string GetMainIconInPlay()
{
return(canvas?.Icons
.Where(elem => elem.IsMainIconInPlay && elem.Tag != IconRoles.GetRoleInt(IconRoles.Role.Folder))
.Select(elem => elem.Text)
.FirstOrDefault());
}
/// <summary>
/// Adds the content of the static.
/// </summary>
void AddStaticContent()
{
OutputDebug("Adding Static Content" +
" Width: " + canvas.CanvasSize.Width + " Height: " + canvas.CanvasSize.Height +
" Layout Width: " + hackLayout.Width +
" Layout Height: " + hackLayout.Height);
resource = App.BoardSettings.InEditMode ? "FastTalkerSkiaSharp.Images.Settings.png" : "FastTalkerSkiaSharp.Images.Speaker.png";
if (canvas.Controller.InFramedModeBottom)
{
stripReference = App.ImageBuilderInstance.BuildSentenceStripBottom();
emitterReference = App.ImageBuilderInstance.BuildStaticIconBottom(resource: resource,
xPercent: 2f,
yPercent: 1.5f,
tag: IconRoles.GetRoleInt(IconRoles.Role.Emitter));
}
else
{
stripReference = App.ImageBuilderInstance.BuildSentenceStrip();
emitterReference = App.ImageBuilderInstance.BuildStaticIcon(resource: resource,
xPercent: 2f,
yPercent: 1.5f,
tag: IconRoles.GetRoleInt(IconRoles.Role.Emitter));
}
canvas.Icons.Add(stripReference);
canvas.Icons.SendToBack(stripReference);
canvas.Icons.Add(emitterReference);
canvas.Icons.SendToBack(emitterReference);
}
/// <summary>
/// Builds the communication folder local.
/// </summary>
/// <returns>The communication folder local.</returns>
/// <param name="selectedIconArgs">Selected icon arguments.</param>
public IconImage BuildCommunicationFolderLocal(ArgsSelectedIcon selectedIconArgs)
{
var item = new Storage.CommunicationIcon()
{
Tag = IconRoles.GetRoleInt(IconRoles.Role.Folder),
Text = selectedIconArgs.Name,
Local = true,
IsStoredInFolder = false,
IsPinned = false,
FolderContainingIcon = "",
ResourceLocation = Constants.LanguageSettings.ResourcePrefixPng + selectedIconArgs.ImageSource + Constants.LanguageSettings.ResourceSuffixPng,
Scale = 1f,
X = -1,
Y = -1
};
return(BuildCommunicationFolderLocal(item));
}
/// <summary>
/// Gets the icons async.
/// </summary>
async System.Threading.Tasks.Task GetIconsAsync()
{
var icons = await App.Database.GetIconsAsync();
if (icons != null && icons.Count > 0)
{
System.Diagnostics.Debug.WriteLineIf(App.OutputVerbose, "icon: " + icons.Count);
foreach (var icon in icons)
{
OutputDebug("Tag: " + icon.Tag +
" Name: " + icon.Text +
" Scale: " + icon.Scale +
" Local: " + icon.Local +
" Stored Bool: " + icon.IsStoredInFolder +
" Base64: " + icon.Base64 +
" FolderTag: " + icon.FolderContainingIcon);
if (icon.Local && icon.Tag == IconRoles.GetRoleInt(IconRoles.Role.Communication))
{
canvas.Icons.Add(App.ImageBuilderInstance.BuildCommunicationIconLocal(icon));
}
else if (!icon.Local && icon.Tag == IconRoles.GetRoleInt(IconRoles.Role.Communication))
{
canvas.Icons.Add(App.ImageBuilderInstance.BuildCommunicationIconDynamic(icon));
}
else if (icon.Local && icon.Tag == IconRoles.GetRoleInt(IconRoles.Role.Folder))
{
canvas.Icons.Add(App.ImageBuilderInstance.BuildCommunicationFolderLocal(icon));
}
}
}
else if (icons != null && icons.Count == 0)
{
OutputDebug("No icons");
}
else
{
OutputDebug("Null");
}
ClearIconsInPlay();
}
public IconSquare BuildSentenceStripBottom()
{
SKSize sizeOfStrip = Constants.DeviceLayout.GetSizeByGrid(canvasReference.CanvasSize,
Constants.DeviceLayout.StripWidth,
Constants.DeviceLayout.StripHeight);
return(new IconSquare(SKRect.Create(Constants.DeviceLayout.Bezel,
canvasReference.CanvasSize.Height - sizeOfStrip.Height - Constants.DeviceLayout.Bezel,
sizeOfStrip.Width,
sizeOfStrip.Height))
{
FillColor = new SKColor(SKColors.White.Red,
SKColors.White.Green,
SKColors.White.Blue, 200),
BorderColor = new SKColor(SKColors.Black.Red,
SKColors.Black.Green,
SKColors.Black.Blue, 200),
Tag = IconRoles.GetRoleInt(IconRoles.Role.SentenceFrame),
IsStoredInAFolder = false,
});
}
/// <summary>
/// Update icon
/// </summary>
/// <param name="feedbackOption">Feedback option.</param>
async void UpdateIconInController(string feedbackOption)
{
int index = controller.Icons.IndexOf(currentIcon);
Icon item = await App.ImageBuilderInstance.AmendIconImage(currentIcon, feedbackOption);
System.Diagnostics.Debug.WriteLineIf(App.OutputVerbose, "Index: " + index);
if (item == null || index == -1)
{
System.Diagnostics.Debug.WriteLineIf(App.OutputVerbose, "was null or unrefernced");
}
else
{
if (currentIcon.Tag == IconRoles.GetRoleInt(IconRoles.Role.Folder))
{
string oldFolderTitle = currentIcon.Text;
if (controller.Icons.Where(elem => elem.IsStoredInAFolder && elem.StoredFolderTag == oldFolderTitle).Any())
{
// Modify dated tags
for (int i = 0; i < controller.Icons.Count; i++)
{
controller.Icons[i].StoredFolderTag = (controller.Icons[i].IsStoredInAFolder &&
controller.Icons[i].Tag == IconRoles.GetRoleInt(IconRoles.Role.Communication) &&
controller.Icons[i].StoredFolderTag == oldFolderTitle) ? item.Text : controller.Icons[i].StoredFolderTag;
}
}
}
controller.Icons[index] = item;
controller.Invalidate();
controller.PromptResave();
currentIcon = controller.Icons[index];
}
}
/// <summary>
/// Add an icon from the camera
/// </summary>
async void AddIconPhoto()
{
await Xamarin.Forms.Application.Current.MainPage.Navigation.PopAllPopupAsync();
string[] base64 = await App.UserInputInstance.GetImageFromCameraCallAsync();
if (base64 == null)
{
return;
}
Storage.CommunicationIcon dynamicIcon = new Storage.CommunicationIcon()
{
Tag = IconRoles.GetRoleInt(IconRoles.Role.Communication),
Text = base64[0],
Local = false,
IsStoredInFolder = false,
FolderContainingIcon = "",
Base64 = base64[1],
Scale = 1f,
X = -1,
Y = -1
};
IconImage testImage = null;
try
{
testImage = App.ImageBuilderInstance.BuildCommunicationIconDynamic(icon: dynamicIcon);
}
catch
{
return;
}
SaveCommunicationIconEvent(testImage);
}
/// <summary>
/// Adds an icon representing a folder
/// </summary>
async void AddFolder()
{
await Xamarin.Forms.Application.Current.MainPage.Navigation.PopAllPopupAsync();
System.Collections.Generic.IEnumerable <Icon> foldersInField = controller.Icons.Where(elem => elem.Tag == IconRoles.GetRoleInt(IconRoles.Role.Folder));
FolderIconPickerViewModel viewModel = new FolderIconPickerViewModel(foldersInField);
viewModel.FolderConstructed += SaveFolderEvent;
Pages.FolderIconPicker folderPicker = new Pages.FolderIconPicker()
{
BindingContext = viewModel
};
await Xamarin.Forms.Application.Current.MainPage.Navigation.PushAsync(folderPicker);
}
/// <summary>
/// Adds an icon from storage
/// </summary>
async void AddIconStored()
{
await Xamarin.Forms.Application.Current.MainPage.Navigation.PopAllPopupAsync();
await Plugin.Media.CrossMedia.Current.Initialize();
var status = await Plugin.Permissions.CrossPermissions.Current.CheckPermissionStatusAsync(Plugin.Permissions.Abstractions.Permission.Photos);
if (status != Plugin.Permissions.Abstractions.PermissionStatus.Granted)
{
if (await Plugin.Permissions.CrossPermissions.Current.ShouldShowRequestPermissionRationaleAsync(Plugin.Permissions.Abstractions.Permission.Photos))
{
await Acr.UserDialogs.UserDialogs.Instance.AlertAsync("Need access to photos to make icon");
}
var results = await Plugin.Permissions.CrossPermissions.Current.RequestPermissionsAsync(new[] { Plugin.Permissions.Abstractions.Permission.Photos });
status = results[Plugin.Permissions.Abstractions.Permission.Photos];
}
if (status == Plugin.Permissions.Abstractions.PermissionStatus.Granted)
{
var userInput = await Acr.UserDialogs.UserDialogs.Instance.PromptAsync("Name the icon to add");
if (userInput == null || string.IsNullOrWhiteSpace(userInput.Text))
{
return;
}
Plugin.Media.Abstractions.MediaFile file = await Plugin.Media.CrossMedia.Current.PickPhotoAsync(new Plugin.Media.Abstractions.PickMediaOptions
{
CustomPhotoSize = 500,
CompressionQuality = 80,
RotateImage = true,
});
if (file == null || file.Path == null)
{
return;
}
if (System.IO.File.Exists(@file.Path))
{
byte[] imageArray = null;
//if (Device.RuntimePlatform == Device.Android)
//{
// imageArray = DependencyService.Get<InterfaceBitmapResize>().RotateImage(@file.Path);
//}
//else
//{
imageArray = System.IO.File.ReadAllBytes(@file.Path);
//}
string base64ImageRepresentation = System.Convert.ToBase64String(imageArray);
file.Dispose();
Storage.CommunicationIcon dynamicIcon = new Storage.CommunicationIcon()
{
Tag = IconRoles.GetRoleInt(IconRoles.Role.Communication),
Text = userInput.Text,
Local = false,
IsStoredInFolder = false,
FolderContainingIcon = "",
Base64 = base64ImageRepresentation,
Scale = 1f,
X = -1,
Y = -1
};
IconImage testImage = null;
try
{
testImage = App.ImageBuilderInstance.BuildCommunicationIconDynamic(icon: dynamicIcon);
}
catch
{
return;
}
SaveCommunicationIconEvent(testImage);
}
}
else if (status != Plugin.Permissions.Abstractions.PermissionStatus.Unknown)
{
await Acr.UserDialogs.UserDialogs.Instance.AlertAsync("Can not continue, try again");
}
}
/// <summary>
/// Process touch completed events
/// </summary>
/// <param name="e"></param>
/// <param name="outputVerbose"></param>
async void ProcessCompletedTouchEvent(SkiaSharp.Views.Forms.SKTouchEventArgs e, bool outputVerbose = false)
{
if (canvas.Icons[canvas.Icons.IndexOf(emitterReference)].IsPressed)
{
canvas.Icons[canvas.Icons.IndexOf(emitterReference)].IsPressed = false;
canvas.InvalidateSurface();
}
// If out of scope, return
if (_currentIcon == null)
{
return;
}
switch (_currentIcon.Tag)
{
case (int)IconRoles.Role.Communication:
if (canvas.Controller.InEditMode && !hasMoved)
{
if (App.UserInputInstance.AreModalsOpen())
{
return;
}
OutputDebug("Completed icon tap");
if (App.InstanceModificationPage == null)
{
App.InstanceModificationPage = new ModifyPage(_currentIcon, canvas.Controller);
}
else
{
App.InstanceModificationPage.UpdateCurrentIcon(_currentIcon);
}
await Navigation.PushPopupAsync(App.InstanceModificationPage);
}
else if (canvas.Controller.InEditMode &&
!_currentIcon.IsInsertableIntoFolder &&
System.DateTime.Now.Subtract(itemPressTime).Seconds > 3)
{
if (App.UserInputInstance.AreModalsOpen())
{
return;
}
OutputDebug("Completed icon held > 3s");
if (App.InstanceModificationPage == null)
{
App.InstanceModificationPage = new ModifyPage(_currentIcon, canvas.Controller);
}
else
{
App.InstanceModificationPage.UpdateCurrentIcon(_currentIcon);
}
await Navigation.PushPopupAsync(App.InstanceModificationPage);
}
else if (hasMoved && _currentIcon.IsInsertableIntoFolder)
{
OutputDebug("Icon completed, has moved");
var folderOfInterest = GetFoldersOfInterest();
App.UserInputInstance.InsertIntoFolder(_currentIcon: _currentIcon, folderOfInterest: folderOfInterest);
}
e.Handled = true;
return;
case (int)IconRoles.Role.Folder:
if (canvas.Controller.InEditMode && !hasMoved)
{
if (App.UserInputInstance.AreModalsOpen())
{
return;
}
OutputDebug("Completed folder tap");
if (App.InstanceModificationPage == null)
{
App.InstanceModificationPage = new ModifyPage(_currentIcon, canvas.Controller);
}
else
{
App.InstanceModificationPage.UpdateCurrentIcon(_currentIcon);
}
await Navigation.PushPopupAsync(App.InstanceModificationPage);
e.Handled = true;
}
else if (canvas.Controller.InEditMode && System.DateTime.Now.Subtract(itemPressTime).Seconds > 3)
{
if (App.UserInputInstance.AreModalsOpen())
{
return;
}
OutputDebug("Completed folder hold");
if (App.InstanceModificationPage == null)
{
App.InstanceModificationPage = new ModifyPage(_currentIcon, canvas.Controller);
}
else
{
App.InstanceModificationPage.UpdateCurrentIcon(_currentIcon);
}
await Navigation.PushPopupAsync(App.InstanceModificationPage);
e.Handled = true;
}
if (!canvas.Controller.InEditMode && !hasMoved)
{
if (App.UserInputInstance.AreModalsOpen())
{
return;
}
OutputDebug("Hit a folder, in user mode: " + _currentIcon.Text);
// This is where the current item is the folder in question
var itemsMatching = GetItemsMatching();
// Leave if empty
if (itemsMatching == null)
{
e.Handled = true;
return;
}
if (App.InstanceStoredIconsViewModel == null)
{
App.InstanceStoredIconsViewModel = new ViewModels.StoredIconPopupViewModel
{
Padding = new Xamarin.Forms.Thickness(100, 100, 100, 100),
IsSystemPadding = true,
FolderWithIcons = _currentIcon.Text,
ItemsMatching = itemsMatching,
};
App.InstanceStoredIconsViewModel.IconSelected += RestoreIcon;
App.InstanceStoredIconPage = new StoredIconPopup()
{
BindingContext = App.InstanceStoredIconsViewModel
};
}
else
{
App.InstanceStoredIconsViewModel.FolderWithIcons = _currentIcon.Text;
App.InstanceStoredIconsViewModel.ItemsMatching = itemsMatching;
}
await Xamarin.Forms.Application.Current.MainPage.Navigation.PushPopupAsync(App.InstanceStoredIconPage);
e.Handled = true;
}
else if (!canvas.Controller.InEditMode && System.DateTime.Now.Subtract(itemPressTime).Seconds > 3)
{
if (App.UserInputInstance.AreModalsOpen())
{
return;
}
OutputDebug("Held a folder, in user mode: " + _currentIcon.Text);
// This is where the current item is the folder in question
var itemsMatching = GetItemsMatching();
// Leave if empty
if (itemsMatching == null)
{
e.Handled = true;
return;
}
if (App.InstanceStoredIconsViewModel == null)
{
App.InstanceStoredIconsViewModel = new ViewModels.StoredIconPopupViewModel
{
Padding = new Xamarin.Forms.Thickness(100, 100, 100, 100),
IsSystemPadding = true,
FolderWithIcons = _currentIcon.Text,
ItemsMatching = itemsMatching,
};
App.InstanceStoredIconsViewModel.IconSelected += RestoreIcon;
App.InstanceStoredIconPage = new StoredIconPopup()
{
BindingContext = App.InstanceStoredIconsViewModel
};
}
else
{
App.InstanceStoredIconsViewModel.FolderWithIcons = _currentIcon.Text;
App.InstanceStoredIconsViewModel.ItemsMatching = itemsMatching;
}
await Xamarin.Forms.Application.Current.MainPage.Navigation.PushPopupAsync(App.InstanceStoredIconPage);
e.Handled = true;
}
return;
default:
// Emitter was tapped/held
if (holdingEmitter)
{
holdingEmitter = false;
OutputDebug("Seconds held: " + (System.DateTime.Now - emitterPressTime).TotalSeconds.ToString());
OutputDebug("Bottom Oriented: " + canvas.Controller.InFramedModeBottom);
// Enter into Edit Mode
if ((System.DateTime.Now - emitterPressTime).Seconds >= thresholdAdmin && !canvas.Controller.InEditMode)
{
canvas.Controller.UpdateSettings(isEditing: !canvas.Controller.InEditMode,
isInFrame: canvas.Controller.InFramedMode,
isFrameBottom: canvas.Controller.InFramedModeBottom,
isAutoDeselecting: canvas.Controller.RequireDeselect,
isInIconModeAuto: canvas.Controller.IconModeAuto);
canvas.Controller.BackgroundColor = canvas.Controller.InEditMode ? SKColors.DarkOrange : SKColors.DimGray;
resource = App.BoardSettings.InEditMode ? "FastTalkerSkiaSharp.Images.Settings.png" : "FastTalkerSkiaSharp.Images.Speaker.png";
if (canvas.Controller.InFramedModeBottom && canvas.Controller.InFramedMode)
{
var list = canvas.Icons.Where(elem => elem.Tag == IconRoles.GetRoleInt(IconRoles.Role.Emitter)).ToList();
foreach (var icon in list)
{
canvas.Icons.Remove(icon);
}
emitterReference = App.ImageBuilderInstance.BuildStaticIconBottom(resource: resource,
xPercent: 2f,
yPercent: 1.5f,
tag: IconRoles.GetRoleInt(IconRoles.Role.Emitter));
canvas.Icons.Add(emitterReference);
}
else
{
var list = canvas.Icons.Where(elem => elem.Tag == IconRoles.GetRoleInt(IconRoles.Role.Emitter)).ToList();
foreach (var icon in list)
{
canvas.Icons.Remove(icon);
}
emitterReference = App.ImageBuilderInstance.BuildStaticIcon(resource: resource,
xPercent: 2f,
yPercent: 1.5f,
tag: IconRoles.GetRoleInt(IconRoles.Role.Emitter));
canvas.Icons.Add(emitterReference);
}
SendReferenceToBack(emitterReference);
ClearIconsInPlay();
}
// TODO: Fix exit program (changed since emitter fx altered)
else if ((System.DateTime.Now - emitterPressTime).Seconds >= thresholdReset && canvas.Controller.InEditMode)
{
// TODO: Confirm message?
OutputDebug("In reset hook, returning to home");
Xamarin.Forms.Application.Current.MainPage = new TitlePage();
}
// Speak output
else
{
if (canvas.Controller.InFramedMode)
{
var mIntersectingIcons = GetSentenceContent();
if (mIntersectingIcons != null && mIntersectingIcons.Count() > 0)
{
var output = System.String.Join(" ", mIntersectingIcons);
OutputDebug("Verbal output (Frame): " + output);
commInterface.SpeakText(text: output);
}
}
else if (!canvas.Controller.IconModeAuto)
{
var selectedIcons = GetMainIconInPlay();
if (selectedIcons != null)
{
OutputDebug("Verbal output (Icon): " + selectedIcons);
commInterface.SpeakText(text: selectedIcons);
}
if (canvas.Controller.RequireDeselect)
{
ClearIconsInPlay();
}
}
}
e.Handled = true;
}
return;
}
}
/// <summary>
/// Process moving touches
/// </summary>
/// <param name="e"></param>
/// <param name="outputVerbose"></param>
void ProcessMovedTouchEvent(SkiaSharp.Views.Forms.SKTouchEventArgs e, bool outputVerbose = false)
{
// If out of scope, return
if (_currentIcon == null)
{
return;
}
OutputDebug("Moving Event: " + e.ToString());
switch (_currentIcon.Tag)
{
case (int)IconRoles.Role.Control:
return;
case (int)IconRoles.Role.Emitter:
return;
case (int)IconRoles.Role.Communication:
hasMoved = true;
// If pinned, prevent move
if (_currentIcon.IsPinnedToSpot && !canvas.Controller.InEditMode)
{
return;
}
_currentIcon.Location = new SKPoint(e.Location.X - _currentIcon.Bounds.Width / 2f,
e.Location.Y - _currentIcon.Bounds.Height / 2f);
ClampCurrentIconToCanvasBounds();
if (canvas.Controller.InFramedMode)
{
_currentIcon.IsSpeakable = _currentIcon.Bounds.IntersectsWith(stripReference.Bounds);
}
else
{
for (int i = 0; i < canvas.Icons.Count; i++)
{
canvas.Icons[i].IsMainIconInPlay = false;
}
_currentIcon.IsMainIconInPlay = true;
}
_currentIcon.IsInsertableIntoFolder = canvas.Icons.Where(elem => elem.Tag == IconRoles.GetRoleInt(IconRoles.Role.Folder))
.Where(folder => folder.Bounds.IntersectsWith(_currentIcon.Bounds))
.Any();
_startLocation = _currentIcon.Location;
return;
case (int)IconRoles.Role.Folder:
hasMoved = true;
if (!canvas.Controller.InEditMode)
{
return;
}
_currentIcon.Location = new SKPoint(e.Location.X - _currentIcon.Bounds.Width / 2f,
e.Location.Y - _currentIcon.Bounds.Height / 2f);
ClampCurrentIconToCanvasBounds();
_startLocation = _currentIcon.Location;
return;
default:
return;
}
}
/// <summary>
/// Process initial touches
/// </summary>
/// <param name="e"></param>
/// <param name="outputVerbose"></param>
void ProcessInitialTouchEvent(SkiaSharp.Views.Forms.SKTouchEventArgs e, bool outputVerbose = false)
{
_currentIcon = canvas.GetIconAtPoint(e.Location);
// Confirmation of movement
hasMoved = false;
// Fail out if null
if (_currentIcon == null)
{
return;
}
itemPressTime = System.DateTime.Now;
// Get origin of element
_startLocation = _currentIcon.Location;
switch (_currentIcon.Tag)
{
case (int)IconRoles.Role.SentenceFrame:
OutputDebug("Hit sentence frame");
return;
case (int)IconRoles.Role.Emitter:
// Serves as Settings button in edit mode
if (canvas.Controller.InEditMode)
{
canvas.Icons[canvas.Icons.IndexOf(emitterReference)].IsPressed = true;
canvas.InvalidateSurface();
OutputDebug("Hit settings (speech emitter)");
App.UserInputInstance.QueryUserMainSettingsAsync();
}
// Serves as speech emitter as normal
else
{
canvas.Icons[canvas.Icons.IndexOf(emitterReference)].IsPressed = true;
canvas.InvalidateSurface();
OutputDebug("Hit speech emitter");
holdingEmitter = true;
emitterPressTime = System.DateTime.Now;
}
return;
case (int)IconRoles.Role.Folder:
OutputDebug("Hit Folder");
ClearIconsInPlay();
canvas.Icons.BringToFront(_currentIcon);
return;
default:
OutputDebug("In Default Hit");
ClearIconsInPlay();
canvas.Icons.BringToFront(_currentIcon);
if (!canvas.Controller.InFramedMode && !canvas.Controller.IconModeAuto)
{
_currentIcon.IsMainIconInPlay = true;
}
else if (!canvas.Controller.InFramedMode &&
_currentIcon != null &&
_currentIcon.Tag == IconRoles.GetRoleInt(IconRoles.Role.Communication) &&
!canvas.Controller.InEditMode &&
canvas.Controller.IconModeAuto)
{
commInterface.SpeakText(_currentIcon.Text);
e.Handled = true;
}
/* Pinned icons in sentence mode */
else if (canvas.Controller.InFramedMode &&
!canvas.Controller.InEditMode &&
_currentIcon.IsPinnedToSpot &&
!stripReference.Bounds.IntersectsWith(_currentIcon.Bounds))
{
OutputDebug("Hit a pinned icon in sentence mode, outside of frame");
e.Handled = true;
commInterface.SpeakText(text: _currentIcon.Text);
_currentIcon = null;
}
return;
}
}
/// <summary>
/// Amends the icon image.
/// </summary>
/// <returns>The icon image.</returns>
/// <param name="element">Icon.</param>
/// <param name="changeActions">Change actions.</param>
public async System.Threading.Tasks.Task <Icon> AmendIconImage(Icon element, string changeActions)
{
float newScale = element.CurrentScale;
string newText = element.Text;
bool isPinned = element.IsPinnedToSpot;
switch (changeActions)
{
case Constants.LanguageSettings.EditGrow:
newScale = element.CurrentScale * 1.1f;
break;
case Constants.LanguageSettings.EditShrink:
newScale = element.CurrentScale * 0.9f;
break;
case Constants.LanguageSettings.EditGrow2:
newScale = element.CurrentScale * 1.5f;
break;
case Constants.LanguageSettings.EditShrink2:
newScale = element.CurrentScale * 0.5f;
break;
case Constants.LanguageSettings.EditResetSize:
newScale = 1.5f;
break;
case Constants.LanguageSettings.EditText:
newText = await App.UserInputInstance.ModifyIconTextAsync(newText);
if (element.Tag == IconRoles.GetRoleInt(IconRoles.Role.Folder) &&
canvasReference.Icons.Where(elem => elem.Text == newText).Any())
{
await Acr.UserDialogs.UserDialogs.Instance.AlertAsync("Please select a different name for the folder.", title : "Cannot rename folder.");
return(element);
}
break;
case Constants.LanguageSettings.EditPinning:
isPinned = !isPinned;
break;
case Constants.LanguageSettings.EditClose:
return(element);
default:
return(element);
}
var icon = new Storage.CommunicationIcon()
{
Text = newText,
X = element.Left,
Y = element.Top,
Tag = element.Tag,
Local = element.LocalImage,
TextVisible = true,
IsPinned = isPinned,
Base64 = (element.LocalImage) ? "" : element.ImageInformation,
ResourceLocation = (element.LocalImage) ? element.ImageInformation : "",
IsStoredInFolder = element.IsStoredInAFolder,
FolderContainingIcon = element.StoredFolderTag,
Scale = newScale,
TextScale = 1f,
HashCode = element.GetHashCode()
};
if (element.Tag == IconRoles.GetRoleInt(IconRoles.Role.Communication) && icon.Local)
{
System.Diagnostics.Debug.WriteLineIf(App.OutputVerbose, "CanvasView.Role.Communication && icon.Local");
return(BuildCommunicationIconLocal(icon));
}
else if (element.Tag == IconRoles.GetRoleInt(IconRoles.Role.Communication) && !icon.Local)
{
System.Diagnostics.Debug.WriteLineIf(App.OutputVerbose, "CanvasView.Role.Communication && !icon.Local");
return(BuildCommunicationIconDynamic(icon));
}
else if (element.Tag == IconRoles.GetRoleInt(IconRoles.Role.Folder))
{
System.Diagnostics.Debug.WriteLineIf(App.OutputVerbose, "CanvasView.Role.Folder");
return(BuildCommunicationFolderLocal(icon));
}
else
{
return(null);
}
}
/// <summary>
/// Saves the current settings.
/// </summary>
/// <param name="sender">Sender.</param>
/// <param name="e">E.</param>
async void SaveCurrentSettings(object sender, System.EventArgs e)
{
OutputDebug("Saving settings (event-based)");
CopySettingsFromController();
if (App.BoardSettings.InFramedMode)
{
App.BoardSettings.InIconModeAuto = false;
resource = App.BoardSettings.InEditMode ? "FastTalkerSkiaSharp.Images.Settings.png" : "FastTalkerSkiaSharp.Images.Speaker.png";
if (App.BoardSettings.IsBottomOriented)
{
canvas.Icons.Remove(emitterReference);
emitterReference = App.ImageBuilderInstance.BuildStaticIconBottom(resource: resource,
xPercent: 2f,
yPercent: 1.5f,
tag: IconRoles.GetRoleInt(IconRoles.Role.Emitter));
canvas.Icons.Add(emitterReference);
canvas.Icons.Remove(stripReference);
stripReference = App.ImageBuilderInstance.BuildSentenceStripBottom();
canvas.Icons.Add(stripReference);
}
else
{
canvas.Icons.Remove(emitterReference);
emitterReference = App.ImageBuilderInstance.BuildStaticIcon(resource: resource,
xPercent: 2f,
yPercent: 1.5f,
tag: IconRoles.GetRoleInt(IconRoles.Role.Emitter));
canvas.Icons.Add(emitterReference);
canvas.Icons.Remove(stripReference);
stripReference = App.ImageBuilderInstance.BuildSentenceStrip();
canvas.Icons.Add(stripReference);
}
SendReferenceToBack(stripReference);
SendReferenceToBack(emitterReference);
canvas.InvalidateSurface();
}
else
{
resource = App.BoardSettings.InEditMode ? "FastTalkerSkiaSharp.Images.Settings.png" : "FastTalkerSkiaSharp.Images.Speaker.png";
canvas.Icons.Remove(emitterReference);
emitterReference = App.ImageBuilderInstance.BuildStaticIcon(resource: resource,
xPercent: 2f,
yPercent: 1.5f,
tag: IconRoles.GetRoleInt(IconRoles.Role.Emitter));
canvas.Icons.Add(emitterReference);
SendReferenceToBack(emitterReference);
}
if (Xamarin.Forms.Device.RuntimePlatform == Xamarin.Forms.Device.Android)
{
Xamarin.Forms.DependencyService.Get <Interfaces.InterfaceAdministration>().RequestAdmin(!canvas.Controller.InEditMode);
}
await App.Database.InsertOrUpdateAsync(App.BoardSettings);
if (canvas.Icons[canvas.Icons.IndexOf(emitterReference)].IsPressed)
{
canvas.Icons[canvas.Icons.IndexOf(emitterReference)].IsPressed = false;
canvas.InvalidateSurface();
}
ClearIconsInPlay();
}
/// <summary>
/// Get icons that are useful from storage
/// </summary>
/// <returns>The icons user interactable.</returns>
System.Collections.Generic.List <Icon> GetIconsUserInteractable()
{
return(canvas.Icons?.Where(elem => elem.Tag == IconRoles.GetRoleInt(IconRoles.Role.Communication) ||
elem.Tag == IconRoles.GetRoleInt(IconRoles.Role.Folder)).ToList());
}
System.Collections.Generic.IEnumerable <string> GetSentenceContent()
{
return(canvas?.Icons.Where(elem => elem.IsSpeakable && elem.Tag != IconRoles.GetRoleInt(IconRoles.Role.Folder))
.OrderBy(elem => elem.Left)
.Select(elem => elem.Text));
}
System.Collections.Generic.IEnumerable <Icon> GetFoldersOfInterest()
{
return(canvas.Icons.Where(elem => elem.Tag == IconRoles.GetRoleInt(IconRoles.Role.Folder) && !elem.IsStoredInAFolder)
.Where(folder => folder.Bounds.IntersectsWith(_currentIcon.Bounds)));
}
