void RemoveTablet(uint index)
{
System.Diagnostics.Debug.Assert(index < Count && Count > 0);
TabletDevice removeTablet = _tablets[index];
TabletDevice[] tablets = new TabletDevice[_tablets.Length - 1];
uint preCopyCount = index;
uint postCopyCount = (uint)_tablets.Length - index - 1;
Array.Copy(_tablets, 0, tablets, 0, preCopyCount);
Array.Copy(_tablets, index + 1, tablets, index, postCopyCount);
_tablets = tablets;
// DevDiv:1078091
// Dispose the tablet unless there is input waiting
removeTablet.DisposeOrDeferDisposal();
// This is now a deferred disposal, move it to the deferred list
if (removeTablet.IsDisposalPending)
{
_deferredTablets.Add(removeTablet);
}
}
void RemoveTablet(uint index)
{
System.Diagnostics.Debug.Assert(index < Count && Count > 0);
TabletDevice removeTablet = _tablets[index];
TabletDevice[] tablets = new TabletDevice[_tablets.Length - 1];
uint preCopyCount = index;
uint postCopyCount = (uint)_tablets.Length - index - 1;
Array.Copy(_tablets, 0, tablets, 0, preCopyCount);
Array.Copy(_tablets, index + 1, tablets, index, postCopyCount);
_tablets = tablets;
// Make sure we release any references to a stylus device that may
// have been removed
if (Tablet.CurrentTabletDevice == removeTablet)
{
StylusLogic.CurrentStylusLogic.SelectStylusDevice(null, null, true);
}
removeTablet.Dispose();
}
protected TabletDeviceBase(TabletDeviceInfo info)
{
// Generate a wrapper for public use
TabletDevice = new TabletDevice(this);
_tabletInfo = info;
if (_tabletInfo.DeviceType == TabletDeviceType.Touch)
{
// A touch device requires multi-touch logic
_multiTouchSystemGestureLogic = new MultiTouchSystemGestureLogic();
}
}
void AddTablet(uint index, TabletDevice tabletDevice)
{
Debug.Assert(index <= Count);
Debug.Assert(tabletDevice.Type != (TabletDeviceType)(-1)); // make sure not the mouse tablet device!
TabletDevice[] newTablets = new TabletDevice[Count + 1];
uint preCopyCount = index;
uint postCopyCount = (uint)_tablets.Length - index;
Array.Copy(_tablets, 0, newTablets, 0, preCopyCount);
newTablets[index] = tabletDevice;
Array.Copy(_tablets, index, newTablets, index + 1, postCopyCount);
_tablets = newTablets;
}
internal StylusDevice UpdateStylusDevices(int tabletId, int stylusId)
{
if (_tablets == null)
{
throw new ObjectDisposedException("TabletDeviceCollection");
}
for (int iTablet = 0, cTablets = _tablets.Length; iTablet < cTablets; iTablet++)
{
TabletDevice tablet = _tablets[iTablet];
if (tablet.Id == tabletId)
{
return(tablet.UpdateStylusDevices(stylusId));
}
}
return(null);
}
internal StylusDevice(TabletDevice tabletDevice, string sName, int id, bool fInverted, StylusButtonCollection stylusButtonCollection)
{
_tabletDevice = tabletDevice;
_sName = sName;
_id = id;
_fInverted = fInverted;
// For tablet devices that can go out of range default them to
// being out of range until we see some events from it.
_fInRange = false; // All tablets out of range by default.
_stylusButtonCollection = stylusButtonCollection;
#if MULTICAPTURE
_overIsEnabledChangedEventHandler = new DependencyPropertyChangedEventHandler(OnOverIsEnabledChanged);
_overIsVisibleChangedEventHandler = new DependencyPropertyChangedEventHandler(OnOverIsVisibleChanged);
_overIsHitTestVisibleChangedEventHandler = new DependencyPropertyChangedEventHandler(OnOverIsHitTestVisibleChanged);
_reevaluateStylusOverDelegate = new DispatcherOperationCallback(ReevaluateStylusOverAsync);
_reevaluateStylusOverOperation = null;
_captureIsEnabledChangedEventHandler = new DependencyPropertyChangedEventHandler(OnCaptureIsEnabledChanged);
_captureIsVisibleChangedEventHandler = new DependencyPropertyChangedEventHandler(OnCaptureIsVisibleChanged);
_captureIsHitTestVisibleChangedEventHandler = new DependencyPropertyChangedEventHandler(OnCaptureIsHitTestVisibleChanged);
_reevaluateCaptureDelegate = new DispatcherOperationCallback(ReevaluateCaptureAsync);
_reevaluateCaptureOperation = null;
#endif
if (_stylusButtonCollection != null)
{
foreach (StylusButton button in _stylusButtonCollection)
{
button.SetOwner(this);
}
}
// Because the stylus device gets a steady stream of input events when it is in range,
// we don't have to be so careful about responding to layout changes as we have to be
// with the mouse.
// InputManager.Current.HitTestInvalidatedAsync += new EventHandler(OnHitTestInvalidatedAsync);
InputManager inputManager = (InputManager)Dispatcher.InputManager;
_stylusLogic = inputManager.StylusLogic;
_stylusLogic.RegisterStylusDeviceCore(this);
}
internal void DisposeTablets()
{
if (_tablets != null)
{
for (int iTablet = 0, cTablets = _tablets.Length; iTablet < cTablets; iTablet++)
{
if (_tablets[iTablet] != null)
{
TabletDevice removedTablet = _tablets[iTablet];
// DevDiv:1078091
// Dispose the tablet unless there is input waiting
removedTablet.DisposeOrDeferDisposal();
// This is now a deferred disposal, move it to the deferred list
if (removedTablet.IsDisposalPending)
{
_deferredTablets.Add(removedTablet);
}
}
}
_tablets = null;
}
}
void UpdateTabletsImpl()
{
// REENTRANCY NOTE: Let a PenThread do this work to avoid reentrancy!
// On return you get entire list of tablet and info needed to
// create all the tablet devices (and stylus device info gets
// cached too in penimc which avoids calls to wisptis.exe).
// Use existing penthread if we have one otherwise grab an available one.
PenThread penThread = _tablets.Length > 0 ? _tablets[0].PenThread :
PenThreadPool.GetPenThreadForPenContext(null);
TabletDeviceInfo [] tabletdevices = penThread.WorkerGetTabletsInfo();
// First find out the index of the mouse device (usually the first at index 0)
uint indexMouseTablet = UInt32.MaxValue;
for (uint i = 0; i < tabletdevices.Length; i++)
{
// See if this is a bogus entry first.
if (tabletdevices[i].PimcTablet == null)
{
continue;
}
// If it is the mouse tablet device we want to ignore it.
if (tabletdevices[i].DeviceType == (TabletDeviceType)(-1))
{
indexMouseTablet = i;
tabletdevices[i].PimcTablet = null; // ignore this one!
}
}
// Now figure out count of valid tablet devices left
uint count = 0;
for (uint k = 0; k < tabletdevices.Length; k++)
{
if (tabletdevices[k].PimcTablet != null)
{
count++;
}
}
TabletDevice[] tablets = new TabletDevice[count];
uint tabletsIndex = 0;
uint unchangedTabletCount = 0;
for (uint iTablet = 0; iTablet < tabletdevices.Length; iTablet++)
{
if (tabletdevices[iTablet].PimcTablet == null)
{
continue; // Skip looking at this index (mouse and bogus tablets are ignored).
}
int id = tabletdevices[iTablet].Id;
// First see if same index has not changed (typical case)
if (tabletsIndex < _tablets.Length && _tablets[tabletsIndex] != null && _tablets[tabletsIndex].Id == id)
{
tablets[tabletsIndex] = _tablets[tabletsIndex];
_tablets[tabletsIndex] = null; // clear to ignore on cleanup pass.
unchangedTabletCount++;
}
else
{
// Look up and see if we have this tabletdevice created already...
TabletDevice tablet = null;
for (uint i = 0; i < _tablets.Length; i++)
{
if (_tablets[i] != null && _tablets[i].Id == id)
{
tablet = _tablets[i];
_tablets[i] = null; // clear it so we don't dispose it.
break;
}
}
// Not found so create it.
if (tablet == null)
{
try
{
tablet = new TabletDevice(tabletdevices[iTablet], penThread);
}
catch (InvalidOperationException ex)
{
// This is caused by the Stylus ID not being unique when trying
// to register it in the StylusLogic.__stylusDeviceMap. If we
// come across a dup then just ignore registering this tablet device.
// There seems to be an issue in wisptis where different tablet IDs get
// duplicate Stylus Ids when installing the VHID test devices.
if (ex.Data.Contains("System.Windows.Input.StylusLogic"))
{
continue; // Just go to next without adding this one.
}
else
{
throw; // not an expected exception, rethrow it.
}
}
}
tablets[tabletsIndex] = tablet;
}
tabletsIndex++;
}
if (unchangedTabletCount == _tablets.Length &&
unchangedTabletCount == tabletsIndex &&
tabletsIndex == count)
{
// Keep the _tablet reference when nothing changes.
// The reason is that if this method gets called from within
// CreateContexts while looping on _tablets, it could result in
// a null ref exception since the original _tablets array has
// been purged to nulls.
// NOTE: There is still the case of changing the ref (else case below)
// when tablet devices actually change. But such a case is rare
// (if not improbable) from within CreateContexts.
Array.Copy(tablets, 0, _tablets, 0, count);
_indexMouseTablet = indexMouseTablet;
}
else
{
// See if we need to re alloc the array due to invalid tabletdevice being seen.
if (tabletsIndex != count)
{
TabletDevice[] updatedTablets = new TabletDevice[tabletsIndex];
Array.Copy(tablets, 0, updatedTablets, 0, tabletsIndex);
tablets = updatedTablets;
}
DisposeTablets(); // Clean up any non null TabletDevice entries on old array.
_tablets = tablets; // set updated tabletdevice array
_indexMouseTablet = indexMouseTablet;
}
// DevDiv:1078091
// Any deferred tablet should be properly disposed of when applicable and
// removed from the list of deferred tablets.
DisposeDeferredTablets();
}
/////////////////////////////////////////////////////////////////////
/// <summary>
/// Copy the TabletDevice objects in the collection to another array
/// of TabletDevices.
/// </summary>
/// <param name="array">destination array</param>
/// <param name="index">position in destination array to begin copying</param>
public void CopyTo(TabletDevice[] array, int index)
{
((ICollection)this).CopyTo(array, index);
}
void RemoveTablet(uint index)
{
System.Diagnostics.Debug.Assert(index < Count && Count > 0);
TabletDevice removeTablet = _tablets[index];
TabletDevice[] tablets = new TabletDevice[_tablets.Length - 1];
uint preCopyCount = index;
uint postCopyCount = (uint)_tablets.Length - index - 1;
Array.Copy(_tablets, 0, tablets, 0, preCopyCount);
Array.Copy(_tablets, index+1, tablets, index, postCopyCount);
_tablets = tablets;
// Make sure we release any references to a stylus device that may
// have been removed
if (Tablet.CurrentTabletDevice == removeTablet)
{
StylusLogic.CurrentStylusLogic.SelectStylusDevice(null, null, true);
}
removeTablet.Dispose();
}
void AddTablet(uint index, TabletDevice tabletDevice)
{
Debug.Assert(index <= Count);
Debug.Assert(tabletDevice.Type != (TabletDeviceType)(-1)); // make sure not the mouse tablet device!
TabletDevice[] newTablets = new TabletDevice[Count + 1];
uint preCopyCount = index;
uint postCopyCount = (uint)_tablets.Length - index;
Array.Copy(_tablets, 0, newTablets, 0, preCopyCount);
newTablets[index] = tabletDevice;
Array.Copy(_tablets, index, newTablets, index+1, postCopyCount);
_tablets = newTablets;
}
internal void UpdateTablets()
{
if (_tablets == null)
throw new ObjectDisposedException("TabletDeviceCollection");
// REENTRANCY NOTE: Let a PenThread do this work to avoid reentrancy!
// On return you get entire list of tablet and info needed to
// create all the tablet devices (and stylus device info gets
// cached too in penimc which avoids calls to wisptis.exe).
// Use existing penthread if we have one otherwise grab an available one.
PenThread penThread = _tablets.Length > 0 ? _tablets[0].PenThread :
PenThreadPool.GetPenThreadForPenContext(null);
TabletDeviceInfo [] tabletdevices = penThread.WorkerGetTabletsInfo();
// First find out the index of the mouse device (usually the first at index 0)
uint indexMouseTablet = UInt32.MaxValue;
for (uint i = 0; i < tabletdevices.Length; i++)
{
// See if this is a bogus entry first.
if (tabletdevices[i].PimcTablet == null) continue;
// If it is the mouse tablet device we want to ignore it.
if (tabletdevices[i].DeviceType == (TabletDeviceType)(-1))
{
indexMouseTablet = i;
tabletdevices[i].PimcTablet = null; // ignore this one!
}
}
// Now figure out count of valid tablet devices left
uint count = 0;
for (uint k = 0; k < tabletdevices.Length; k++)
{
if (tabletdevices[k].PimcTablet != null) count++;
}
TabletDevice[] tablets = new TabletDevice[count];
uint tabletsIndex = 0;
uint unchangedTabletCount = 0;
for (uint iTablet = 0; iTablet < tabletdevices.Length; iTablet++)
{
if (tabletdevices[iTablet].PimcTablet == null)
{
continue; // Skip looking at this index (mouse and bogus tablets are ignored).
}
int id = tabletdevices[iTablet].Id;
// First see if same index has not changed (typical case)
if (tabletsIndex < _tablets.Length && _tablets[tabletsIndex] != null && _tablets[tabletsIndex].Id == id)
{
tablets[tabletsIndex] = _tablets[tabletsIndex];
_tablets[tabletsIndex] = null; // clear to ignore on cleanup pass.
unchangedTabletCount++;
}
else
{
// Look up and see if we have this tabletdevice created already...
TabletDevice tablet = null;
for (uint i = 0; i < _tablets.Length; i++)
{
if (_tablets[i] != null && _tablets[i].Id == id)
{
tablet = _tablets[i];
_tablets[i] = null; // clear it so we don't dispose it.
break;
}
}
// Not found so create it.
if (tablet == null)
{
try
{
tablet = new TabletDevice(tabletdevices[iTablet], penThread);
}
catch (InvalidOperationException ex)
{
// This is caused by the Stylus ID not being unique when trying
// to register it in the StylusLogic.__stylusDeviceMap. If we
// come across a dup then just ignore registering this tablet device.
// There seems to be an issue in wisptis where different tablet IDs get
// duplicate Stylus Ids when installing the VHID test devices.
if (ex.Data.Contains("System.Windows.Input.StylusLogic"))
{
continue; // Just go to next without adding this one.
}
else
{
throw; // not an expected exception, rethrow it.
}
}
}
tablets[tabletsIndex] = tablet;
}
tabletsIndex++;
}
if (unchangedTabletCount == _tablets.Length &&
unchangedTabletCount == tabletsIndex &&
tabletsIndex == count)
{
// Keep the _tablet reference when nothing changes.
// The reason is that if this method gets called from within
// CreateContexts while looping on _tablets, it could result in
// a null ref exception since the original _tablets array has
// been purged to nulls.
// NOTE: There is still the case of changing the ref (else case below)
// when tablet devices actually change. But such a case is rare
// (if not improbable) from within CreateContexts.
Array.Copy(tablets, 0, _tablets, 0, count);
_indexMouseTablet = indexMouseTablet;
}
else
{
// See if we need to re alloc the array due to invalid tabletdevice being seen.
if (tabletsIndex != count)
{
TabletDevice[] updatedTablets = new TabletDevice[tabletsIndex];
Array.Copy(tablets, 0, updatedTablets, 0, tabletsIndex);
tablets = updatedTablets;
}
DisposeTablets(); // Clean up any non null TabletDevice entries on old array.
_tablets = tablets; // set updated tabletdevice array
_indexMouseTablet = indexMouseTablet;
}
}
public void CopyTo(TabletDevice[] array, int index)
{
}
/////////////////////////////////////////////////////////////////////
internal Matrix GetTabletToViewTransform(TabletDevice tabletDevice)
{
// NTRAID#Tablet_PC_Bug 26555-2004/11/3-xiaotu: Inking is offset under 120 DPI
// Changet the TabletToViewTransform matrix to take DPI into account. The default
// value is 96 DPI in Avalon. The device DPI value is cached after the first call
// to this function.
Matrix matrix = _transformToDevice;
matrix.Invert();
return matrix * tabletDevice.TabletToScreen;
}
