private void InitializeDefinitions() { TagVisualizer myTagVisualizer = new TagVisualizer(); for (byte k = 1; k <= 5; k++) { TagVisualizationDefinition tagDef = new TagVisualizationDefinition(); // The tag value that this definition will respond to. tagDef.Value = k; // The .xaml file for the UI tagDef.Source = new Uri("CameraVisualization.xaml", UriKind.Relative); // The maximum number for this tag value. tagDef.MaxCount = 2; // The visualization stays for 2 seconds. tagDef.LostTagTimeout = 2000.0; // Orientation offset (default). tagDef.OrientationOffsetFromTag = 0.0; // Physical offset (horizontal inches, vertical inches). tagDef.PhysicalCenterOffsetFromTag = new Vector(0.0, 0.0); // Tag removal behavior (default). tagDef.TagRemovedBehavior = TagRemovedBehavior.Fade; // Orient UI to tag? (default). tagDef.UsesTagOrientation = true; // Add the definition to the collection. MyTagVisualizer.Definitions.Add(tagDef); } }
/// <summary> /// Primary Constructor for a TransferManager. Expected to work with one lynx /// </summary> /// <param name="tagger">used to initiate event handlers in TransferManager</param> /// <param name="FrameReporter">used to initiate event handlers in TransferManager</param> /// <param name="anticipatedLynx">the id of the lynx this TransferManager is intended to handle</param> public TransferManager(TagVisualizer tagger, Grid FrameReporter, int anticipatedLynx) { lynx = new Lynx(anticipatedLynx); //TEMP sendBuffer = new byte[512]; //size is arbitrary receiveBuffer = new byte[4098]; toSend = 0; sIndex = 0; rIndex = 0; toReceive = 0; lightMatrix = new int[16]; length = -1; currentRID = -1; flags = -1; type = sendType.String; checksum = 0; headerInProgress = false; offset = 0; hasRead = false; hasWritten = false; lynxHasRead = false; lynxHasWritten = true; addTagListener(tagger); addFrameReporter(FrameReporter); //tempTestStop = true; LynxAvailable = false; DataReset = false; }
// Methode, die aufgerufen wird bei Klick auf "grab it" Button private void btn_grabIt_Click(object sender, RoutedEventArgs e) { // damit Miniatur-Bild erst zur Laufzeit angezeigt wird placeholder_smartphone.Children.Clear(); // Erstellen des Vizualizer's TagVisualizer visualizer = new TagVisualizer(); visualizer.Name = "MyTagVisualizer"; // Visualization Definitionen TagVisualizationDefinition tagDefinition = new TagVisualizationDefinition(); // Tag Value 0x1 - wichtig für Input Simulator tagDefinition.Value = "0x1"; tagDefinition.Source = new Uri("CameraVisualization.xaml", UriKind.Relative); tagDefinition.LostTagTimeout = 2000; tagDefinition.MaxCount = 2; tagDefinition.OrientationOffsetFromTag = 0; tagDefinition.TagRemovedBehavior = TagRemovedBehavior.Fade; tagDefinition.UsesTagOrientation = true; // Definitionen dem Visualizer hinzufügen visualizer.Definitions.Add(tagDefinition); visualizer.VisualizationAdded += OnVisualizationAdded; // Miniaturbild auf gts-Fläche System.Windows.Controls.Image newImage = new System.Windows.Controls.Image(); newImage.Source = konfig_auto.Source; Thickness margin = newImage.Margin; margin.Left = 20; margin.Right = 20; newImage.Margin = margin; // zur Laufzeit Bild und Visualizer erzeugen placeholder_smartphone.Children.Add(newImage); placeholder_smartphone.Children.Add(visualizer); // WPF-Image zu Drawing-Image konvertieren System.Drawing.Image drawingImage = ConvertWpfImageToImage(newImage); baseString = GetStringFromImage(drawingImage); // Auto Transfer Objekt erzeugen (mit erbender Klasse AutoTO.cs) //AutoTO autoTo = new AutoTO(); //autoTo.setModel(auto.getModel()); //autoTo.setModelDescription(auto.getModelDescription()); //autoTo.setPrice(auto.getPrice()); //autoTo.setBaseString64(baseString); //JSON-String erzeugen aus Objekt Auto und Base64-String (= autoTo) //var javaScriptSerializer = new JavaScriptSerializer(); //string jsonString = javaScriptSerializer.Serialize(autoTo); //Console.WriteLine("Auto-Objekt:" + jsonString); // Methodenaufruf, damit JSON-String auf den Server gepusht wird postJSONtoServer(); }
// Methode, die aufgerufen wird bei Klick auf "grab it" Button private void btn_grabIt_Click(object sender, RoutedEventArgs e) { // damit Miniatur-Bild erst zur Laufzeit angezeigt wird // placeholder_smartphone.Children.Clear(); // Erstellen des Vizualizer's TagVisualizer visualizer = new TagVisualizer(); visualizer.Name = "MyTagVisualizer"; // Visualization Definitionen TagVisualizationDefinition tagDefinition = new TagVisualizationDefinition(); // Tag Value 0x18 - wichtig für Input Simulator tagDefinition.Value = "0x18"; tagDefinition.Source = new Uri("CameraVisualization.xaml", UriKind.Relative); tagDefinition.LostTagTimeout = 2000; tagDefinition.MaxCount = 2; tagDefinition.OrientationOffsetFromTag = 0; tagDefinition.TagRemovedBehavior = TagRemovedBehavior.Disappear; tagDefinition.UsesTagOrientation = true; // Definitionen dem Visualizer hinzufügen visualizer.Definitions.Add(tagDefinition); visualizer.VisualizationAdded += OnVisualizationAdded; // Miniaturbild auf gts-Fläche System.Windows.Controls.Image newImage = new System.Windows.Controls.Image(); newImage.Source = konfig_auto.Source; Thickness margin = newImage.Margin; margin.Left = 20; margin.Right = 20; newImage.Margin = margin; // zur Laufzeit Visualizer erzeugen placeholder_smartphone.Children.Add(visualizer); hierAuflegen.Visibility = System.Windows.Visibility.Visible; // WPF-Image zu Drawing-Image konvertieren System.Drawing.Image drawingImage = ConvertWpfImageToImage(newImage); baseString = GetStringFromImage(drawingImage); // setzt status des Datensatzes in DB auf false zunächst btn_grabIt.IsEnabled = false; MongoDB.mongoDBconnection(this.auto); }
public Point? ConvertToPointTagVisualizer(TagVisualizer visualizer, double localRelativeX, double localRelativeY) { if (visualizer != null) { Point local = new Point(ScreenRectangle.Width * localRelativeX, ScreenRectangle.Height * localRelativeY); GeneralTransform gt = ScreenRectangle.TransformToVisual(visualizer); if (gt != null) { return gt.Transform(local); } Debug.WriteLine("ConvertToPointTagVisualizer: GeneralTransform is null"); } Debug.WriteLine("ConvertToPointTagVisualizer: Returning null"); return null; }
private void InitializeTags() { TagVisualizer myTagVisualizer2 = new TagVisualizer(); //myTagVisualizer.VerticalAlignment = VerticalAlignment.Stretch; //myTagVisualizer.HorizontalAlignment = HorizontalAlignment.Stretch; //myTagVisualizer.Background = new SolidColorBrush(Colors.Transparent); //myTagVisualizer2.VisualizationAdded += OnVisualizationAdded; //myTagVisualizer.AddHandler(myTagVisualizer.VisualizationAdded, OnVisualizationAdded(sender, e), true); //myTagVisualizer.AddHandler(MyTagVisualizer.VisualizationAdded, new TagVisualizerEventHandler(OnVisualizationAdded()), true); //myTagVisualizer.FindResource("VisualizationAdded"); //myTagVisualizer.SetResourceReference(,"VisualisationAdded"); for (byte k = 0; k <= 42; k++) { TagVisualizationDefinition tagDef = new TagVisualizationDefinition(); // The tag value that this definition will respond to. tagDef.Value = k; // The .xaml file for the UI tagDef.Source = new Uri("TagVisualization1.xaml", UriKind.Relative); // The maximum number for this tag value. tagDef.MaxCount = 2; // The visualization stays for 2 seconds. tagDef.LostTagTimeout = 100.0; // Orientation offset (default). tagDef.OrientationOffsetFromTag = 0.0; // Physical offset (horizontal inches, vertical inches). tagDef.PhysicalCenterOffsetFromTag = new Vector(0.0, 0.0); // Tag removal behavior (default). tagDef.TagRemovedBehavior = TagRemovedBehavior.Fade; // Orient UI to tag? (default). tagDef.UsesTagOrientation = true; //tags[k] = tagDef; // Add the definition to the collection. MyTagVisualizer.Definitions.Add(tagDef); } }
/// <summary> /// Private constructor. /// </summary> /// <param name="visualizer"></param> private VisualizerHitTester(TagVisualizer visualizer) { Debug.Assert(visualizer != null); this.visualizer = visualizer; }
public static DependencyObject HitTest(TagVisualizer visualizer, Point point) { Debug.Assert(visualizer != null); VisualizerHitTester tester = new VisualizerHitTester(visualizer); VisualTreeHelper.HitTest( visualizer, tester.FilterCallback, tester.ResultCallback, new PointHitTestParameters(point)); return tester.visualHit; }
/// <summary> /// Synchronizes the specified visualization. /// </summary> /// <param name="visualizer"></param> /// <param name="visualization"></param> private static void SynchronizeVisualization(TagVisualizer visualizer, TagVisualization visualization) { Debug.Assert(visualizer != null); Debug.Assert(visualization != null); Debug.Assert(visualizer.ActiveVisualizations.Contains(visualization)); // Find the element that the visualization is over DependencyObject elementHit = VisualizerHitTester.HitTest(visualizer, visualization.Center) ?? visualizer; // Get its current ancestry chain Predicate<DependencyObject> isVisualizer = delegate(DependencyObject obj) { return obj == visualizer; }; AncestryChain newChain = new AncestryChain(elementHit, isVisualizer); Debug.Assert(newChain.IsComplete, "Hit element's ancestry chain didn't reach visualizer"); // Get its old chain, if any AncestryChain oldChain; if (visualizationChains.TryGetValue(visualization, out oldChain)) { Debug.Assert(oldChain != null); // We have an old chain. Process any adds or removes. IEnumerable<DependencyObject> removes = newChain.FindDiff(oldChain); if (removes != null) { OnVisualizationsLeave(removes, visualization); } IEnumerable<DependencyObject> adds = oldChain.FindDiff(newChain); if (adds != null) { OnVisualizationsEnter(adds, visualization); } } else { // We don't have an old chain. Treat everything as an add. OnVisualizationsEnter(newChain, visualization); } visualizationChains[visualization] = newChain; }
/// <summary> /// Turns off auto-synchronize for the specified visualizer. /// </summary> /// <param name="visualizer"></param> private static void EndAutoSynchronize(TagVisualizer visualizer) { Debug.Assert(visualizer != null); Debug.Assert(visualizers.ContainsKey(visualizer), "Unknown visualizer"); Debug.Assert(visualizers[visualizer], "Auto-synchronize was already turned off"); Debug.Assert(autoSynchronizeCount > 0, "Auto-synchronize count is corrupt"); // Make sure that this is the visualizer's thread, to be sure // to get the correct input manager visualizer.VerifyAccess(); // Mark it as being un-tracked --autoSynchronizeCount; visualizers[visualizer] = false; // If it's the last one, stop tracking if (autoSynchronizeCount < 1) { InputManager.Current.HitTestInvalidatedAsync -= OnHitTestInvalidatedAsync; } }
/// <summary> /// Turns on auto-synchronize for the specified visualizer. /// </summary> /// <param name="visualizer"></param> private static void BeginAutoSynchronize(TagVisualizer visualizer) { Debug.Assert(visualizer != null); Debug.Assert(visualizers.ContainsKey(visualizer), "Unknown visualizer"); Debug.Assert(!visualizers[visualizer], "Auto-synchronize was already turned on"); // Make sure that this is the visualizer's thread, to be sure // to get the correct input manager visualizer.VerifyAccess(); // Mark it as being tracked ++autoSynchronizeCount; visualizers[visualizer] = true; // If it's the first one, activate tracking if (autoSynchronizeCount == 1) { InputManager.Current.HitTestInvalidatedAsync += OnHitTestInvalidatedAsync; } }
/// <summary> /// Registers a new visualizer for event processing. /// </summary> /// <param name="visualizer"></param> private static void AddVisualizer(TagVisualizer visualizer) { Debug.Assert(visualizer != null); Debug.Assert(!visualizers.ContainsKey(visualizer), "Trying to add visualizer that's already registered"); visualizers.Add(visualizer, false); // Register with the visualizer so that whenever a visualization moves, is added, // or is removed, it can be synchronized. visualizer.VisualizationMoved += OnSynchronizeVisualization; visualizer.VisualizationAdded += OnSynchronizeVisualization; visualizer.VisualizationRemoved += OnRemoveVisualization; }
/// <summary> /// Here when the Mode property on a TagVisualizer changes. /// </summary> /// <param name="visualizer"></param> /// <param name="oldMode"></param> /// <param name="newMode"></param> private static void OnVisualizerModeChanged( TagVisualizer visualizer, TagVisualizerSynchronizationMode oldMode, TagVisualizerSynchronizationMode newMode) { Debug.Assert(visualizer != null); Debug.Assert(oldMode != newMode); // Add or remove visualizer if necessary bool oldIsActive = oldMode != TagVisualizerSynchronizationMode.Off; bool newIsActive = newMode != TagVisualizerSynchronizationMode.Off; if (!oldIsActive && newIsActive) { AddVisualizer(visualizer); } else if (oldIsActive && !newIsActive) { RemoveVisualizer(visualizer); } // Is the visualizer active? if (newIsActive) { bool oldAutoSynchronize = oldMode == TagVisualizerSynchronizationMode.Auto; bool newAutoSynchronize = newMode == TagVisualizerSynchronizationMode.Auto; if (!oldAutoSynchronize && newAutoSynchronize) { BeginAutoSynchronize(visualizer); } else if (oldAutoSynchronize && !newAutoSynchronize) { EndAutoSynchronize(visualizer); } } }
public static TagVisualizerSynchronizationMode GetMode(TagVisualizer visualizer) { if (visualizer == null) { throw new ArgumentNullException("visualizer"); } return (TagVisualizerSynchronizationMode)visualizer.GetValue(ModeProperty); }
public static void SetMode(TagVisualizer visualizer, TagVisualizerSynchronizationMode mode) { if (visualizer == null) { throw new ArgumentNullException("visualizer"); } visualizer.SetValue(ModeProperty, mode); }
/// <summary> /// Wrapper method to add appropriate eventhandlers to events /// </summary> /// <param name="tagger">the TagVisualizer object to listen to</param> public void addTagListener(TagVisualizer tagger) { tagger.VisualizationAdded += onTagAdded; tagger.VisualizationMoved += onTagMoved; tagger.VisualizationRemoved += onTagRemoved; }
/// <summary> /// Unregisters a previous visualizer from event processing. /// </summary> /// <param name="visualizer"></param> private static void RemoveVisualizer(TagVisualizer visualizer) { Debug.Assert(visualizer != null); Debug.Assert(visualizers.ContainsKey(visualizer), "Trying to remove unknown visualizer"); // Unregister from the visualizer. visualizer.VisualizationMoved -= OnSynchronizeVisualization; visualizer.VisualizationAdded -= OnSynchronizeVisualization; visualizer.VisualizationRemoved -= OnRemoveVisualization; // Turn off auto-synchronize, if it's on if (visualizers[visualizer]) { EndAutoSynchronize(visualizer); } visualizers.Remove(visualizer); }