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