//CTOR
public InkInputControl()
{
//Initialize XAML
this.InitializeComponent();
//Create a new InkDrawingAttributes instance
m_inkAttr = new InkDrawingAttributes();
//Set firt to curve to true to get nice Bezier curves
m_inkAttr.FitToCurve = true;
//We ignore the presuer as our custom ink renderer does not know how to render it.
m_inkAttr.IgnorePressure = true;
//Set the default ink rendering size to 1.0
m_inkAttr.Size = new Size(1.0, 1.0);
//Set the defualt ink pen tip to circle
m_inkAttr.PenTip = PenTipShape.Circle;
//Set the default ink color to black
m_inkAttr.Color = Windows.UI.Colors.Black;
//Create a new Ink Manager instance
m_inkMan = new InkManager();
//Set the default ink rendering attributes
m_inkMan.SetDefaultDrawingAttributes(m_inkAttr);
//Create a new Ink Renderer instance using the control's inkCanvas object as the target
m_renderer = new InkRenderer(this.inkCanvas);
m_renderer.UseActiveInkColor = false;
//Create an empty list for CanvaImage objects
m_canvasImages = new List <CanvasImage>();
}
private async void SetImage(byte[] ImageData)
{
MedicalCanvas.Children.Clear();
if (ImageData == null)
{
MedcialInkManager = new InkManager();
return;
}
InkManager inkMgr = MedcialInkManager;
renderer = new XamlInkRenderer(MedicalCanvas);
using (var stream = new InMemoryRandomAccessStream())
{
await stream.WriteAsync(ImageData.AsBuffer());
await stream.FlushAsync();
stream.Seek(0);
await inkMgr.LoadAsync(stream);
var iskList = inkMgr.GetStrokes();
int iskCount = iskList.Count;
renderer.Clear();
renderer.AddInk(iskList);
}
}
void Awake()
{
if (enabled)
{
if (mInstance == null || mInstance == this)
{
mInstance = this;
}
else
{
Debug.LogWarning("Another Ink Manager already exists (" + mInstance.gameObject + "), destroying " + gameObject, mInstance);
DestroyImmediate(gameObject);
return;
}
//Ensure that this object persists across scene loads
DontDestroyOnLoad(this.gameObject);
}
else
{
Debug.LogWarning("This Ink Manager is disabled (" + gameObject + "), destroying.");
DestroyImmediate(gameObject);
}
Initialize();
}
/// <summary>
/// Clears the selection of any stroke.
/// </summary>
/// <param name="inkManager">
/// The <see cref="InkManager"/>.
/// </param>
public static void ClearStrokeSelection(this InkManager inkManager)
{
foreach (var stroke in inkManager.GetStrokes())
{
stroke.Selected = false;
}
}
/// <summary>
/// Selects all of the strokes.
/// </summary>
/// <param name="inkManager">
/// The <see cref="InkManager"/>.
/// </param>
public static void SelectAllStrokes(this InkManager inkManager)
{
foreach (var stroke in inkManager.GetStrokes())
{
stroke.Selected = true;
}
}
void OnDestroy()
{
if (mInstance == this)
{
mInstance = null;
}
}
/// <summary>
/// Adds a collection of strokes to the specified <see cref="InkManager"/>.
/// </summary>
/// <param name="inkManager">
/// The <see cref="InkManager"/>.
/// </param>
/// <param name="strokes">
/// The strokes to add.
/// </param>
public static void AddStrokes(this InkManager inkManager, IEnumerable <InkStroke> strokes)
{
foreach (var stroke in strokes)
{
inkManager.AddStroke(stroke);
}
}
protected override void OnPointerReleased(PointerRoutedEventArgs args)
{
// Get information
PointerPoint pointerPoint = args.GetCurrentPoint(sheetPanel);
uint id = pointerPoint.PointerId;
InkManager inkManager = this.InkFileManager.InkManager;
if (pointerDictionary.ContainsKey(id))
{
// Give PointerPoint to InkManager
inkManager.ProcessPointerUp(pointerPoint);
if (inkManager.Mode == InkManipulationMode.Inking)
{
// Get rid of the little line segments
newLineGrid.Children.Clear();
// Render the new stroke
IReadOnlyList <InkStroke> inkStrokes = inkManager.GetStrokes();
InkStroke inkStroke = inkStrokes[inkStrokes.Count - 1];
this.InkFileManager.RenderStroke(inkStroke);
}
else if (inkManager.Mode == InkManipulationMode.Selecting)
{
// Get rid of the enclosure line
newLineGrid.Children.Clear();
// Render everything so selected items are identified
this.InkFileManager.RenderAll();
}
pointerDictionary.Remove(id);
}
base.OnPointerReleased(args);
}
private void OnValidate()
{
ink = ink ?? GetComponent <InkManager>();
var watcher = ink.GetOrAddInkVariableWatcher(inkListName, HandleTypeEnum.List);
watcher.changedAsList.AddListener(OnInventoryChanged);
}
public void Awake()
{
//establish the singleton
instance = this;
//Find all the UI components
uiCanvas = GameObject.Find("Canvas").GetComponent <Canvas>();
//dialogueBox = Instantiate<Image>(textboxPrefab, uiCanvas.transform);
dialogueText = dialogueBox.transform.GetChild(0).GetComponent <TextMeshProUGUI>();
characterNameText = dialogueBox.transform.GetChild(1).GetComponent <TextMeshProUGUI>();
continuebutton = dialogueBox.transform.GetChild(2).GetComponent <Button>();
exitbutton = dialogueBox.transform.Find("ExitIcon").GetComponent <Button>();
choicebutton1 = GameObject.FindWithTag("ChoiceButton1").GetComponent <Button>();
choicebutton2 = GameObject.FindWithTag("ChoiceButton2").GetComponent <Button>();
choicebutton3 = GameObject.FindWithTag("ChoiceButton3").GetComponent <Button>();
//add button click functionality to newly instantiated prefab
exitbutton.onClick.AddListener(() => ExitTextBox());
choicebutton1.onClick.AddListener(() => ChoiceButtonPressed(0));
choicebutton2.onClick.AddListener(() => ChoiceButtonPressed(1));
choicebutton3.onClick.AddListener(() => ChoiceButtonPressed(2));
continuebutton.onClick.AddListener(() => ContinueButtonPressed());
//deactivate the UI so it doesn't get in the way
blackBackground.gameObject.SetActive(false);
dialogueBox.gameObject.SetActive(false);
//
//
TextAsset storyFile = Resources.Load <TextAsset>("master_dialogue_file");
Debug.Log("Story file loaded");
story = new Story(storyFile.text);
}
/// <summary>
/// Populates the page with content passed during navigation. Any saved state is also
/// provided when recreating a page from a prior session.
/// </summary>
/// <param name="navigationParameter">The parameter value passed to
/// <see cref="Frame.Navigate(Type, Object)"/> when this page was initially requested.
/// </param>
/// <param name="pageState">A dictionary of state preserved by this page during an earlier
/// session. This will be null the first time a page is visited.</param>
protected override void LoadState(Object navigationParameter, Dictionary <String, Object> pageState)
{
letterToWright.Text = "";
l = navigationParameter as Lesson;
letterToWright.Text = l.selectedLetter;
if (l.selectedLetter.Equals("t"))
{
letterToWright.FontFamily = new FontFamily("Ariel black");
}
else
{
letterToWright.FontFamily = new FontFamily("Comic Sans MS");
}
_inkKhaled = new InkManager();
thick = 10.0;
sbrush = new SolidColorBrush(Colors.Black);
ptsh = new PenTipShape()
{
};
myCanvas.PointerPressed += new PointerEventHandler(MyCanvas_PointerPressed);
myCanvas.PointerMoved += new PointerEventHandler(MyCanvas_PointerMoved);
myCanvas.PointerReleased += new PointerEventHandler(MyCanvas_PointerReleased);
myCanvas.PointerExited += new PointerEventHandler(MyCanvas_PointerReleased);
}
void Start()
{
_inkManager = FindObjectOfType <InkManager>();
if (_inkManager == null)
{
Debug.LogError("Ink Manager was not found!");
}
}
public InkView()
{
this.InitializeComponent();
inkStream = new MemoryStream();
inkManager = new InkManager();
Ink.InkPresenter.IsInputEnabled = true;
Ink.InkPresenter.InputDeviceTypes = CoreInputDeviceTypes.Mouse | CoreInputDeviceTypes.Pen | CoreInputDeviceTypes.Touch;
}
private void Clear_Clicked(object sender, RoutedEventArgs e)
{
inkManager = new InkManager();
needToRedrawInkSurface = true;
canvasControl.Invalidate();
}
private void DefaultConditions() //This Is The Method Called On The Startup Of The PaintApp
{
inkManager = new InkManager(); //Initializes The Inkmanager
strokeThickness = 5; //Initialize The Drawing Pen's Thickness To 5
shapeKind = ShapeTyp.LINE; //Initialize The Drawing Shape To Line
pen = new SolidColorBrush(Colors.Black); //Initialize The Drawing Pen With Black Color
hideLayers();
}
private void Clear_Clicked(object sender, RoutedEventArgs e)
{
strokeList.Clear();
inkManager = new InkManager();
needsClear = true;
canvasControl.Invalidate();
}
protected override void OnPointerMoved(PointerRoutedEventArgs args)
{
// Get information
PointerPoint pointerPoint = args.GetCurrentPoint(sheetPanel);
uint id = pointerPoint.PointerId;
InkManager inkManager = this.InkFileManager.InkManager;
InkDrawingAttributes inkDrawingAttributes =
this.InkFileManager.InkDrawingAttributes;
if (pointerDictionary.ContainsKey(id))
{
foreach (PointerPoint point in args.GetIntermediatePoints(sheetPanel).Reverse())
{
Point point1 = pointerDictionary[id];
Point point2 = pointerPoint.Position;
// Give PointerPoint to InkManager
object obj = inkManager.ProcessPointerUpdate(point);
if (inkManager.Mode == InkManipulationMode.Erasing)
{
// See if something has actually been removed
Rect rect = (Rect)obj;
if (rect.Width != 0 && rect.Height != 0)
{
this.InkFileManager.RenderAll();
}
}
else if (inkManager.Mode == InkManipulationMode.Selecting)
{
Polyline polyline = newLineGrid.Children[0] as Polyline;
polyline.Points.Add(point2);
}
else // inkManager.Mode == InkManipulationMode.Inking
{
// Render the line
Line line = new Line
{
X1 = point1.X,
Y1 = point1.Y,
X2 = point2.X,
Y2 = point2.Y,
Stroke = new SolidColorBrush(inkDrawingAttributes.Color),
StrokeThickness = inkDrawingAttributes.Size.Width *
pointerPoint.Properties.Pressure,
StrokeStartLineCap = PenLineCap.Round,
StrokeEndLineCap = PenLineCap.Round
};
newLineGrid.Children.Add(line);
}
pointerDictionary[id] = point2;
}
}
base.OnPointerMoved(args);
}
private void WaitForLevelEndChargingToStartDialog(Scene scene, LoadSceneMode mode)
{
if (scene.name != AppScenes.MAP_SCENE && scene.name != AppScenes.LOAD_SCENE)
{
inkManRef = FindObjectOfType <InkManager>();
dialogManRef = FindObjectOfType <DialogManager>();
StartDialog(true);
}
}
public ImageMarkupPage()
{
this.InitializeComponent();
this._inkManager = new InkManager();
//#FF003f82
this._brushColor = Colors.Blue;
this.Loaded += DrawImageView_Loaded;
}
private void InkPresenter_StrokesErased(InkPresenter sender, InkStrokesErasedEventArgs args)
{
var removed = args.Strokes;
var strokeList = inkManager.GetStrokes().Except(removed).ToList();
inkManager = new InkManager();
strokeList.ForEach(inkManager.AddStroke);
ClearSelection();
canvasControl.Invalidate();
}
/* Works as follows...
* We iterate through the entire loop of characters, and for each character,
* we are going to create an instance of it, set it to inactive, name it properly,
* and then add it to our list of all actors called actorsList.
*/
void Awake()
{
_inkManager = GetComponent <InkManager>();
for (int i = 0; i < characters.Length; i++)
{
GameObject newActor = Instantiate(characters[i]);
newActor.SetActive(false);
newActor.name = characters[i].name;
actorsList.Add(newActor);
}
characterTags = GetComponent <CharacterTags>();
}
private async void LoadStrokesFromStream(Stream stream)
{
if (stream.Length > 0)
{
await inkManager.LoadAsync(stream.AsInputStream());
}
else
{
inkManager = new InkManager();
}
needToRedrawInkSurface = true;
}
private void Awake()
{
if (!instance)
{
instance = this;
}
else
{
Destroy(gameObject);
}
dialogTyper = dialogBox.GetComponent <TextTyper>();
StartStory();
}
void Canvas_PointerPressed(object sender, PointerRoutedEventArgs e)
{
if (DrawingTool != "Eraser")
{
Window.Current.CoreWindow.PointerCursor = new CoreCursor(CoreCursorType.Cross, 1);
}
else
{
Window.Current.CoreWindow.PointerCursor = new CoreCursor(CoreCursorType.UniversalNo, 1);
}
Canvas canvas = sender as Canvas;
InkManager inkManager = MedcialInkManager;
switch (DrawingTool)
{
case "Pencil":
{
var MyDrawingAttributes = new InkDrawingAttributes();
MyDrawingAttributes.Size = new Size(StrokeThickness, StrokeThickness);
MyDrawingAttributes.Color = BorderColor;
MyDrawingAttributes.FitToCurve = true;
inkManager.SetDefaultDrawingAttributes(MyDrawingAttributes);
PreviousContactPoint = e.GetCurrentPoint(canvas).Position;
if (e.GetCurrentPoint(canvas).Properties.IsLeftButtonPressed)
{
// Pass the pointer information to the InkManager.
inkManager.ProcessPointerDown(e.GetCurrentPoint(canvas));
PenID = e.GetCurrentPoint(canvas).PointerId;
e.Handled = true;
}
}
break;
case "Eraser":
{
Window.Current.CoreWindow.PointerCursor = new CoreCursor(CoreCursorType.UniversalNo, 1);
StartPoint = e.GetCurrentPoint(canvas).Position;
Pencil = new Polyline();
Pencil.Stroke = new SolidColorBrush(Colors.White);
Pencil.StrokeThickness = 10;
canvas.Children.Add(Pencil);
}
break;
default:
break;
}
}
void Canvas_PointerReleased(object sender, PointerRoutedEventArgs e)
{
Canvas canvas = sender as Canvas;
InkManager inkManager = MedcialInkManager;
if (e.Pointer.PointerId == PenID || e.Pointer.PointerId == TouchID)
{
inkManager.ProcessPointerUp(e.GetCurrentPoint(canvas));
}
TouchID = 0;
PenID = 0;
e.Handled = true;
//Pencil = null;
}
protected override void OnPointerPressed(PointerRoutedEventArgs args)
{
if (args.Pointer.PointerDeviceType == PointerDeviceType.Pen)
{
// Get information
PointerPoint pointerPoint = args.GetCurrentPoint(sheetPanel);
uint id = pointerPoint.PointerId;
InkManager inkManager = this.InkFileManager.InkManager;
// Initialize for inking, erasing, or selecting
if (pointerPoint.Properties.IsEraser)
{
inkManager.Mode = InkManipulationMode.Erasing;
this.InkFileManager.UnselectAll();
}
else if (pointerPoint.Properties.IsBarrelButtonPressed)
{
inkManager.Mode = InkManipulationMode.Selecting;
// Create Polyline for showing enclosure
Polyline polyline = new Polyline
{
Stroke = selectionBrush,
StrokeThickness = 1
};
polyline.Points.Add(pointerPoint.Position);
newLineGrid.Children.Add(polyline);
}
else
{
inkManager.Mode = InkManipulationMode.Inking;
this.InkFileManager.UnselectAll();
}
// Give PointerPoint to InkManager
inkManager.ProcessPointerDown(pointerPoint);
// Add an entry to the dictionary
pointerDictionary.Add(args.Pointer.PointerId, pointerPoint.Position);
// Capture the pointer
this.CapturePointer(args.Pointer);
}
base.OnPointerPressed(args);
}
public InkPresenter()
{
inkManager = new InkManager();
// for the visual
tempPathShape = new Path();
Children.Add(tempPathShape);
// touch events
PointerPressed += OnCanvasPointerPressed;
PointerMoved += OnCanvasPointerMoved;
PointerReleased += OnCanvasPointerReleased;
// defaults
Background = new SolidColorBrush(Colors.Transparent);
StrokeColor = ImageConstructionSettings.Black;
StrokeWidth = 2f;
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
InkManager I = (InkManager)target;
if (GUILayout.Button("Debug Advance Group Chat"))
{
I.AdvanceStory("Group");
}
/*
* Rect lastRect = GUILayoutUtility.GetLastRect();
* var space = GUILayoutUtility.GetRect(GUIContent.none, GUIStyle.none, GUILayout.Height(EditorGUIUtility.singleLineHeight));
* //Rect singleFieldRect = new Rect(lastRect.position.x, lastRect.position.y + lastRect.height + 5, lastRect.width, EditorGUIUtility.singleLineHeight );
* EditorGUI.DrawRect(space, Color.green);
*/
}
private void InitDefaults()
{
GetPreviousFlashbacks();
//VAR//
audioSource = GetComponent <AudioSource>();
inkManager = GetComponent <InkManager>();
button.interactable = false;
coinLayer.SetActive(true);
//UI//
blackCanvasGroup.gameObject.SetActive(true);
blackCanvasGroup.alpha = 1;
LeanTween.alphaCanvas(blackCanvasGroup, 0, 1f);
StartCoroutine(FadeIn(audioSource, 0.8f, heartbeat));
}
private void InkPresenter_StrokesErased(InkPresenter sender, InkStrokesErasedEventArgs args)
{
var removed = args.Strokes;
foreach (var s in removed)
{
strokeList.Remove(s);
}
inkManager = new InkManager();
foreach (var s in strokeList)
{
inkManager.AddStroke(s);
}
ClearSelection();
canvasControl.Invalidate();
}
