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; }