int UnsafeNativeMethods.IOleContainer.EnumObjects(int grfFlags, out UnsafeNativeMethods.IEnumUnknown ppenum)
{
ppenum = null;
Debug.Assert(_host != null, "gotta have the avalon activex host");
object ax = _host.ActiveXInstance;
//We support only one control, return that here
//How does one add multiple controls to a container?
if (ax != null
&&
( ((grfFlags & NativeMethods.OLECONTF_EMBEDDINGS) != 0)
||
((grfFlags & NativeMethods.OLECONTF_ONLYIFRUNNING) != 0 &&
_host.ActiveXState == ActiveXHelper.ActiveXState.Running )) )
{
Object[] temp = new Object[1];
temp[0]= ax;
ppenum = new EnumUnknown(temp);
return NativeMethods.S_OK;
}
ppenum = new EnumUnknown(null);
return NativeMethods.S_OK;
}
internal HtmlWindow(HtmlShimManager shimManager, UnsafeNativeMethods.IHTMLWindow2 win)
{
this.htmlWindow2 = win;
Debug.Assert(this.NativeHtmlWindow != null, "The window object should implement IHTMLWindow2");
this.shimManager = shimManager;
}
internal HtmlElement(HtmlShimManager shimManager, UnsafeNativeMethods.IHTMLElement element)
{
this.htmlElement = element;
Debug.Assert(this.NativeHtmlElement != null, "The element object should implement IHTMLElement");
this.shimManager = shimManager;
}
internal HtmlDocument(HtmlShimManager shimManager, UnsafeNativeMethods.IHTMLDocument doc)
{
this.htmlDocument2 = (UnsafeNativeMethods.IHTMLDocument2)doc;
Debug.Assert(this.NativeHtmlDocument2 != null, "The document should implement IHtmlDocument2");
this.shimManager = shimManager;
}
public int GetDropTarget(
UnsafeNativeMethods.IOleDropTarget pDropTarget,
out UnsafeNativeMethods.IOleDropTarget ppDropTarget)
{
// no additional drop target
ppDropTarget = pDropTarget;
return NativeMethods.SRESULTS.S_FALSE;
}
string GetStringHelper(UnsafeNativeMethods.ArgsGetLineStringConsts which)
{
IntPtr ptr_const_this = ConstPointer();
using (var sh = new StringHolder())
{
IntPtr ptr_string = sh.NonConstPointer();
UnsafeNativeMethods.CArgsRhinoGetLine_GetString(ptr_const_this, which, ptr_string);
return sh.ToString();
}
}
public static void EvtSeek(
EventLogHandle resultSet,
long position,
EventLogHandle bookmark,
int timeout,
UnsafeNativeMethods.EvtSeekFlags flags) {
bool status = UnsafeNativeMethods.EvtSeek(resultSet, position, bookmark, timeout, flags);
int win32Error = Marshal.GetLastWin32Error();
if (!status)
EventLogException.Throw(win32Error);
}
/// <summary>
/// Called when removing a delegate from an event, see the
/// GroundPlane.Changed event for an example.
/// </summary>
/// <param name="type">
/// The event watcher type index
/// </param>
/// <param name="value">
/// Delegate to remove
/// </param>
public static void Remove(UnsafeNativeMethods.EventSyncDocumentSettingsChangedFlag type, EventHandler<RenderPropertyChangedEvent> value)
{
// Remove from the dictionary
if (g_event_dictionary.ContainsKey(type)) g_event_dictionary[type] -= value;
// If there are still event hooks set then bail
if (!IsEmpty) return;
// There are no event hooks set so call into rhcmnrdk_c to set the
// callback hook to null.
UnsafeNativeMethods.CRdkCmnEventWatcher_SetDocumentSettingsChangedEventCallback(null, Rhino.Runtime.HostUtils.m_rdk_ew_report);
g_settings_changed_hook = null;
}
int UnsafeNativeMethods.IOleContainer.EnumObjects(int grfFlags, out UnsafeNativeMethods.IEnumUnknown ppenum) {
ppenum = null;
if ((grfFlags & 1) != 0) { // 1 == OLECONTF_EMBEDDINGS
Debug.Assert(parent != null, "gotta have it...");
ArrayList list = new ArrayList();
ListAXControls(list, true);
if (list.Count > 0) {
Object[] temp = new Object[list.Count];
list.CopyTo(temp, 0);
ppenum = new AxHost.EnumUnknown(temp);
return NativeMethods.S_OK;
}
}
ppenum = new AxHost.EnumUnknown(null);
return NativeMethods.S_OK;
}
/// <summary>
/// Called when adding a delegate to a event, see the GroundPlane.Changed
/// event for an example.
/// </summary>
/// <param name="type">
/// The event watcher type index
/// </param>
/// <param name="value">
/// Delegate to add
/// </param>
public static void Add(UnsafeNativeMethods.EventSyncDocumentSettingsChangedFlag type, EventHandler<RenderPropertyChangedEvent> value)
{
// If the callback hook has not been set then set it now
if (g_settings_changed_hook == null)
{
// Call into rhcmnrdk_c to set the callback hook
g_settings_changed_hook = OnSettingsChanged;
UnsafeNativeMethods.CRdkCmnEventWatcher_SetDocumentSettingsChangedEventCallback(g_settings_changed_hook, Rhino.Runtime.HostUtils.m_rdk_ew_report);
}
if (!g_event_dictionary.ContainsKey(type))
g_event_dictionary.Add(type, null);
// Need to do this to ensure the delegate does not get added twice
g_event_dictionary[type] -= value;
// Add the new delegate to the event list
g_event_dictionary[type] += value;
}
internal ODBC32.RetCode BindColumn2(int columnNumber, ODBC32.SQL_C targetType, HandleRef buffer, IntPtr length, IntPtr srLen_or_Ind)
{
ODBC32.RetCode retcode = UnsafeNativeMethods.SQLBindCol(this, checked ((ushort)columnNumber), targetType, buffer, length, srLen_or_Ind);
ODBC.TraceODBC(3, "SQLBindCol", retcode);
return(retcode);
}
/// <summary>
/// Creates raw stylus data from the raw WM_POINTER properties
/// </summary>
/// <param name="pointerData">The current pointer info</param>
/// <param name="tabletDevice">The current TabletDevice</param>
/// <returns>An array of raw pointer data</returns>
private int[] GenerateRawStylusData(PointerData pointerData, PointerTabletDevice tabletDevice)
{
// Since we are copying raw pointer data, we want to use every property supported by this pointer.
// We may never access some of the unknown (unsupported by WPF) properties, but they should be there
// for consumption by the developer.
int pointerPropertyCount = tabletDevice.DeviceInfo.SupportedPointerProperties.Length;
// The data is as wide as the pointer properties and is per history point
int[] rawPointerData = new int[pointerPropertyCount * pointerData.Info.historyCount];
int[] data = new int[0];
// Get the raw data formatted to our supported properties
if (UnsafeNativeMethods.GetRawPointerDeviceData(
pointerData.Info.pointerId,
pointerData.Info.historyCount,
(uint)pointerPropertyCount,
tabletDevice.DeviceInfo.SupportedPointerProperties,
rawPointerData))
{
// Get the X and Y offsets to translate device coords to the origin of the hwnd
int originOffsetX, originOffsetY;
GetOriginOffsetsLogical(out originOffsetX, out originOffsetY);
int numButtons = tabletDevice.DeviceInfo.SupportedPointerProperties.Length - tabletDevice.DeviceInfo.SupportedButtonPropertyIndex;
int rawDataPointSize = (numButtons > 0) ? pointerPropertyCount - numButtons + 1 : pointerPropertyCount;
// Instead of a single entry for each button we use one entry for all buttons so reflect that in the raw data size
data = new int[rawDataPointSize * pointerData.Info.historyCount];
// Skip to the beginning of each stylus point in both the target WPF array and the pointer data array.
// The pointer data is arranged from last point to first point in the history while WPF data is arranged
// the reverse of this (in whole stylus points). Therefore we need to fill backward from pointer data
// via stylus point strides.
for (int i = 0, j = rawPointerData.Length - pointerPropertyCount; i < data.Length; i += rawDataPointSize, j -= pointerPropertyCount)
{
Array.Copy(rawPointerData, j, data, i, rawDataPointSize);
// Apply offsets from the origin to raw pointer data here
data[i + StylusPointDescription.RequiredXIndex] -= originOffsetX;
data[i + StylusPointDescription.RequiredYIndex] -= originOffsetY;
if (numButtons > 0)
{
int buttonIndex = i + rawDataPointSize - 1;
// The last data point probably has garbage in it, so clear it to store button info
data[buttonIndex] = 0;
// Condense any leftover button properties into a single entry
for (int k = tabletDevice.DeviceInfo.SupportedButtonPropertyIndex; k < pointerPropertyCount; k++)
{
int mask = rawPointerData[j + k] << (k - tabletDevice.DeviceInfo.SupportedButtonPropertyIndex);
data[buttonIndex] |= mask;
}
}
}
}
return(data);
}
internal ODBC32.RetCode NumberOfResultColumns(out short columnsAffected)
{
ODBC32.RetCode retcode = UnsafeNativeMethods.SQLNumResultCols(this, out columnsAffected);
ODBC.TraceODBC(3, "SQLNumResultCols", retcode);
return(retcode);
}
private bool GetTriggerValue()
{
return(UnsafeNativeMethods.GetTriggerValue(_native));
}
internal ODBC32.RetCode Prepare(string commandText)
{
ODBC32.RetCode retcode = UnsafeNativeMethods.SQLPrepareW(this, commandText, ODBC32.SQL_NTS);
ODBC.TraceODBC(3, "SQLPrepareW", retcode);
return(retcode);
}
public static extern IntPtr GetHGlobalFromILockBytes(UnsafeNativeMethods.ILockBytes pLkbyt);
void UnsafeNativeMethods.IEnumUnknown.Clone(out UnsafeNativeMethods.IEnumUnknown ppenum)
{
ppenum = new EnumUnknown(this.arr, this.loc);
}
IntPtr NonConstDocSunPointer()
{
return(UnsafeNativeMethods.Rdk_DocSun(m_doc.m_docId));
}
/// <summary>
/// Sets position of the Sun based on azimuth and altitude values.
/// </summary>
/// <param name="azimuthDegrees">The azimut sun angle in degrees.</param>
/// <param name="altitudeDegrees">The altitude sun angle in degrees.</param>
public void SetPosition(double azimuthDegrees, double altitudeDegrees)
{
IntPtr pSun = NonConstPointer();
UnsafeNativeMethods.Rdk_Sun_SetAzimuthAltitude(pSun, azimuthDegrees, altitudeDegrees);
}
public static void ShowHelp()
{
UnsafeNativeMethods.WinExec("HH NTHelp.CHM", NativeMethods.SW_SHOW);
}
public static void MineAbout(string value)
{
UnsafeNativeMethods.ShellAbout(IntPtr.Zero, "扫雷", value, IntPtr.Zero);
}
public static void FillRectangle(IntPtr hDC, int x, int y, int cx, int cy, int color)
{
UnsafeNativeMethods.SetBkColor(hDC, color);
NativeMethods.RECT rect = new NativeMethods.RECT(x, y, x + cx, y + cy);
UnsafeNativeMethods.ExtTextOut(hDC, 0, 0, NativeMethods.ETO_OPAQUE, ref rect, IntPtr.Zero, 0, IntPtr.Zero);
}
/// <summary>
/// Processes the latest WM_POINTER message and forwards it to the WPF input stack.
/// </summary>
/// <param name="pointerId">The id of the pointer message</param>
/// <param name="action">The stylus action being done</param>
/// <param name="timestamp">The time (in ticks) the message arrived</param>
/// <returns>True if successfully processed (handled), false otherwise</returns>
private bool ProcessMessage(uint pointerId, RawStylusActions action, int timestamp)
{
bool handled = false;
// Acquire all pointer data needed
PointerData data = new PointerData(pointerId);
// Only process touch or pen messages, do not process mouse or touchpad
if (data.IsValid &&
(data.Info.pointerType == UnsafeNativeMethods.POINTER_INPUT_TYPE.PT_TOUCH ||
data.Info.pointerType == UnsafeNativeMethods.POINTER_INPUT_TYPE.PT_PEN))
{
uint cursorId = 0;
if (UnsafeNativeMethods.GetPointerCursorId(pointerId, ref cursorId))
{
IntPtr deviceId = data.Info.sourceDevice;
// If we cannot acquire the latest tablet and stylus then wait for the
// next message.
if (!UpdateCurrentTabletAndStylus(deviceId, cursorId))
{
return(false);
}
// Convert move to InAirMove if applicable
if (action == RawStylusActions.Move &&
(!data.Info.pointerFlags.HasFlag(UnsafeNativeMethods.POINTER_FLAGS.POINTER_FLAG_INCONTACT) &&
data.Info.pointerFlags.HasFlag(UnsafeNativeMethods.POINTER_FLAGS.POINTER_FLAG_INRANGE)))
{
action = RawStylusActions.InAirMove;
}
// Generate a raw input to send to the input manager to start the event chain in PointerLogic
RawStylusInputReport rsir =
new RawStylusInputReport(
InputMode.Foreground,
timestamp,
_source.Value,
action,
() => { return(_currentTabletDevice.StylusPointDescription); },
_currentTabletDevice.Id,
_currentStylusDevice.Id,
GenerateRawStylusData(data, _currentTabletDevice))
{
StylusDevice = _currentStylusDevice.StylusDevice,
};
// Send the input report to the stylus plugins if we're not doing a drag and the window
// is currently enabled.
if (!_pointerLogic.Value.InDragDrop && IsWindowEnabled)
{
PointerStylusPlugInManager manager;
if (_pointerLogic.Value.PlugInManagers.TryGetValue(_source.Value, out manager))
{
manager.InvokeStylusPluginCollection(rsir);
}
}
// Update the data in the stylus device with the latest pointer data
_currentStylusDevice.Update(this, _source.Value, data, rsir);
// Call the StylusDevice to process and fire any interactions that
// might have resulted from the input. If the originating inputs
// have been handled, we don't want to generate any gestures.
_currentStylusDevice.UpdateInteractions(rsir);
InputReportEventArgs irea = new InputReportEventArgs(_currentStylusDevice.StylusDevice, rsir)
{
RoutedEvent = InputManager.PreviewInputReportEvent,
};
// Now send the input report
InputManager.UnsecureCurrent.ProcessInput(irea);
// If this is not a primary pointer input, we don't want to
// allow it to go to DefWindowProc, so we should handle it.
// This ensures that primary pointer to mouse promotions
// will occur in multi-touch scenarios.
// We don't use the results of the input processing here as doing
// so could possibly cause some messages of a pointer chain as
// being handled, and some as being unhandled. This results in
// undefined behavior in the WM_POINTER stack.
// <see cref="https://msdn.microsoft.com/en-us/library/windows/desktop/hh454923(v=vs.85).aspx"/>
handled = !_currentStylusDevice.IsPrimary;
}
}
return(handled);
}
int UnsafeNativeMethods.IOleInPlaceSite.GetWindowContext(out UnsafeNativeMethods.IOleInPlaceFrame ppFrame, out UnsafeNativeMethods.IOleInPlaceUIWindow ppDoc,
NativeMethods.COMRECT lprcPosRect, NativeMethods.COMRECT lprcClipRect, NativeMethods.OLEINPLACEFRAMEINFO lpFrameInfo)
{
ppDoc = null;
ppFrame = this.Host.Container;
lprcPosRect.left = (int) this.Host.Bounds.left;
lprcPosRect.top = (int) this.Host.Bounds.top;
lprcPosRect.right = (int) this.Host.Bounds.right;
lprcPosRect.bottom = (int) this.Host.Bounds.bottom;
lprcClipRect = this.Host.Bounds;
if (lpFrameInfo != null)
{
lpFrameInfo.cb = (uint)Marshal.SizeOf(typeof(NativeMethods.OLEINPLACEFRAMEINFO));
lpFrameInfo.fMDIApp = false;
lpFrameInfo.hAccel = IntPtr.Zero;
lpFrameInfo.cAccelEntries = 0;
lpFrameInfo.hwndFrame = this.Host.ParentHandle.Handle;
}
return NativeMethods.S_OK;
}
internal HtmlElementCollection(HtmlShimManager shimManager, UnsafeNativeMethods.IHTMLElementCollection elements) {
this.htmlElementCollection = elements;
this.elementsArray = null;
this.shimManager = shimManager;
Debug.Assert(this.NativeHtmlElementCollection != null, "The element collection object should implement IHTMLElementCollection");
}
/// <summary>
/// Create a non-document controlled Sun
/// </summary>
public Sun()
{
m_pLocalSun = UnsafeNativeMethods.Rdk_SunNew();
m_doc = null;
}
public static extern UnsafeNativeMethods.IStorage StgCreateDocfileOnILockBytes(UnsafeNativeMethods.ILockBytes iLockBytes, int grfMode, int reserved);
/// <summary>
/// Tests for a valid model component name.
/// </summary>
/// <param name="name">The string to validate.</param>
/// <returns>true if the string is a valid model component name, false otherwise.</returns>
/// <since>6.15</since>
public static bool IsValidComponentName(string name)
{
return(UnsafeNativeMethods.ON_ModelComponent_IsValidComponentName(name));
}
public int ResizeBorder(
NativeMethods.COMRECT rect,
UnsafeNativeMethods.IOleInPlaceUIWindow doc,
bool fFrameWindow)
{
// We don't have any UI by default, so pretend we updated it.
return NativeMethods.SRESULTS.S_OK;
}
public uint DataCRC(uint currentRemainder)
{
var const_ptr = ConstPointer();
return(UnsafeNativeMethods.ON_ModelComponent_DataCRC(const_ptr, currentRemainder));
}
internal static IntPtr NarrowBase(IntPtr ptr)
{
return(UnsafeNativeMethods.NativeNarrowBase(ptr));
}
internal State RefreshStorage(UnsafeNativeMethods.IPersistStorage iPersistStorage) {
Debug.Assert(storage != null, "how can we not have a storage object?");
Debug.Assert(iLockBytes != null, "how can we have a storage w/o ILockBytes?");
if (storage == null || iLockBytes == null) return null;
iPersistStorage.Save(storage, true);
storage.Commit(0);
iPersistStorage.HandsOffStorage();
try {
buffer = null;
ms = null;
NativeMethods.STATSTG stat = new NativeMethods.STATSTG();
iLockBytes.Stat(stat, NativeMethods.Ole.STATFLAG_NONAME);
length = (int) stat.cbSize;
buffer = new byte[length];
IntPtr hglobal = UnsafeNativeMethods.GetHGlobalFromILockBytes(iLockBytes);
IntPtr pointer = UnsafeNativeMethods.GlobalLock(new HandleRef(null, hglobal));
try {
if (pointer != IntPtr.Zero) {
Marshal.Copy(pointer, buffer, 0, length);
}
else {
length = 0;
buffer = null;
}
}
finally {
UnsafeNativeMethods.GlobalUnlock(new HandleRef(null, hglobal));
}
}
finally {
iPersistStorage.SaveCompleted(storage);
}
return this;
}
/// <summary>
/// Scans for all attached removable devices
/// </summary>
public Task <IEnumerable <InstalledMountedDriveInfo> > ScanAttachedDrivesAsync()
{
var installedMountedDrives = new SortedList <string, InstalledMountedDriveInfo>();
try
{
var environmentDrives = new Hashtable();
var mountedDrives = new Hashtable();
foreach (var drive in Environment.GetLogicalDrives())
{
environmentDrives.Add(drive, new DriveInfo(drive));
}
var mountedDevices = Registry.LocalMachine.OpenSubKey("SYSTEM\\MountedDevices");
if (mountedDevices?.ValueCount > 0)
{
var mountedDeviceNames = mountedDevices.GetValueNames()
.Where(name => name.StartsWith("\\DosDevices\\"));
foreach (var mountedDeviceName in mountedDeviceNames)
{
var driveLetter = new StringBuilder(mountedDeviceName.Substring(12));
driveLetter.Append("\\");
if (!environmentDrives.ContainsKey(driveLetter.ToString()))
{
continue;
}
var thisDriveInfo = (DriveInfo)environmentDrives[driveLetter.ToString()];
if (thisDriveInfo.DriveType != DriveType.Removable)
{
continue;
}
var bytes = (byte[])mountedDevices.GetValue(mountedDeviceName);
var cleaned = new byte[bytes.Length - 1];
var pointer = 0;
var firstSlashFound = false;
var secondSlashFound = false;
var questionMarkFound = false;
foreach (var character in (byte[])mountedDevices.GetValue(mountedDeviceName))
{
if (character == 0)
{
continue;
}
if (firstSlashFound)
{
if (questionMarkFound)
{
if (secondSlashFound)
{
cleaned[pointer] = character;
pointer++;
}
else
{
if (character == 92)
{
secondSlashFound = true;
}
}
}
else
{
if (character == 63)
{
questionMarkFound = true;
}
}
}
else
{
if (character == 92)
{
firstSlashFound = true;
}
}
}
var finished = new byte[pointer];
for (var i = 0; i < pointer; i++)
{
finished[i] = cleaned[i];
}
mountedDrives.Add(driveLetter,
new MountedDriveInfo(thisDriveInfo, Encoding.Default.GetString(finished).ToUpper()));
}
}
mountedDevices?.Close();
var classGuid = new Guid(UnsafeNativeMethods.GUID_DEVINTERFACE_VOLUME);
var deviceInfoSet = UnsafeNativeMethods.SetupDiGetClassDevs(ref classGuid, 0, IntPtr.Zero,
UnsafeNativeMethods.DIGCF_DEVICEINTERFACE | UnsafeNativeMethods.DIGCF_PRESENT);
if (deviceInfoSet.ToInt32() == UnsafeNativeMethods.INVALID_HANDLE_VALUE)
{
return(Task.FromResult(Enumerable.Empty <InstalledMountedDriveInfo>()));
}
var index = 0;
while (true)
{
var size = 0;
var interfaceData = new UnsafeNativeMethods.SP_DEVICE_INTERFACE_DATA();
var devData = new UnsafeNativeMethods.SP_DEVINFO_DATA();
var detailData = new UnsafeNativeMethods.SP_DEVICE_INTERFACE_DETAIL_DATA();
if (
!UnsafeNativeMethods.SetupDiEnumDeviceInterfaces(deviceInfoSet, null, ref classGuid, index,
interfaceData))
{
break;
}
UnsafeNativeMethods.SetupDiGetDeviceInterfaceDetail(deviceInfoSet, interfaceData, IntPtr.Zero, 0,
ref size, devData);
var buffer = Marshal.AllocHGlobal(size);
// for 64 bit system, the size needs to be 8, for 32 bit system, the size needs to be 5
if (IntPtr.Size == 8)
{
detailData.cbSize = 8;
}
else
{
detailData.cbSize = Marshal.SizeOf(typeof(UnsafeNativeMethods.SP_DEVICE_INTERFACE_DETAIL_DATA));
}
Marshal.StructureToPtr(detailData, buffer, false);
if (!UnsafeNativeMethods.SetupDiGetDeviceInterfaceDetail(deviceInfoSet, interfaceData,
buffer, size, ref size, devData))
{
Marshal.FreeHGlobal(buffer);
}
var pDevicePath = (IntPtr)((int)buffer + Marshal.SizeOf(typeof(int)));
var devicePath = Marshal.PtrToStringAuto(pDevicePath);
if (devicePath != null)
{
devicePath = devicePath.ToUpper();
Marshal.FreeHGlobal(buffer);
foreach (MountedDriveInfo mountedDrive in mountedDrives.Values)
{
if (!devicePath.Contains(mountedDrive.RegistryInfo))
{
continue;
}
var thisMountedDrive = new InstalledMountedDriveInfo(mountedDrive.DriveInfo,
devData.devInst, (UnsafeNativeMethods.DeviceCapabilities)
UnsafeNativeMethods.GetProperty(deviceInfoSet, devData,
UnsafeNativeMethods.SPDRP_CAPABILITIES, 0),
UnsafeNativeMethods.GetProperty(deviceInfoSet, devData,
UnsafeNativeMethods.SPDRP_PHYSICAL_DEVICE_OBJECT_NAME, "bad name"));
try
{
// Check attempts to add duplicate drives when the SetupDiEnumDeviceInterfaces call does not break
// on first call for a particular drive (multiple device interfaces).
if (installedMountedDrives.ContainsKey(thisMountedDrive.Description) == false)
{
installedMountedDrives.Add(thisMountedDrive.Description, thisMountedDrive);
}
}
catch (Exception)
{
// Ignore unspecified exceptions and continue building mounted drives
}
}
}
index++;
}
}
catch (Exception ex)
{
_logger.Log(ex);
}
_events.GetEvent <ScanDrivesCompletedEvent>().Publish(installedMountedDrives.Values.AsEnumerable());
return(Task.FromResult(installedMountedDrives.Values.AsEnumerable()));
}
internal ODBC32.RetCode BindColumn3(int columnNumber, ODBC32.SQL_C targetType, IntPtr srLen_or_Ind)
{
ODBC32.RetCode retcode = UnsafeNativeMethods.SQLBindCol(this, checked ((ushort)columnNumber), targetType, ADP.PtrZero, ADP.PtrZero, srLen_or_Ind);
ODBC.TraceODBC(3, "SQLBindCol", retcode);
return(retcode);
}
/// <summary>
/// Helper function to set or clear a bit in the flags field.
/// </summary>
/// <param name="flag">The Flag bit to set or clear.</param>
/// <param name="value">True to set, false to clear the bit in the flags field.</param>
private void SetFlag(UnsafeNativeMethods.TASKDIALOG_FLAGS flag, bool value)
{
if (value)
{
this.flags |= flag;
}
else
{
this.flags &= ~flag;
}
}
public void WriteData(string fileName, string templateFileName, byte[] data, ref long readTime)
{
if (!fileName.ToLowerInvariant().EndsWith(".config", StringComparison.Ordinal))
{
throw new Exception(SR.GetString(SR.Can_not_access_files_other_than_config));
}
bool fileExists = File.Exists(fileName);
FileInfo fileInfo = null;
FileAttributes fileAttributes = FileAttributes.Normal;
string tempFile = null;
Exception createStreamExcep = null;
FileStream tempFileStream = null;
long lastWriteTicks = 0;
long utcNowTicks = 0;
/////////////////////////////////////////////////////////////////////
// Step 1: If the file exists, then make sure it hasn't been written to since it was read
if (fileExists && File.GetLastWriteTimeUtc(fileName).Ticks > readTime)
{
throw new Exception(SR.GetString(SR.File_changed_since_read, fileName));
}
/////////////////////////////////////////////////////////////////////
// Step 2: Get the security-descriptor and attributes of the file
if (fileExists)
{
try {
fileInfo = new FileInfo(fileName);
fileAttributes = fileInfo.Attributes;
} catch { }
if (((int)(fileAttributes & (FileAttributes.ReadOnly | FileAttributes.Hidden))) != 0)
{
throw new Exception(SR.GetString(SR.File_is_read_only, fileName));
}
}
/////////////////////////////////////////////////////////////////////
// Step 3: Generate a temp file name. Make sure that the temp file doesn't exist
tempFile = fileName + "." + GetRandomFileExt() + ".tmp";
for (int iter = 0; File.Exists(tempFile); iter++) // if it exists, then use a different random name
{
if (iter > 100) // don't try more than 100 times
{
throw new Exception(SR.GetString(SR.Unable_to_create_temp_file));
}
else
{
tempFile = fileName + "." + GetRandomFileExt() + ".tmp";
}
}
/////////////////////////////////////////////////////////////////////
// Step 4: Write the buffer to the temp file, and move it to the actual file
try {
tempFileStream = new FileStream(tempFile, FileMode.CreateNew, FileAccess.Write, FileShare.ReadWrite, data.Length, FileOptions.WriteThrough);
tempFileStream.Write(data, 0, data.Length);
} catch (Exception e) {
createStreamExcep = e;
} finally {
if (tempFileStream != null)
{
tempFileStream.Close();
}
}
if (createStreamExcep != null)
{
try {
File.Delete(tempFile);
} catch { }
throw createStreamExcep;
}
if (fileExists)
{
try {
DuplicateFileAttributes(fileName, tempFile);
} catch { }
}
else if (templateFileName != null)
{
try {
DuplicateTemplateAttributes(fileName, templateFileName);
} catch { }
}
/////////////////////////////////////////////////////////////////////
// Step 4: Move the temp filt to the actual file
if (!UnsafeNativeMethods.MoveFileEx(tempFile, fileName, MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH))
{
try {
File.Delete(tempFile);
} catch { }
Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
}
/////////////////////////////////////////////////////////////////////
// Step 5: Set the attributes of the file
if (fileExists)
{
fileInfo = new FileInfo(fileName);
fileInfo.Attributes = fileAttributes;
}
/////////////////////////////////////////////////////////////////////
// Step 6: Record the current time as the read-time
lastWriteTicks = File.GetLastWriteTimeUtc(fileName).Ticks;
utcNowTicks = DateTime.UtcNow.Ticks;
readTime = (utcNowTicks > lastWriteTicks ? utcNowTicks : lastWriteTicks);
}
private unsafe void SetSearchPreferences(UnsafeNativeMethods.IDirectorySearch adsSearch, bool findMoreThanOne)
{
ArrayList prefList = new ArrayList();
AdsSearchPreferenceInfo info;
// search scope
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.SEARCH_SCOPE;
info.vValue = new AdsValueHelper((int)SearchScope).GetStruct();
prefList.Add(info);
// size limit
if (_sizeLimit != 0 || !findMoreThanOne)
{
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.SIZE_LIMIT;
info.vValue = new AdsValueHelper(findMoreThanOne ? SizeLimit : 1).GetStruct();
prefList.Add(info);
}
// time limit
if (ServerTimeLimit >= new TimeSpan(0))
{
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.TIME_LIMIT;
info.vValue = new AdsValueHelper((int)ServerTimeLimit.TotalSeconds).GetStruct();
prefList.Add(info);
}
// propertyNamesOnly
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.ATTRIBTYPES_ONLY;
info.vValue = new AdsValueHelper(PropertyNamesOnly).GetStruct();
prefList.Add(info);
// Timeout
if (ClientTimeout >= new TimeSpan(0))
{
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.TIMEOUT;
info.vValue = new AdsValueHelper((int)ClientTimeout.TotalSeconds).GetStruct();
prefList.Add(info);
}
// page size
if (PageSize != 0)
{
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.PAGESIZE;
info.vValue = new AdsValueHelper(PageSize).GetStruct();
prefList.Add(info);
}
// page time limit
if (ServerPageTimeLimit >= new TimeSpan(0))
{
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.PAGED_TIME_LIMIT;
info.vValue = new AdsValueHelper((int)ServerPageTimeLimit.TotalSeconds).GetStruct();
prefList.Add(info);
}
// chase referrals
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.CHASE_REFERRALS;
info.vValue = new AdsValueHelper((int)ReferralChasing).GetStruct();
prefList.Add(info);
// asynchronous
if (Asynchronous == true)
{
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.ASYNCHRONOUS;
info.vValue = new AdsValueHelper(Asynchronous).GetStruct();
prefList.Add(info);
}
// tombstone
if (Tombstone == true)
{
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.TOMBSTONE;
info.vValue = new AdsValueHelper(Tombstone).GetStruct();
prefList.Add(info);
}
// attributescopequery
if (_attributeScopeQuerySpecified)
{
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.ATTRIBUTE_QUERY;
info.vValue = new AdsValueHelper(AttributeScopeQuery, AdsType.ADSTYPE_CASE_IGNORE_STRING).GetStruct();
prefList.Add(info);
}
// derefalias
if (DerefAlias != DereferenceAlias.Never)
{
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.DEREF_ALIASES;
info.vValue = new AdsValueHelper((int)DerefAlias).GetStruct();
prefList.Add(info);
}
// securitymask
if (SecurityMasks != SecurityMasks.None)
{
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.SECURITY_MASK;
info.vValue = new AdsValueHelper((int)SecurityMasks).GetStruct();
prefList.Add(info);
}
// extendeddn
if (ExtendedDN != ExtendedDN.None)
{
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.EXTENDED_DN;
info.vValue = new AdsValueHelper((int)ExtendedDN).GetStruct();
prefList.Add(info);
}
// dirsync
if (directorySynchronizationSpecified)
{
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.DIRSYNC;
info.vValue = new AdsValueHelper(DirectorySynchronization.GetDirectorySynchronizationCookie(), AdsType.ADSTYPE_PROV_SPECIFIC).GetStruct();
prefList.Add(info);
if (DirectorySynchronization.Option != DirectorySynchronizationOptions.None)
{
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.DIRSYNC_FLAG;
info.vValue = new AdsValueHelper((int)DirectorySynchronization.Option).GetStruct();
prefList.Add(info);
}
}
IntPtr ptrToFree = (IntPtr)0;
IntPtr ptrVLVToFree = (IntPtr)0;
IntPtr ptrVLVContexToFree = (IntPtr)0;
try
{
// sort
if (Sort.PropertyName != null && Sort.PropertyName.Length > 0)
{
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.SORT_ON;
AdsSortKey sortKey = new AdsSortKey();
sortKey.pszAttrType = Marshal.StringToCoTaskMemUni(Sort.PropertyName);
ptrToFree = sortKey.pszAttrType; // so we can free it later.
sortKey.pszReserved = (IntPtr)0;
sortKey.fReverseOrder = (Sort.Direction == SortDirection.Descending) ? -1 : 0;
byte[] sortKeyBytes = new byte[Marshal.SizeOf(sortKey)];
Marshal.Copy((INTPTR_INTPTRCAST)(&sortKey), sortKeyBytes, 0, sortKeyBytes.Length);
info.vValue = new AdsValueHelper(sortKeyBytes, AdsType.ADSTYPE_PROV_SPECIFIC).GetStruct();
prefList.Add(info);
}
// vlv
if (directoryVirtualListViewSpecified)
{
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.VLV;
AdsVLV vlvValue = new AdsVLV();
vlvValue.beforeCount = _vlv.BeforeCount;
vlvValue.afterCount = _vlv.AfterCount;
vlvValue.offset = _vlv.Offset;
//we need to treat the empty string as null here
if (_vlv.Target.Length != 0)
vlvValue.target = Marshal.StringToCoTaskMemUni(_vlv.Target);
else
vlvValue.target = IntPtr.Zero;
ptrVLVToFree = vlvValue.target;
if (_vlv.DirectoryVirtualListViewContext == null)
{
vlvValue.contextIDlength = 0;
vlvValue.contextID = (IntPtr)0;
}
else
{
vlvValue.contextIDlength = _vlv.DirectoryVirtualListViewContext.context.Length;
vlvValue.contextID = Marshal.AllocCoTaskMem(vlvValue.contextIDlength);
ptrVLVContexToFree = vlvValue.contextID;
Marshal.Copy(_vlv.DirectoryVirtualListViewContext.context, 0, vlvValue.contextID, vlvValue.contextIDlength);
}
IntPtr vlvPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(AdsVLV)));
byte[] vlvBytes = new byte[Marshal.SizeOf(vlvValue)];
try
{
Marshal.StructureToPtr(vlvValue, vlvPtr, false);
Marshal.Copy(vlvPtr, vlvBytes, 0, vlvBytes.Length);
}
finally
{
Marshal.FreeHGlobal(vlvPtr);
}
info.vValue = new AdsValueHelper(vlvBytes, AdsType.ADSTYPE_PROV_SPECIFIC).GetStruct();
prefList.Add(info);
}
// cacheResults
if (_cacheResultsSpecified)
{
info = new AdsSearchPreferenceInfo();
info.dwSearchPref = (int)AdsSearchPreferences.CACHE_RESULTS;
info.vValue = new AdsValueHelper(CacheResults).GetStruct();
prefList.Add(info);
}
//
// now make the call
//
AdsSearchPreferenceInfo[] prefs = new AdsSearchPreferenceInfo[prefList.Count];
for (int i = 0; i < prefList.Count; i++)
{
prefs[i] = (AdsSearchPreferenceInfo)prefList[i];
}
DoSetSearchPrefs(adsSearch, prefs);
}
finally
{
if (ptrToFree != (IntPtr)0)
Marshal.FreeCoTaskMem(ptrToFree);
if (ptrVLVToFree != (IntPtr)0)
Marshal.FreeCoTaskMem(ptrVLVToFree);
if (ptrVLVContexToFree != (IntPtr)0)
Marshal.FreeCoTaskMem(ptrVLVContexToFree);
}
}
void SetBool(UnsafeNativeMethods.FileWriteOptionsBoolConsts which, bool value)
{
if (m_bDoDelete) // means this is not "const"
UnsafeNativeMethods.CRhinoFileWriteOptions_SetBool(m_ptr, which, value);
}
/// <summary>
/// Locks the component Name property.
/// </summary>
/// <since>6.0</since>
public void LockName()
{
IntPtr non_const_ptr = NonConstPointer();
UnsafeNativeMethods.ON_ModelComponent_LockName(non_const_ptr);
}
internal ODBC32.RetCode SetStatementAttribute(ODBC32.SQL_ATTR attribute, IntPtr value, ODBC32.SQL_IS stringLength)
{
ODBC32.RetCode retcode = UnsafeNativeMethods.SQLSetStmtAttrW(this, (int)attribute, value, (int)stringLength);
ODBC.TraceODBC(3, "SQLSetStmtAttrW", retcode);
return(retcode);
}
int UnsafeNativeMethods.IPropertyBag.Read(string pszPropName, ref object pVar, UnsafeNativeMethods.IErrorLog pErrorLog) {
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "Reading property " + pszPropName + " from OCXState propertybag.");
if (!bag.Contains(pszPropName))
return NativeMethods.E_INVALIDARG;
pVar = bag[pszPropName];
Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "\tValue=" + ((pVar == null) ? "<null>" : pVar.ToString()));
// The EE returns a VT_EMPTY for a null. The problem is that visual basic6 expects the caller to respect the
// "hint" it gives in the VariantType. For eg., for a VT_BSTR, it expects that the callee will null
// out the BSTR field of the variant. Since, the EE or us cannot do anything about this, we will return
// a E_INVALIDARG rather than let visual basic6 crash.
//
return (pVar == null) ? NativeMethods.E_INVALIDARG : NativeMethods.S_OK;
}
/// <summary>
/// Informs the developer if a particular model component type will require uniqueness within a document.
/// This is currently true with render materials and model geometry; false otherwise.
/// </summary>
/// <param name="type">The type to check.</param>
/// <returns>true with render materials and model geometry; false otherwise.</returns>
/// <since>6.0</since>
public static bool ModelComponentTypeRequiresUniqueName(ModelComponentType type)
{
return(UnsafeNativeMethods.ON_ModelComponent_RequiresUniqueName(type));
}
private static void DoSetSearchPrefs(UnsafeNativeMethods.IDirectorySearch adsSearch, AdsSearchPreferenceInfo[] prefs)
{
int structSize = Marshal.SizeOf(typeof(AdsSearchPreferenceInfo));
IntPtr ptr = Marshal.AllocHGlobal((IntPtr)(structSize * prefs.Length));
try
{
IntPtr tempPtr = ptr;
for (int i = 0; i < prefs.Length; i++)
{
Marshal.StructureToPtr(prefs[i], tempPtr, false);
tempPtr = IntPtr.Add(tempPtr, structSize);
}
adsSearch.SetSearchPreference(ptr, prefs.Length);
// Check for the result status for all preferences
tempPtr = ptr;
for (int i = 0; i < prefs.Length; i++)
{
int status = Marshal.ReadInt32(tempPtr, 32);
if (status != 0)
{
int prefIndex = prefs[i].dwSearchPref;
string property = "";
switch (prefIndex)
{
case (int)AdsSearchPreferences.SEARCH_SCOPE:
property = "SearchScope";
break;
case (int)AdsSearchPreferences.SIZE_LIMIT:
property = "SizeLimit";
break;
case (int)AdsSearchPreferences.TIME_LIMIT:
property = "ServerTimeLimit";
break;
case (int)AdsSearchPreferences.ATTRIBTYPES_ONLY:
property = "PropertyNamesOnly";
break;
case (int)AdsSearchPreferences.TIMEOUT:
property = "ClientTimeout";
break;
case (int)AdsSearchPreferences.PAGESIZE:
property = "PageSize";
break;
case (int)AdsSearchPreferences.PAGED_TIME_LIMIT:
property = "ServerPageTimeLimit";
break;
case (int)AdsSearchPreferences.CHASE_REFERRALS:
property = "ReferralChasing";
break;
case (int)AdsSearchPreferences.SORT_ON:
property = "Sort";
break;
case (int)AdsSearchPreferences.CACHE_RESULTS:
property = "CacheResults";
break;
case (int)AdsSearchPreferences.ASYNCHRONOUS:
property = "Asynchronous";
break;
case (int)AdsSearchPreferences.TOMBSTONE:
property = "Tombstone";
break;
case (int)AdsSearchPreferences.ATTRIBUTE_QUERY:
property = "AttributeScopeQuery";
break;
case (int)AdsSearchPreferences.DEREF_ALIASES:
property = "DerefAlias";
break;
case (int)AdsSearchPreferences.SECURITY_MASK:
property = "SecurityMasks";
break;
case (int)AdsSearchPreferences.EXTENDED_DN:
property = "ExtendedDn";
break;
case (int)AdsSearchPreferences.DIRSYNC:
property = "DirectorySynchronization";
break;
case (int)AdsSearchPreferences.DIRSYNC_FLAG:
property = "DirectorySynchronizationFlag";
break;
case (int)AdsSearchPreferences.VLV:
property = "VirtualListView";
break;
}
throw new InvalidOperationException(Res.GetString(Res.DSSearchPreferencesNotAccepted, property));
}
tempPtr = IntPtr.Add(tempPtr, structSize);
}
}
finally
{
Marshal.FreeHGlobal(ptr);
}
}
/// <summary>
/// Informs the developer if a particular model component type will require case-ignoring searching within a document.
/// This is currently true with groups; false otherwise.
/// </summary>
/// <param name="type">True if the component ignores case.</param>
/// <since>6.0</since>
public static bool ModelComponentTypeIgnoresCase(ModelComponentType type)
{
return(UnsafeNativeMethods.ON_ModelComponent_UniqueNameIgnoresCase(type));
}
bool GetBool(UnsafeNativeMethods.FileWriteOptionsBoolConsts which)
{
return UnsafeNativeMethods.CRhinoFileWriteOptions_GetBool(m_ptr, which);
}
/// <summary>
/// Informs the developer if a particular model component type will include the hash of the parent.
/// </summary>
/// <param name="type">True if the component includes parent hash.</param>
/// <since>6.0</since>
public static bool ModelComponentTypeIncludesParent(ModelComponentType type)
{
return(UnsafeNativeMethods.ON_ModelComponent_UniqueNameIncludesParent(type));
}
int UnsafeNativeMethods.IOleClientSite.GetContainer(out UnsafeNativeMethods.IOleContainer container)
{
container = this.Host.Container;
return NativeMethods.S_OK;
}
/// <summary>
/// Is called when the object associated with this data is transformed. If you override this
/// function, make sure to call the base class if you want the stored Transform to be updated.
/// </summary>
/// <param name="transform">The transform being applied.</param>
protected virtual void OnTransform(Geometry.Transform transform)
{
UnsafeNativeMethods.ON_UserData_OnTransform(m_native_pointer, ref transform);
}
internal int CallISAPI(UnsafeNativeMethods.CallISAPIFunc iFunction, byte [] bufIn, byte [] bufOut) {
if (_wr == null || !(_wr is System.Web.Hosting.ISAPIWorkerRequest))
throw new HttpException(SR.GetString(SR.Cannot_call_ISAPI_functions));
#if !FEATURE_PAL // FEATURE_PAL does not enable IIS-based hosting features
return ((System.Web.Hosting.ISAPIWorkerRequest) _wr).CallISAPI(iFunction, bufIn, bufOut);
#else // !FEATURE_PAL
throw new NotImplementedException ("ROTORTODO");
#endif // !FEATURE_PAL
}
/// <summary>
/// Checks for the existence of a specific type of userdata in this list
/// Both .NET and native userdata is checked
/// </summary>
/// <param name="userdataId"></param>
/// <returns></returns>
public bool Contains(Guid userdataId)
{
IntPtr const_ptr_onobject = m_parent.ConstPointer();
return(UnsafeNativeMethods.CRhCmnUserData_Contains(const_ptr_onobject, userdataId));
}
private static string TranslateReturnCode(UnsafeNativeMethods.CredUIReturnCodes result)
{
return string.Format(CultureInfo.CurrentUICulture, Properties.Resources.CredUIReturn, result.ToString());
}
/// <summary>
/// Removes all user data from this geometry.
/// </summary>
/// <remarks>User <see cref="Remove"/> to delete a single, known, item.</remarks>
public void Purge()
{
IntPtr non_const_ptr_onobject = m_parent.NonConstPointer();
UnsafeNativeMethods.ON_UserData_PurgeUserData(non_const_ptr_onobject);
}
public static extern int RegisterDragDrop(HandleRef hwnd, UnsafeNativeMethods.IOleDropTarget target);
public static DataFormat GetDataFormat(string format)
{
if (format == null)
{
throw new ArgumentNullException("format");
}
if (format == string.Empty)
{
throw new ArgumentException(SR.Get(SRID.DataObject_EmptyFormatNotAllowed));
}
// Ensures the predefined Win32 data formats into our format list.
EnsurePredefined();
// Lock the data format list to obtains the mutual-exclusion.
lock (_formatListlock)
{
int formatId;
int index;
// It is much faster to do a case sensitive search here. So do
// the case sensitive compare first, then the expensive one.
//
for (int n = 0; n < _formatList.Count; n++)
{
DataFormat formatItem;
formatItem = (DataFormat)_formatList[n];
if (formatItem.Name.Equals(format))
{
return(formatItem);
}
}
for (int n = 0; n < _formatList.Count; n++)
{
DataFormat formatItem;
formatItem = (DataFormat)_formatList[n];
if (String.Compare(formatItem.Name, format, StringComparison.OrdinalIgnoreCase) == 0)
{
return(formatItem);
}
}
// In the most cases the default formats return earlier. If we got here
// then this is an attempt to register a new format which is not ok in partial trust.
SecurityHelper.DemandUnmanagedCode();
// Reigster the this format string.
formatId = UnsafeNativeMethods.RegisterClipboardFormat(format);
if (formatId == 0)
{
throw new System.ComponentModel.Win32Exception();
}
index = _formatList.Add(new DataFormat(format, formatId));
return((DataFormat)_formatList[index]);
}
}
public static extern UnsafeNativeMethods.IStorage StgOpenStorageOnILockBytes(UnsafeNativeMethods.ILockBytes iLockBytes, UnsafeNativeMethods.IStorage pStgPriority, int grfMode, int sndExcluded, int reserved);
/// <summary>
/// Invokes the operation OnDataAvailable on the <see cref="DataReaderListener" /> objects attached to contained <see cref="DataReader" />
/// entities with a <see cref="StatusKind.DataAvailableStatus" /> that is considered changed.
/// </summary>
/// <remarks>
/// This operation is typically invoked from the OnDataOnReaders operation in the <see cref="SubscriberListener" />. That way the
/// <see cref="SubscriberListener" /> can delegate to the <see cref="DataReaderListener" /> objects the handling of the data.
/// </remarks>
/// <returns>The <see cref="ReturnCode" /> that indicates the operation result.</returns>
public ReturnCode NotifyDataReaders()
{
return(UnsafeNativeMethods.NotifyDataReaders(_native));
}
static unsafe string EncodeObject(ref object data, UnsafeNativeMethods.EventData* dataDescriptor, byte* dataBuffer)
{
dataDescriptor->Reserved = 0;
string sRet = data as string;
if (sRet != null)
{
dataDescriptor->Size = (uint)((sRet.Length + 1) * 2);
return sRet;
}
if (data is IntPtr)
{
dataDescriptor->Size = (uint)sizeof(IntPtr);
IntPtr* intptrPtr = (IntPtr*)dataBuffer;
*intptrPtr = (IntPtr)data;
dataDescriptor->DataPointer = (ulong)intptrPtr;
}
else if (data is int)
{
dataDescriptor->Size = (uint)sizeof(int);
int* intptrPtr = (int*)dataBuffer;
*intptrPtr = (int)data;
dataDescriptor->DataPointer = (ulong)intptrPtr;
}
else if (data is long)
{
dataDescriptor->Size = (uint)sizeof(long);
long* longptr = (long*)dataBuffer;
*longptr = (long)data;
dataDescriptor->DataPointer = (ulong)longptr;
}
else if (data is uint)
{
dataDescriptor->Size = (uint)sizeof(uint);
uint* uintptr = (uint*)dataBuffer;
*uintptr = (uint)data;
dataDescriptor->DataPointer = (ulong)uintptr;
}
else if (data is UInt64)
{
dataDescriptor->Size = (uint)sizeof(ulong);
UInt64* ulongptr = (ulong*)dataBuffer;
*ulongptr = (ulong)data;
dataDescriptor->DataPointer = (ulong)ulongptr;
}
else if (data is char)
{
dataDescriptor->Size = (uint)sizeof(char);
char* charptr = (char*)dataBuffer;
*charptr = (char)data;
dataDescriptor->DataPointer = (ulong)charptr;
}
else if (data is byte)
{
dataDescriptor->Size = (uint)sizeof(byte);
byte* byteptr = (byte*)dataBuffer;
*byteptr = (byte)data;
dataDescriptor->DataPointer = (ulong)byteptr;
}
else if (data is short)
{
dataDescriptor->Size = (uint)sizeof(short);
short* shortptr = (short*)dataBuffer;
*shortptr = (short)data;
dataDescriptor->DataPointer = (ulong)shortptr;
}
else if (data is sbyte)
{
dataDescriptor->Size = (uint)sizeof(sbyte);
sbyte* sbyteptr = (sbyte*)dataBuffer;
*sbyteptr = (sbyte)data;
dataDescriptor->DataPointer = (ulong)sbyteptr;
}
else if (data is ushort)
{
dataDescriptor->Size = (uint)sizeof(ushort);
ushort* ushortptr = (ushort*)dataBuffer;
*ushortptr = (ushort)data;
dataDescriptor->DataPointer = (ulong)ushortptr;
}
else if (data is float)
{
dataDescriptor->Size = (uint)sizeof(float);
float* floatptr = (float*)dataBuffer;
*floatptr = (float)data;
dataDescriptor->DataPointer = (ulong)floatptr;
}
else if (data is double)
{
dataDescriptor->Size = (uint)sizeof(double);
double* doubleptr = (double*)dataBuffer;
*doubleptr = (double)data;
dataDescriptor->DataPointer = (ulong)doubleptr;
}
else if (data is bool)
{
dataDescriptor->Size = (uint)sizeof(bool);
bool* boolptr = (bool*)dataBuffer;
*boolptr = (bool)data;
dataDescriptor->DataPointer = (ulong)boolptr;
}
else if (data is Guid)
{
dataDescriptor->Size = (uint)sizeof(Guid);
Guid* guidptr = (Guid*)dataBuffer;
*guidptr = (Guid)data;
dataDescriptor->DataPointer = (ulong)guidptr;
}
else if (data is decimal)
{
dataDescriptor->Size = (uint)sizeof(decimal);
decimal* decimalptr = (decimal*)dataBuffer;
*decimalptr = (decimal)data;
dataDescriptor->DataPointer = (ulong)decimalptr;
}
else if (data is Boolean)
{
dataDescriptor->Size = (uint)sizeof(Boolean);
Boolean* booleanptr = (Boolean*)dataBuffer;
*booleanptr = (Boolean)data;
dataDescriptor->DataPointer = (ulong)booleanptr;
}
else
{
// Everything else is a just a string
sRet = data.ToString();
dataDescriptor->Size = (uint)((sRet.Length + 1) * 2);
return sRet;
}
return null;
}
/// <summary>
/// Indicates that the application is about to access the data samples in any of the <see cref="DataReader" /> objects attached to
/// the <see cref="Subscriber" />.
/// </summary>
/// <remarks>
/// <para>The application is required to use this operation only if <see cref="PresentationQosPolicy" /> of the <see cref="Subscriber" /> to which the
/// <see cref="DataReader" /> belongs has the <see cref="PresentationQosPolicy.AccessScope" /> set to
/// <see cref="PresentationQosPolicyAccessScopeKind.GroupPresentationQos" />.</para>
/// <para>In the aforementioned case, the operation BeginAccess must be called prior to calling any of the sample-accessing operations,
/// namely: GetDataReaders on the <see cref="Subscriber" /> and Read, Take on any <see cref="DataReader" />.
/// Otherwise the sample-accessing operations will return the error <see cref="ReturnCode.PreconditionNotMet" />. Once the application has
/// finished accessing the data samples it must call <see cref="EndAccess" />.</para>
/// <para>The calls to BeginAccess/<see cref="EndAccess" /> may be nested. In that case, the application must call <see cref="EndAccess" /> as many times as it
/// called BeginAccess.</para>
/// </remarks>
/// <returns>The <see cref="ReturnCode" /> that indicates the operation result.</returns>
public ReturnCode BeginAccess()
{
return(UnsafeNativeMethods.BeginAccess(_native));
}
/// <summary>
/// Shows the UI.
/// </summary>
/// <param name="dwID">The dw ID.</param>
/// <param name="activeObject">The active object.</param>
/// <param name="commandTarget">The command target.</param>
/// <param name="frame">The frame.</param>
/// <param name="doc">The doc.</param>
/// <returns></returns>
public int ShowUI(
int dwID,
UnsafeNativeMethods.IOleInPlaceActiveObject activeObject,
NativeMethods.IOleCommandTarget commandTarget,
UnsafeNativeMethods.IOleInPlaceFrame frame,
UnsafeNativeMethods.IOleInPlaceUIWindow doc)
{
// default means we don't have any UI, and control should show its UI
return NativeMethods.SRESULTS.S_FALSE;
}
/// <summary>
/// Indicates that the application has finished accessing the data samples in <see cref="DataReader" /> objects managed by the <see cref="Subscriber" />.
/// </summary>
/// <remarks>
/// <para>This operation must be used to 'close' a corresponding <see cref="BeginAccess" />.</para>
/// <para>After calling EndAccess the application should no longer access any of the data or <see cref="SampleInfo" /> elements returned from the
/// sample-accessing operations. This call must close a previous call to <see cref="BeginAccess" /> otherwise the operation will return the error
/// <see cref="ReturnCode.PreconditionNotMet" />.</para>
/// </remarks>
/// <returns>The <see cref="ReturnCode" /> that indicates the operation result.</returns>
public ReturnCode EndAccess()
{
return(UnsafeNativeMethods.EndAccess(_native));
}
