private unsafe void FileSystemEventCallback(
FSEventStreamRef streamRef,
IntPtr clientCallBackInfo,
size_t numEvents,
byte **eventPaths,
FSEventStreamEventFlags *eventFlags,
FSEventStreamEventId *eventIds)
{
// Try to get the actual watcher from our weak reference. We maintain a weak reference most of the time
// so as to avoid a rooted cycle that would prevent our processing loop from ever ending
// if the watcher is dropped by the user without being disposed. If we can't get the watcher,
// there's nothing more to do (we can't raise events), so bail.
FileSystemWatcher watcher;
if (!_weakWatcher.TryGetTarget(out watcher))
{
CancellationCallback();
return;
}
ExecutionContext context = _context;
if (context is null)
{
// Flow suppressed, just run here
ProcessEvents(numEvents.ToInt32(), eventPaths, new Span <FSEventStreamEventFlags>(eventFlags, numEvents.ToInt32()), new Span <FSEventStreamEventId>(eventIds, numEvents.ToInt32()), watcher);
}
else
{
ExecutionContext.Run(
context,
(object o) => ((RunningInstance)o).ProcessEvents(numEvents.ToInt32(), eventPaths, new Span <FSEventStreamEventFlags>(eventFlags, numEvents.ToInt32()), new Span <FSEventStreamEventId>(eventIds, numEvents.ToInt32()), watcher),
this);
}
}
void OnRenderObject()
{
//if (Input.GetKey(KeyCode.Joystick1Button0))
//{
// currentOverlayType = OverlayType.None;
//}
//else if (Input.GetKey(KeyCode.Joystick1Button1))
//{
// currentOverlayType = OverlayType.OverlayShowLod;
//}
//else
//{
// currentOverlayType = OverlayType.Overlay;
//}
//int eyeNum = (Camera.current.depth == (int)RenderEventType.RightEyeEndFrame) ? 1 : 0;
//Matrix4x4 mv_Left = LeftAnchor.worldToCameraMatrix * this.transform.localToWorldMatrix * toOculusMatrix;
//IVR_SetOverlay(LeftAnchor.targetTexture.GetNativeTextureID(), 0);
System.IntPtr texutre = mCamera.targetTexture.GetNativeTexturePtr();
mActivity.Interface_javaobjcall("SetEyeTexture", texutre.ToInt32(), (int)eyeType);
//Matrix4x4 mv_Right = RightAnchor.worldToCameraMatrix * this.transform.localToWorldMatrix * toOculusMatrix;
//IVR_SetOverlay(RightAnchor.targetTexture.GetNativeTextureID(), 1);
//mActivity.Interface_javaobjcall("SetEyeTexture", RightAnchor.targetTexture.GetNativeTextureID(), 1);
}
// display windows dialog
private void displayDialog(System.IntPtr wndHandle, int dialogToShow)
{
// prep variables
int i = -1;
int iHandle = 0;
// get parent handle
if (wndHandle != System.IntPtr.Zero)
{
iHandle = wndHandle.ToInt32();
}
// choose dialog to show bassed on
if (dialogToShow == 1)
{
i = WNetConnectionDialog(iHandle, RESOURCETYPE_DISK);
}
else if (dialogToShow == 2)
{
i = WNetDisconnectDialog(iHandle, RESOURCETYPE_DISK);
}
// if error returned, throw
if (i > 0)
{
throw new System.ComponentModel.Win32Exception(i);
}
}
private void StyleComboBox_DrawItem(object sender, System.Windows.Forms.DrawItemEventArgs e)
{
if (this.iarray_0.Count != 0)
{
e.DrawBackground();
try
{
IStyleGalleryItem styleGalleryItem = this.iarray_0.get_Element(e.Index) as IStyleGalleryItem;
if (styleGalleryItem != null)
{
System.IntPtr hdc = e.Graphics.GetHdc();
IStyleDraw styleDraw = StyleDrawFactory.CreateStyleDraw(styleGalleryItem.Item);
if (styleDraw != null)
{
e.Bounds.Inflate(-2, -4);
styleDraw.Draw(hdc.ToInt32(), e.Bounds, 72.0, 1.0);
}
e.Graphics.ReleaseHdc(hdc);
}
else
{
Brush brush = new SolidBrush(e.ForeColor);
e.Graphics.DrawString(base.Items[e.Index].ToString(), e.Font, brush, (float)(e.Bounds.Left + 3),
(float)(e.Bounds.Top + 3));
}
}
catch
{
}
}
}
private void SymbolItem_Paint(object sender, System.Windows.Forms.PaintEventArgs e)
{
if (this.object_0 != null)
{
if (this.bool_0 && this.object_0 is IMarkerSymbol)
{
System.Drawing.Point pt = new System.Drawing.Point(base.ClientSize.Width / 2,
base.ClientRectangle.Top + 2);
System.Drawing.Point pt2 = new System.Drawing.Point(base.ClientSize.Width / 2,
base.ClientRectangle.Bottom - 2);
e.Graphics.DrawLine(Pens.Green, pt, pt2);
pt.X = base.ClientRectangle.Left + 2;
pt.Y = base.ClientSize.Height / 2;
pt2.X = base.ClientRectangle.Right - 2;
pt2.Y = base.ClientSize.Height / 2;
e.Graphics.DrawLine(Pens.Green, pt, pt2);
}
else if (this.object_0 is ITextSymbol)
{
System.Drawing.Point point = new System.Drawing.Point(base.ClientSize.Width / 2,
base.ClientRectangle.Height + 2);
e.Graphics.DrawEllipse(Pens.Black, point.X, point.Y, 2, 2);
}
System.IntPtr hdc = e.Graphics.GetHdc();
this.DrawSymbol(hdc.ToInt32(), base.ClientRectangle, this.object_0);
e.Graphics.ReleaseHdc(hdc);
}
}
private void ColorRampComboBox_DrawItem(object sender, System.Windows.Forms.DrawItemEventArgs e)
{
if (this.iarray_0.Count != 0)
{
e.DrawBackground();
System.IntPtr hdc = e.Graphics.GetHdc();
this.DrawColorRamp(hdc.ToInt32(), e.Bounds, (IColorRamp)this.iarray_0.get_Element(e.Index));
e.Graphics.ReleaseHdc(hdc);
}
}
/// <summary>
/// Converts Byte array to Unity Color32 array.
/// </summary>
/// <param name="bytes">Input Byte array.</param>
/// <param name="colors">Output Color32 array.</param>
public static void ByteArrayToColor32Array(byte[] bytes, out Color32[] colors)
{
int size = bytes.Length;
colors = new Color32[size / 4];
System.IntPtr ptr = CvUtil.GetIntPtr(bytes);
for (int i = 0; i < size / 4; i++)
{
colors[i] = (Color32)Marshal.PtrToStructure(ptr, typeof(Color32));
ptr = new System.IntPtr(ptr.ToInt32() + 4);
}
}
public void StyleGalleryItemToBmp(Bitmap bitmap_0, double double_0, double double_1)
{
Size size = bitmap_0.Size;
Graphics graphics = Graphics.FromImage(bitmap_0);
System.IntPtr hdc = graphics.GetHdc();
Rectangle rectangle_ = new Rectangle(0, 0, size.Width, size.Height);
this.Draw(hdc.ToInt32(), rectangle_, double_0, double_1);
graphics.ReleaseHdc(hdc);
graphics.Dispose();
}
public void ControllCamWithScreenshot()
{
string dName = "".PadRight(100);
string dVersion = "".PadRight(100);
System.IntPtr hWndC = capCreateCaptureWindowA("VFW Capture", WS_POPUP | WS_CHILD, 0, 0, 320, 240, 0, 0); // get camera handle
SendMessage(hWndC, WM_CAP_DRIVER_CONNECT, 0, 0); // connect to camera
string path = System.Environment.GetEnvironmentVariable("USERPROFILE") + "\\Pictures\\" + System.DateTime.Now.ToString("yyyy.MM.dd HH.mm.ss") + ".jpg";
System.IntPtr hBmp = System.Runtime.InteropServices.Marshal.StringToHGlobalAnsi(path);
SendMessage(hWndC, WM_CAP_SAVEDIB, 0, hBmp.ToInt32()); // save screenshot
SendMessage(hWndC, WM_CAP_DRIVER_DISCONNECT, 0, 0); // turn off the camera
}
private unsafe void FileSystemEventCallback(
FSEventStreamRef streamRef,
IntPtr clientCallBackInfo,
size_t numEvents,
byte **eventPaths,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)]
Interop.EventStream.FSEventStreamEventFlags[] eventFlags,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)]
FSEventStreamEventId[] eventIds)
{
Debug.Assert((eventPaths != null) && (numEvents.ToInt32() == eventFlags.Length) && (numEvents.ToInt32() == eventIds.Length));
// Try to get the actual watcher from our weak reference. We maintain a weak reference most of the time
// so as to avoid a rooted cycle that would prevent our processing loop from ever ending
// if the watcher is dropped by the user without being disposed. If we can't get the watcher,
// there's nothing more to do (we can't raise events), so bail.
FileSystemWatcher watcher;
if (!_weakWatcher.TryGetTarget(out watcher))
{
CancellationCallback();
return;
}
ExecutionContext context = _context;
if (context is null)
{
// Flow suppressed, just run here
ProcessEvents(numEvents.ToInt32(), eventPaths, eventFlags, eventIds, watcher);
}
else
{
ExecutionContext.Run(
context,
(object o) => ((RunningInstance)o).ProcessEvents(numEvents.ToInt32(), eventPaths, eventFlags, eventIds, watcher),
this);
}
}
public Bitmap StyleGalleryItemToBmp(Size size_0, double double_0, double double_1)
{
Bitmap bitmap = new Bitmap(size_0.Width, size_0.Height);
Graphics graphics = Graphics.FromImage(bitmap);
System.IntPtr hdc = graphics.GetHdc();
Rectangle rectangle_ = new Rectangle(0, 0, size_0.Width, size_0.Height);
this.Draw(hdc.ToInt32(), rectangle_, double_0, double_1);
graphics.ReleaseHdc(hdc);
graphics.Dispose();
return(bitmap);
}
private void StyleButton_Paint(object sender, System.Windows.Forms.PaintEventArgs e)
{
if (this.object_0 != null)
{
System.IntPtr hdc = e.Graphics.GetHdc();
if (this.istyleDraw_0 != null)
{
Rectangle clipRectangle = e.ClipRectangle;
clipRectangle.Inflate(-3, -3);
this.istyleDraw_0.Draw(hdc.ToInt32(), clipRectangle, 72.0, 1.0);
}
e.Graphics.ReleaseHdc(hdc);
}
}
private int HookCallbackProc(int nCode, System.IntPtr wParam, System.IntPtr lParam)
{
if (nCode < 0)
{
return(ColorPicker_NativeMethods.CallNextHookEx(m_hHook, nCode, wParam, lParam));
}
else
{
//Marshall the data from the callback.
WinUtil.KeyboardHookStruct hookstruct =
(WinUtil.KeyboardHookStruct)
System.Runtime.InteropServices.Marshal.PtrToStructure(lParam, typeof(WinUtil.KeyboardHookStruct));
if (OnKeyDown != null && wParam.ToInt32() == WinUtil.WM_KEYDOWN)
{
var key = (System.Windows.Forms.Keys)hookstruct.vkCode;
const Keys shift = System.Windows.Forms.Keys.Shift;
const Keys control = System.Windows.Forms.Keys.Control;
Keys modkeys = System.Windows.Forms.Control.ModifierKeys;
if ((modkeys & shift) == shift)
{
key |= shift;
}
if ((modkeys & control) == control)
{
key |= control;
}
var e = new System.Windows.Forms.KeyEventArgs(key);
e.Handled = false;
OnKeyDown(e);
if (e.Handled)
{
return(1);
}
}
int result = 0;
if (m_hHook != 0)
{
result = ColorPicker_NativeMethods.CallNextHookEx(m_hHook, nCode, wParam, lParam);
}
return(result);
}
}
private void NewSymbolButton_Paint(object sender, System.Windows.Forms.PaintEventArgs e)
{
if (this.object_0 != null)
{
System.IntPtr hdc = e.Graphics.GetHdc();
IStyleDraw styleDraw = StyleDrawFactory.CreateStyleDraw(this.object_0);
if (styleDraw != null)
{
Rectangle clipRectangle = e.ClipRectangle;
clipRectangle.Inflate(-3, -3);
styleDraw.Draw(hdc.ToInt32(), clipRectangle, 96.0, 1.0);
}
e.Graphics.ReleaseHdc(hdc);
}
}
private void SymbolListBox_DrawItem(object sender, System.Windows.Forms.DrawItemEventArgs e)
{
if (base.Items.Count != 0)
{
SymbolListItem symbolListItem = (SymbolListItem)base.Items[e.Index];
e.DrawBackground();
Bitmap image;
if (symbolListItem.m_bVisible)
{
image =
new Bitmap(
base.GetType().Assembly.GetManifestResourceStream("Yutai.ArcGIS.Common.SymbolLib.Check.bmp"));
}
else
{
image =
new Bitmap(
base.GetType()
.Assembly.GetManifestResourceStream("Yutai.ArcGIS.Common.SymbolLib.UnCheck.bmp"));
}
Bitmap image2;
if (symbolListItem.m_bLockColor)
{
image2 =
new Bitmap(
base.GetType().Assembly.GetManifestResourceStream("Yutai.ArcGIS.Common.SymbolLib.Lock.bmp"));
}
else
{
image2 =
new Bitmap(
base.GetType()
.Assembly.GetManifestResourceStream("Yutai.ArcGIS.Common.SymbolLib.UnLock.bmp"));
}
Rectangle rect = new Rectangle(2, e.Bounds.Y + (e.Bounds.Height - 16) / 2, 16, 16);
Rectangle rect2 = new Rectangle(e.Bounds.Right - 21, e.Bounds.Y + (e.Bounds.Height - 16) / 2, 16, 16);
Rectangle rectangle = new Rectangle(rect.Right + 2, e.Bounds.Y + 1, e.Bounds.Width - 46,
e.Bounds.Height - 2);
e.Graphics.DrawImageUnscaled(image, rect);
e.Graphics.DrawImageUnscaled(image2, rect2);
e.Graphics.FillRectangle(Brushes.White, rectangle);
Graphics graphics = e.Graphics;
System.IntPtr hdc = graphics.GetHdc();
this.DrawSymbol(hdc.ToInt32(), rectangle, symbolListItem.m_pSymbol);
graphics.ReleaseHdc(hdc);
}
}
static System.IntPtr WndProc(System.IntPtr hwnd, int msg, System.IntPtr wparam, System.IntPtr lparam, ref bool handled)
{
switch (msg)
{
case 0x0312: // WM_HOTKEY
switch (wparam.ToInt32())
{
case 0:
System.Diagnostics.Debug.WriteLine("ホットキー「Alt + Shift + A」が押された。");
break;
case 1:
System.Diagnostics.Debug.WriteLine("ホットキー「Ctrl + Windows + B」が押された。");
break;
}
break;
}
return(System.IntPtr.Zero);
}
private void RepresentationruleListBox_DrawItem(object sender, System.Windows.Forms.DrawItemEventArgs e)
{
if (base.Items.Count != 0)
{
RepresentationruleListBox.RepresentationRuleWrap representationRuleWrap =
(RepresentationruleListBox.RepresentationRuleWrap)base.Items[e.Index];
e.DrawBackground();
string s = "(" + representationRuleWrap.RuleID.ToString() + ") " + representationRuleWrap.Name;
Brush brush = new SolidBrush(e.ForeColor);
e.Graphics.DrawString(s, this.Font, brush, (float)e.Bounds.X, (float)e.Bounds.Y);
brush.Dispose();
System.IntPtr hdc = e.Graphics.GetHdc();
IOutputContext outputContext = new OutputContext();
IPoint point = new ESRI.ArcGIS.Geometry.Point();
point.PutCoords((double)(e.Bounds.X + e.Bounds.Width / 2), (double)(e.Bounds.Y + e.Bounds.Height / 2 + 10));
tagRECT tagRECT_ = default(tagRECT);
tagRECT_.left = e.Bounds.Left + 10;
tagRECT_.right = e.Bounds.Right - 10;
tagRECT_.top = e.Bounds.Top + 10;
tagRECT_.bottom = e.Bounds.Bottom - 5;
outputContext.Init(1.0, 1.5, 96.0, 0.0, point, ref tagRECT_, hdc.ToInt32());
IGeometry geometry;
if (this.esriGeometryType_0 == esriGeometryType.esriGeometryPolygon)
{
geometry = this.method_1(tagRECT_);
}
else if (this.esriGeometryType_0 == esriGeometryType.esriGeometryPolyline)
{
geometry = this.method_2(tagRECT_);
}
else
{
geometry = new ESRI.ArcGIS.Geometry.Point();
(geometry as IPoint).PutCoords((double)((tagRECT_.left + tagRECT_.right) / 2),
(double)((tagRECT_.top + tagRECT_.bottom) / 2));
}
representationRuleWrap.RepresentationRule.Draw(-1, outputContext, geometry, geometry.Envelope);
e.Graphics.ReleaseHdc(hdc);
}
}
protected override void OnPaint(System.Windows.Forms.PaintEventArgs paintEventArgs_0)
{
if (this.object_0 == null)
{
this.Text = "无法绘制符号!";
}
else
{
this.Text = "";
System.IntPtr hdc = paintEventArgs_0.Graphics.GetHdc();
Rectangle clipRectangle = paintEventArgs_0.ClipRectangle;
clipRectangle.Inflate(-3, -3);
if (this.istyleDraw_0 != null)
{
this.istyleDraw_0.Draw(hdc.ToInt32(), clipRectangle, 72.0, 1.0);
}
else
{
paintEventArgs_0.Graphics.DrawString(this.Text, this.Font, Brushes.Black, clipRectangle);
}
paintEventArgs_0.Graphics.ReleaseHdc(hdc);
base.OnPaint(paintEventArgs_0);
}
}
private unsafe void FileSystemEventCallback(
FSEventStreamRef streamRef,
IntPtr clientCallBackInfo,
size_t numEvents,
byte **eventPaths,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)]
Interop.EventStream.FSEventStreamEventFlags[] eventFlags,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)]
FSEventStreamEventId[] eventIds)
{
Debug.Assert((eventPaths != null) && (numEvents.ToInt32() == eventFlags.Length) && (numEvents.ToInt32() == eventIds.Length));
// Try to get the actual watcher from our weak reference. We maintain a weak reference most of the time
// so as to avoid a rooted cycle that would prevent our processing loop from ever ending
// if the watcher is dropped by the user without being disposed. If we can't get the watcher,
// there's nothing more to do (we can't raise events), so bail.
FileSystemWatcher watcher;
if (!_weakWatcher.TryGetTarget(out watcher))
{
CancellationCallback();
return;
}
ExecutionContext.Run(_context, delegate
{
// Since renames come in pairs, when we find the first we need to search for the next one. Once we find it, we'll add it to this
// list so when the for-loop comes across it, we'll skip it since it's already been processed as part of the original of the pair.
List <FSEventStreamEventId> handledRenameEvents = null;
Memory <char>[] events = new Memory <char> [numEvents.ToInt32()];
ProcessEvents();
for (long i = 0; i < numEvents.ToInt32(); i++)
{
ReadOnlySpan <char> path = events[i].Span;
Debug.Assert(path[path.Length - 1] != '/', "Trailing slashes on events is not supported");
// Match Windows and don't notify us about changes to the Root folder
if (_fullDirectory.Length >= path.Length && path.Equals(_fullDirectory.AsSpan(0, path.Length), StringComparison.OrdinalIgnoreCase))
{
continue;
}
WatcherChangeTypes eventType = 0;
// First, we should check if this event should kick off a re-scan since we can't really rely on anything after this point if that is true
if (ShouldRescanOccur(eventFlags[i]))
{
watcher.OnError(new ErrorEventArgs(new IOException(SR.FSW_BufferOverflow, (int)eventFlags[i])));
break;
}
else if ((handledRenameEvents != null) && (handledRenameEvents.Contains(eventIds[i])))
{
// If this event is the second in a rename pair then skip it
continue;
}
else if (CheckIfPathIsNested(path) && ((eventType = FilterEvents(eventFlags[i])) != 0))
{
// The base FileSystemWatcher does a match check against the relative path before combining with
// the root dir; however, null is special cased to signify the root dir, so check if we should use that.
ReadOnlySpan <char> relativePath = ReadOnlySpan <char> .Empty;
if (!path.Equals(_fullDirectory, StringComparison.OrdinalIgnoreCase))
{
// Remove the root directory to get the relative path
relativePath = path.Slice(_fullDirectory.Length);
}
// Raise a notification for the event
if (((eventType & WatcherChangeTypes.Changed) > 0))
{
watcher.NotifyFileSystemEventArgs(WatcherChangeTypes.Changed, relativePath);
}
if (((eventType & WatcherChangeTypes.Created) > 0))
{
watcher.NotifyFileSystemEventArgs(WatcherChangeTypes.Created, relativePath);
}
if (((eventType & WatcherChangeTypes.Deleted) > 0))
{
watcher.NotifyFileSystemEventArgs(WatcherChangeTypes.Deleted, relativePath);
}
if (((eventType & WatcherChangeTypes.Renamed) > 0))
{
// Find the rename that is paired to this rename, which should be the next rename in the list
long pairedId = FindRenameChangePairedChange(i, eventFlags);
if (pairedId == long.MinValue)
{
// Getting here means we have a rename without a pair, meaning it should be a create for the
// move from unwatched folder to watcher folder scenario or a move from the watcher folder out.
// Check if the item exists on disk to check which it is
// Don't send a new notification if we already sent one for this event.
if (DoesItemExist(path, IsFlagSet(eventFlags[i], Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemIsFile)))
{
if ((eventType & WatcherChangeTypes.Created) == 0)
{
watcher.NotifyFileSystemEventArgs(WatcherChangeTypes.Created, relativePath);
}
}
else if ((eventType & WatcherChangeTypes.Deleted) == 0)
{
watcher.NotifyFileSystemEventArgs(WatcherChangeTypes.Deleted, relativePath);
}
}
else
{
// Remove the base directory prefix and add the paired event to the list of
// events to skip and notify the user of the rename
ReadOnlySpan <char> newPathRelativeName = events[pairedId].Span.Slice(_fullDirectory.Length);
watcher.NotifyRenameEventArgs(WatcherChangeTypes.Renamed, newPathRelativeName, relativePath);
// Create a new list, if necessary, and add the event
if (handledRenameEvents == null)
{
handledRenameEvents = new List <FSEventStreamEventId>();
}
handledRenameEvents.Add(eventIds[pairedId]);
}
}
}
ArraySegment <char> underlyingArray;
if (MemoryMarshal.TryGetArray(events[i], out underlyingArray))
{
ArrayPool <char> .Shared.Return(underlyingArray.Array);
}
}
this._context = ExecutionContext.Capture();
void ProcessEvents()
{
for (int i = 0; i < events.Length; i++)
{
int byteCount = 0;
Debug.Assert(eventPaths[i] != null);
byte *temp = eventPaths[i];
// Finds the position of null character.
while (*temp != 0)
{
temp++;
byteCount++;
}
Debug.Assert(byteCount > 0, "Empty events are not supported");
events[i] = new Memory <char>(ArrayPool <char> .Shared.Rent(Encoding.UTF8.GetMaxCharCount(byteCount)));
int charCount;
// Converting an array of bytes to UTF-8 char array
charCount = Encoding.UTF8.GetChars(new ReadOnlySpan <byte>(eventPaths[i], byteCount), events[i].Span);
events[i] = events[i].Slice(0, charCount);
}
}
}, null);
private void FileSystemEventCallback(
FSEventStreamRef streamRef,
IntPtr clientCallBackInfo,
size_t numEvents,
String[] eventPaths,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)]
Interop.EventStream.FSEventStreamEventFlags[] eventFlags,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)]
FSEventStreamEventId[] eventIds)
{
Debug.Assert((numEvents.ToInt32() == eventPaths.Length) && (numEvents.ToInt32() == eventFlags.Length) && (numEvents.ToInt32() == eventIds.Length));
// Try to get the actual watcher from our weak reference. We maintain a weak reference most of the time
// so as to avoid a rooted cycle that would prevent our processing loop from ever ending
// if the watcher is dropped by the user without being disposed. If we can't get the watcher,
// there's nothing more to do (we can't raise events), so bail.
FileSystemWatcher watcher;
if (!_weakWatcher.TryGetTarget(out watcher))
{
CancellationCallback();
return;
}
// Since renames come in pairs, when we find the first we need to search for the next one. Once we find it, we'll add it to this
// list so when the for-loop comes across it, we'll skip it since it's already been processed as part of the original of the pair.
List <FSEventStreamEventId> handledRenameEvents = null;
for (long i = 0; i < numEvents.ToInt32(); i++)
{
Debug.Assert(eventPaths[i].Length > 0, "Empty events are not supported");
Debug.Assert(eventPaths[i][eventPaths[i].Length - 1] != '/', "Trailing slashes on events is not supported");
// Match Windows and don't notify us about changes to the Root folder
string path = eventPaths[i];
if (string.Compare(path, 0, _fullDirectory, 0, path.Length, StringComparison.OrdinalIgnoreCase) == 0)
{
continue;
}
WatcherChangeTypes eventType = 0;
// First, we should check if this event should kick off a re-scan since we can't really rely on anything after this point if that is true
if (ShouldRescanOccur(eventFlags[i]))
{
watcher.OnError(new ErrorEventArgs(new IOException(SR.FSW_BufferOverflow, (int)eventFlags[i])));
break;
}
else if ((handledRenameEvents != null) && (handledRenameEvents.Contains(eventIds[i])))
{
// If this event is the second in a rename pair then skip it
continue;
}
else if (CheckIfPathIsNested(path) && ((eventType = FilterEvents(eventFlags[i], path)) != 0))
{
// The base FileSystemWatcher does a match check against the relative path before combining with
// the root dir; however, null is special cased to signify the root dir, so check if we should use that.
string relativePath = null;
if (path.Equals(_fullDirectory, StringComparison.OrdinalIgnoreCase) == false)
{
// Remove the root directory to get the relative path
relativePath = path.Remove(0, _fullDirectory.Length);
}
// Raise a notification for the event
if (((eventType & WatcherChangeTypes.Changed) > 0))
{
watcher.NotifyFileSystemEventArgs(WatcherChangeTypes.Changed, relativePath);
}
if (((eventType & WatcherChangeTypes.Created) > 0))
{
watcher.NotifyFileSystemEventArgs(WatcherChangeTypes.Created, relativePath);
}
if (((eventType & WatcherChangeTypes.Deleted) > 0))
{
watcher.NotifyFileSystemEventArgs(WatcherChangeTypes.Deleted, relativePath);
}
if (((eventType & WatcherChangeTypes.Renamed) > 0))
{
// Find the rename that is paired to this rename, which should be the next rename in the list
long pairedId = FindRenameChangePairedChange(i, eventPaths, eventFlags, eventIds);
if (pairedId == long.MinValue)
{
// Getting here means we have a rename without a pair, meaning it should be a create for the
// move from unwatched folder to watcher folder scenario or a move from the watcher folder out.
// Check if the item exists on disk to check which it is
// Don't send a new notification if we already sent one for this event.
if (DoesItemExist(path, IsFlagSet(eventFlags[i], Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemIsFile)))
{
if ((eventType & WatcherChangeTypes.Created) == 0)
{
watcher.NotifyFileSystemEventArgs(WatcherChangeTypes.Created, relativePath);
}
}
else if ((eventType & WatcherChangeTypes.Deleted) == 0)
{
watcher.NotifyFileSystemEventArgs(WatcherChangeTypes.Deleted, relativePath);
}
}
else
{
// Remove the base directory prefix and add the paired event to the list of
// events to skip and notify the user of the rename
string newPathRelativeName = eventPaths[pairedId].Remove(0, _fullDirectory.Length);
watcher.NotifyRenameEventArgs(WatcherChangeTypes.Renamed, newPathRelativeName, relativePath);
// Create a new list, if necessary, and add the event
if (handledRenameEvents == null)
{
handledRenameEvents = new List <FSEventStreamEventId>();
}
handledRenameEvents.Add(eventIds[pairedId]);
}
}
}
}
}
private void FileSystemEventCallback(
FSEventStreamRef streamRef,
IntPtr clientCallBackInfo,
size_t numEvents,
String[] eventPaths,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)]
Interop.EventStream.FSEventStreamEventFlags[] eventFlags,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)]
FSEventStreamEventId[] eventIds)
{
Debug.Assert((numEvents.ToInt32() == eventPaths.Length) && (numEvents.ToInt32() == eventFlags.Length) && (numEvents.ToInt32() == eventIds.Length));
// Since renames come in pairs, when we find the first we need to search for the next one. Once we find it, we'll add it to this
// list so when the for-loop comes across it, we'll skip it since it's already been processed as part of the original of the pair.
List <FSEventStreamEventId> handledRenameEvents = null;
for (long i = 0; i < numEvents.ToInt32(); i++)
{
// First, we should check if this event should kick off a re-scan since we can't really rely on anything after this point if that is true
if (ShouldRescanOccur(eventFlags[i]))
{
OnError(new ErrorEventArgs(new IOException(SR.FSW_BufferOverflow, (int)eventFlags[i])));
break;
}
else if ((handledRenameEvents != null) && (handledRenameEvents.Contains(eventIds[i])))
{
// If this event is the second in a rename pair then skip it
continue;
}
else if ((DoesPathPassNameFilter(eventPaths[i])) && ((_filterFlags & eventFlags[i]) != 0))
{
// Remove the base directory prefix (including trailing / that OS X adds)
string relativePath = eventPaths[i].Remove(0, _directory.Length + 1);
// Check if this is a rename
if ((eventFlags[i] & Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemRenamed) == Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemRenamed)
{
// Find the rename that is paired to this rename, which should be the next rename in the list
long pairedId = FindRenameChangePairedChange(i, eventPaths, eventFlags, eventIds);
if (pairedId == long.MinValue)
{
OnError(new ErrorEventArgs(new ArgumentOutOfRangeException("pairedId")));
}
else
{
// Remove the base directory prefix (including trailing / that OS X adds) and
// add the paired event to the list of events to skip and notify the user of the rename
string newPathRelativeName = eventPaths[pairedId].Remove(0, _directory.Length + 1);
NotifyRenameEventArgs(WatcherChangeTypes.Renamed, newPathRelativeName, relativePath);
// Create a new list, if necessary, and add the event
if (handledRenameEvents == null)
{
handledRenameEvents = new List <FSEventStreamEventId>();
}
handledRenameEvents.Add(eventIds[pairedId]);
}
}
else
{
// Note: the order here matters due to coalescing since two events (such as a mod followed by a delete) could be coalesced into one notification
// So look for deletes first since those will mean the listening app can't do anything with the item since it doesn't exist (such as stat
// the file to determine what exactly changed, in this example).
if ((eventFlags[i] & Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemRemoved) == Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemRemoved)
{
NotifyFileSystemEventArgs(WatcherChangeTypes.Deleted, relativePath);
}
else if ((eventFlags[i] & Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemCreated) == Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemCreated)
{
// Next look for creates since a create + modification coalesced could confuse apps since a file they haven't heard of yet would get a mod event
NotifyFileSystemEventArgs(WatcherChangeTypes.Created, relativePath);
}
else if (((eventFlags[i] & Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemInodeMetaMod) == Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemInodeMetaMod) ||
((eventFlags[i] & Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemModified) == Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemModified) ||
((eventFlags[i] & Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemFinderInfoMod) == Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemChangeOwner) ||
((eventFlags[i] & Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemXattrMod) == Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemXattrMod))
{
// Everything else is a modification
NotifyFileSystemEventArgs(WatcherChangeTypes.Changed, relativePath);
}
}
}
}
}
protected override void OnPaint(System.Windows.Forms.PaintEventArgs paintEventArgs_0)
{
base.OnPaint(paintEventArgs_0);
StringFormat stringFormat = new StringFormat();
stringFormat.LineAlignment = StringAlignment.Center;
if (base.View == System.Windows.Forms.View.Details)
{
for (int i = 0; i < base.Items.Count; i++)
{
Rectangle bounds = base.Items[i].GetBounds(System.Windows.Forms.ItemBoundsPortion.Icon);
if (bounds.Bottom >= 0 && bounds.Top <= base.ClientRectangle.Height)
{
if (base.Items[i].SubItems[0].Text.Length == 0)
{
bounds.Width = base.Columns[0].Width + bounds.Width;
}
Rectangle bounds2 = base.Items[i].GetBounds(System.Windows.Forms.ItemBoundsPortion.Entire);
float x = (float)(bounds2.Left + bounds.Width);
float y = (float)bounds2.Top;
RectangleF rectangleF = new RectangleF(x, y, 0f, (float)bounds2.Height);
if (base.Items[i].Tag != null)
{
Graphics graphics = paintEventArgs_0.Graphics;
System.IntPtr hdc = graphics.GetHdc();
if (base.Items[i].Tag is ISymbol)
{
this.DrawSymbol(hdc.ToInt32(), bounds, base.Items[i].Tag);
}
else if (base.Items[i].Tag is IStyleGalleryItem)
{
this.DrawSymbol(hdc.ToInt32(), bounds, (base.Items[i].Tag as IStyleGalleryItem).Item);
}
graphics.ReleaseHdc(hdc);
}
SolidBrush solidBrush;
SolidBrush solidBrush2;
if (base.Items[i].Selected)
{
solidBrush = new SolidBrush(base.Items[i].ForeColor);
solidBrush2 = new SolidBrush(base.Items[i].BackColor);
}
else
{
solidBrush = new SolidBrush(base.Items[i].BackColor);
solidBrush2 = new SolidBrush(base.Items[i].ForeColor);
}
for (int j = 0; j < base.Items[i].SubItems.Count; j++)
{
if (j > 1)
{
rectangleF.X += (float)base.Columns[j - 1].Width;
}
else if (j == 1)
{
rectangleF.X = rectangleF.X + (float)base.Columns[0].Width - (float)bounds.Width;
}
if (j == 0)
{
rectangleF.Width = (float)(base.Columns[j].Width - bounds.Width);
}
else
{
rectangleF.Width = (float)base.Columns[j].Width;
}
if (j == 0 || base.FullRowSelect)
{
if (j != 0 || base.Items[i].SubItems[j].Text.Length != 0)
{
paintEventArgs_0.Graphics.FillRectangle(solidBrush, rectangleF);
paintEventArgs_0.Graphics.DrawString(base.Items[i].SubItems[j].Text, this.Font,
solidBrush2, rectangleF);
}
}
else
{
paintEventArgs_0.Graphics.DrawString(base.Items[i].SubItems[j].Text, this.Font,
Brushes.Black, rectangleF);
}
}
solidBrush.Dispose();
solidBrush2.Dispose();
}
}
}
else if (base.View == System.Windows.Forms.View.LargeIcon || base.View == System.Windows.Forms.View.SmallIcon ||
base.View == System.Windows.Forms.View.List)
{
for (int i = 0; i < base.Items.Count; i++)
{
Rectangle bounds = base.Items[i].GetBounds(System.Windows.Forms.ItemBoundsPortion.Icon);
if (bounds.Bottom >= 0 && bounds.Top <= base.ClientRectangle.Height)
{
if (base.Items[i].Tag != null)
{
Graphics graphics = paintEventArgs_0.Graphics;
System.IntPtr hdc = graphics.GetHdc();
if (base.Items[i].Tag is ISymbol)
{
this.DrawSymbol(hdc.ToInt32(), bounds, base.Items[i].Tag);
}
else if (base.Items[i].Tag is IStyleGalleryItem)
{
this.DrawSymbol(hdc.ToInt32(), bounds, (base.Items[i].Tag as IStyleGalleryItem).Item);
}
graphics.ReleaseHdc(hdc);
}
SolidBrush solidBrush;
SolidBrush solidBrush2;
if (base.Items[i].Selected)
{
solidBrush = new SolidBrush(base.Items[i].ForeColor);
solidBrush2 = new SolidBrush(base.Items[i].BackColor);
}
else
{
solidBrush = new SolidBrush(base.Items[i].BackColor);
solidBrush2 = new SolidBrush(base.Items[i].ForeColor);
}
Rectangle bounds2 = base.Items[i].GetBounds(System.Windows.Forms.ItemBoundsPortion.Label);
RectangleF rectangleF = new RectangleF((float)bounds2.X, (float)bounds2.Y,
(float)bounds2.Width, (float)bounds2.Height);
paintEventArgs_0.Graphics.FillRectangle(solidBrush, rectangleF);
paintEventArgs_0.Graphics.DrawString(base.Items[i].Text, this.Font, solidBrush2, rectangleF,
stringFormat);
solidBrush.Dispose();
solidBrush2.Dispose();
}
}
}
}
// forwards to the 64-bit aware version.
public static LONG GetWindowLong(HWND hWnd, int nIndex)
{
LONG_PTR ret = GetWindowLongPtr(hWnd, nIndex);
return(ret.ToInt32());
}
// forwards to the 64-bit aware version.
public static LONG SetWindowLong(HWND hWnd, int nIndex, LONG dwNewLong)
{
LONG_PTR ret = SetWindowLongPtr(hWnd, nIndex, new LONG_PTR(dwNewLong));
return(ret.ToInt32());
}
private void FileSystemEventCallback(
FSEventStreamRef streamRef,
IntPtr clientCallBackInfo,
size_t numEvents,
String[] eventPaths,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)]
Interop.EventStream.FSEventStreamEventFlags[] eventFlags,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)]
FSEventStreamEventId[] eventIds)
{
Debug.Assert((numEvents.ToInt32() == eventPaths.Length) && (numEvents.ToInt32() == eventFlags.Length) && (numEvents.ToInt32() == eventIds.Length));
// Since renames come in pairs, when we find the first we need to search for the next one. Once we find it, we'll add it to this
// list so when the for-loop comes across it, we'll skip it since it's already been processed as part of the original of the pair.
List <FSEventStreamEventId> handledRenameEvents = null;
for (long i = 0; i < numEvents.ToInt32(); i++)
{
// We need to special case the root path for pattern matching, so cache the path this way in case it is the root
// and use it for pattern matching. We'll go back to the eventPaths[i] to get the actual path for notifications
string path = eventPaths[i];
if (path.Equals(_fullDirectory, StringComparison.OrdinalIgnoreCase))
{
path += "/.";
}
// First, we should check if this event should kick off a re-scan since we can't really rely on anything after this point if that is true
if (ShouldRescanOccur(eventFlags[i]))
{
OnError(new ErrorEventArgs(new IOException(SR.FSW_BufferOverflow, (int)eventFlags[i])));
break;
}
else if ((handledRenameEvents != null) && (handledRenameEvents.Contains(eventIds[i])))
{
// If this event is the second in a rename pair then skip it
continue;
}
else if ((DoesPathPassNameFilter(path)) && ((_filterFlags & eventFlags[i]) != 0))
{
// The base FileSystemWatcher does a match check against the relative path before combining with
// the root dir; however, null is special cased to signify the root dir, so check if we should use that.
string relativePath = null;
if (eventPaths[i].Equals(_fullDirectory, StringComparison.OrdinalIgnoreCase) == false)
{
// Check if the event path, with the root directory removed, begins with a / and
// if so, remove it; otherwise, just remove the root path (which contains a trailing /)
if (eventPaths[i][_fullDirectory.Length] == '/')
{
relativePath = eventPaths[i].Remove(0, _fullDirectory.Length + 1);
}
else
{
relativePath = eventPaths[i].Remove(0, _fullDirectory.Length);
}
}
// Check if this is a rename
if (IsFlagSet(eventFlags[i], Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemRenamed))
{
// Find the rename that is paired to this rename, which should be the next rename in the list
long pairedId = FindRenameChangePairedChange(i, eventPaths, eventFlags, eventIds);
if (pairedId == long.MinValue)
{
// Getting here means we have a rename without a pair, meaning it should be a create for the
// move from unwatched folder to watcher folder scenario or a move from the watcher folder out.
// Check if the item exists on disk to check which it is
if (DoesItemExist(eventPaths[i], IsFlagSet(eventFlags[i], Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemIsFile)))
{
NotifyFileSystemEventArgs(WatcherChangeTypes.Created, relativePath);
}
else
{
NotifyFileSystemEventArgs(WatcherChangeTypes.Deleted, relativePath);
}
}
else
{
// Remove the base directory prefix (including trailing / that OS X adds) and
// add the paired event to the list of events to skip and notify the user of the rename
string newPathRelativeName = eventPaths[pairedId].Remove(0, _fullDirectory.Length + 1);
NotifyRenameEventArgs(WatcherChangeTypes.Renamed, newPathRelativeName, relativePath);
// Create a new list, if necessary, and add the event
if (handledRenameEvents == null)
{
handledRenameEvents = new List <FSEventStreamEventId>();
}
handledRenameEvents.Add(eventIds[pairedId]);
}
}
else
{
// OS X is wonky where it can give back kFSEventStreamEventFlagItemCreated and kFSEventStreamEventFlagItemRemoved
// for the same item. The only option we have is to stat and see if the item exists; if so send created, otherwise send deleted.
if ((IsFlagSet(eventFlags[i], Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemCreated)) ||
(IsFlagSet(eventFlags[i], Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemRemoved)))
{
if (DoesItemExist(eventPaths[i], IsFlagSet(eventFlags[i], Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemIsFile)))
{
NotifyFileSystemEventArgs(WatcherChangeTypes.Created, relativePath);
}
else
{
NotifyFileSystemEventArgs(WatcherChangeTypes.Deleted, relativePath);
}
}
if (IsFlagSet(eventFlags[i], Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemInodeMetaMod) ||
IsFlagSet(eventFlags[i], Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemModified) ||
IsFlagSet(eventFlags[i], Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemFinderInfoMod) ||
IsFlagSet(eventFlags[i], Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemChangeOwner) ||
IsFlagSet(eventFlags[i], Interop.EventStream.FSEventStreamEventFlags.kFSEventStreamEventFlagItemXattrMod))
{
// Everything else is a modification
NotifyFileSystemEventArgs(WatcherChangeTypes.Changed, relativePath);
}
}
}
}
}
public int EnumerateDevices()
{
int result = 0;
int deviceCount = 0;
int dwSize = (System.Runtime.InteropServices.Marshal.SizeOf(typeof(RAWINPUTDEVICELIST)));
if (GetRawInputDeviceList(System.IntPtr.Zero, ref deviceCount, dwSize) == 0)
{
System.IntPtr pRawInputDeviceList = System.Runtime.InteropServices.Marshal.AllocHGlobal(System.Convert.ToInt32(dwSize * deviceCount));
GetRawInputDeviceList(pRawInputDeviceList, ref deviceCount, System.Convert.ToInt32(dwSize));
for (long i = 0; i <= deviceCount - 1; i++)
{
DeviceNameInfo dName = default(DeviceNameInfo);
string deviceName = null;
int pcbSizeA = 0;
int pcbSizeB = 0;
RAWINPUTDEVICELIST rid = (RAWINPUTDEVICELIST)System.Runtime.InteropServices.Marshal.PtrToStructure(new System.IntPtr((pRawInputDeviceList.ToInt32() + (dwSize * i))), typeof(RAWINPUTDEVICELIST));
GetRawInputDeviceInfo(rid.hDevice, RIDI_DEVICENAME, System.IntPtr.Zero, ref pcbSizeA);
if (pcbSizeA > 0)
{
System.IntPtr pDataA = System.Runtime.InteropServices.Marshal.AllocHGlobal(System.Convert.ToInt32(pcbSizeA));
GetRawInputDeviceInfo(rid.hDevice, RIDI_DEVICENAME, pDataA, ref pcbSizeA);
deviceName = (string)System.Runtime.InteropServices.Marshal.PtrToStringAnsi(pDataA);
// Drop the "root" keyboard and mouse devices used for Terminal Services and the Remote Desktop
if (!deviceName.ToUpper().Contains("ROOT"))
{
dName = new DeviceNameInfo();
dName.deviceName = (string)System.Runtime.InteropServices.Marshal.PtrToStringAnsi(pDataA);
dName.deviceHandle = rid.hDevice;
dName.deviceType = GetDeviceType(rid.dwType);
GetRawInputDeviceInfo(rid.hDevice, RIDI_DEVICEINFO, System.IntPtr.Zero, ref pcbSizeB);
if (pcbSizeB > 0)
{
System.IntPtr pDataB = System.Runtime.InteropServices.Marshal.AllocHGlobal(System.Convert.ToInt32(pcbSizeB));
System.Runtime.InteropServices.Marshal.Copy(new int[] { pcbSizeB }, 0, pDataB, 1);
GetRawInputDeviceInfo(rid.hDevice, RIDI_DEVICEINFO, pDataB, ref pcbSizeB);
byte[] deviceInfoBuffer = new byte[pcbSizeB];
System.Runtime.InteropServices.Marshal.Copy(pDataB, deviceInfoBuffer, 0, pcbSizeB);
System.Runtime.InteropServices.Marshal.FreeHGlobal(pDataB);
DeviceInfo dInfo = new DeviceInfo();
dInfo.Size = System.BitConverter.ToInt32(deviceInfoBuffer, 0);
dInfo.Type = System.BitConverter.ToInt32(deviceInfoBuffer, 4);
int pcbSizeC = pcbSizeB - 8;
if (((dInfo.Type == RIM_TYPEKEYBOARD) && (pcbSizeC >= System.Runtime.InteropServices.Marshal.SizeOf(typeof(DeviceInfoKeyboard)))))
{
dInfo.KeyboardInfo.Type = System.BitConverter.ToUInt32(deviceInfoBuffer, 8);
dInfo.KeyboardInfo.SubType = System.BitConverter.ToUInt32(deviceInfoBuffer, 12);
dInfo.KeyboardInfo.KeyboardMode = System.BitConverter.ToUInt32(deviceInfoBuffer, 16);
dInfo.KeyboardInfo.NumberOfFunctionKeys = System.BitConverter.ToUInt32(deviceInfoBuffer, 20);
dInfo.KeyboardInfo.NumberOfIndicators = System.BitConverter.ToUInt32(deviceInfoBuffer, 24);
dInfo.KeyboardInfo.NumberOfKeysTotal = System.BitConverter.ToUInt32(deviceInfoBuffer, 28);
}
else if (((dInfo.Type == RIM_TYPEHID) && (pcbSizeC >= System.Runtime.InteropServices.Marshal.SizeOf(typeof(DeviceInfoHID)))))
{
dInfo.HIDInfo.VendorID = System.BitConverter.ToUInt32(deviceInfoBuffer, 8);
dInfo.HIDInfo.ProductID = System.BitConverter.ToUInt32(deviceInfoBuffer, 12);
dInfo.HIDInfo.VersionNumber = System.BitConverter.ToUInt32(deviceInfoBuffer, 16);
dInfo.HIDInfo.UsagePage = System.BitConverter.ToUInt16(deviceInfoBuffer, 20);
dInfo.HIDInfo.Usage = System.BitConverter.ToUInt16(deviceInfoBuffer, 22);
if (!m_usagePagesList.ContainsKey(dInfo.HIDInfo.UsagePage))
{
m_usagePagesList.Add(dInfo.HIDInfo.UsagePage, dInfo.HIDInfo.UsagePage);
}
}
else if (((dInfo.Type == RIM_TYPEMOUSE) && (pcbSizeC >= System.Runtime.InteropServices.Marshal.SizeOf(typeof(DeviceInfoMouse)))))
{
dInfo.MouseInfo.ID = System.BitConverter.ToUInt32(deviceInfoBuffer, 8);
dInfo.MouseInfo.NumberOfButtons = System.BitConverter.ToUInt32(deviceInfoBuffer, 12);
dInfo.MouseInfo.SampleRate = System.BitConverter.ToUInt32(deviceInfoBuffer, 16);
}
result += 1;
m_deviceInfoList.Add(rid.hDevice, dInfo);
m_deviceNameList.Add(rid.hDevice, dName);
}
}
System.Runtime.InteropServices.Marshal.FreeHGlobal(pDataA);
}
}
System.Runtime.InteropServices.Marshal.FreeHGlobal(pRawInputDeviceList);
}
else
{
m_errorMessage = "An error occurred while retrieving the list of raw input devices.";
result = 0;
}
return(result);
}
