public static void Show(string msg, string caption, MessageBoxButton button, MessageImage msgImage, Action<MessageBoxResult> callback)
{
DialogMessage result = new DialogMessage(null, msg, callback);
result.Caption = caption + ";" + ((int)msgImage).ToString();
result.Button = button;
AppMessages.SendMessage.Send(result);
}
public static ITwicasKiitos CreateKiitosMessage(Item item)
{
Debug.Assert(Tools.IsKiitos(item));
var itemName = "キートス";
var message = $"[{item.t13}] {item.Message}{Environment.NewLine}";
var itemImage = new MessageImage
{
Url = item.ItemImage,
Alt = itemName,
Height = 40,
Width = 40,
};
return(new TwicasKiitos(item.Raw)
{
UserIcon = new MessageImage
{
Url = item.SenderImage,
Alt = null,
Height = 40,
Width = 40,
},
ItemName = itemName,
CommentItems = new List <IMessagePart> {
Common.MessagePartFactory.CreateMessageText(message), itemImage
},
NameItems = new List <IMessagePart> {
Common.MessagePartFactory.CreateMessageText(item.t12)
},
UserId = item.SenderName,
ItemId = item.Id,
});
}
private static MessageBoxImage ConvertMessageBoxImages(MessageImage messageBoxImages)
{
switch (messageBoxImages)
{
case MessageImage.Asterisk:
return(MessageBoxImage.Asterisk);
case MessageImage.Error:
return(MessageBoxImage.Error);
case MessageImage.Exclamation:
return(MessageBoxImage.Exclamation);
case MessageImage.Hand:
return(MessageBoxImage.Hand);
case MessageImage.Information:
return(MessageBoxImage.Information);
case MessageImage.None:
return(MessageBoxImage.None);
case MessageImage.Question:
return(MessageBoxImage.Question);
case MessageImage.Stop:
return(MessageBoxImage.Stop);
case MessageImage.Warning:
return(MessageBoxImage.Warning);
default:
return(MessageBoxImage.None);
}
}
public async static Task Run([QueueTrigger("queue-image-delete")]
MessageImage message,
IBinder binder,
ILogger log)
{
log.LogInformation($"Função ativada!");
var blobAtributte = new BlobAttribute(message.ImageUri, FileAccess.Read);
var cloudBlobStream = await binder.BindAsync <ICloudBlob>(blobAtributte);
await cloudBlobStream.DeleteIfExistsAsync();
await cloudBlobStream.Container.SetPermissionsAsync(new BlobContainerPermissions()
{
PublicAccess = BlobContainerPublicAccessType.Blob
});
var connectionString = Environment.GetEnvironmentVariable("SqlConnectionString");
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
var textSql = $@"DELETE FROM [dbo].[BibliotecaMusical] WHERE Id = {message.Id}";
using (SqlCommand cmd = new SqlCommand(textSql, conn))
{
var rowsAffected = cmd.ExecuteNonQuery();
log.LogInformation($"rowsAffected: {rowsAffected}");
}
}
log.LogInformation($"Função encerrada!");
}
/// <summary>
/// Shows the message box.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="button">The button.</param>
/// <param name="icon">The icon.</param>
/// <returns>The message result.</returns>
/// <exception cref="ArgumentException">The <paramref name="message"/> is <c>null</c> or whitespace.</exception>
protected virtual Task<MessageResult> ShowMessageBoxAsync(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None)
{
Argument.IsNotNullOrWhitespace("message", message);
var tcs = new TaskCompletionSource<MessageResult>();
_dispatcherService.BeginInvoke(() =>
{
MessageBoxResult result;
var messageBoxButton = TranslateMessageButton(button);
var messageBoxImage = TranslateMessageImage(icon);
var activeWindow = Application.Current.GetActiveWindow();
if (activeWindow != null)
{
result = MessageBox.Show(activeWindow, message, caption, messageBoxButton, messageBoxImage);
}
else
{
result = MessageBox.Show(message, caption, messageBoxButton, messageBoxImage);
}
tcs.SetResult(TranslateMessageBoxResult(result));
});
return tcs.Task;
}
/// <summary>
/// Shows the specified message and returns the result.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="button">The button.</param>
/// <param name="icon">The icon.</param>
/// <returns>The <see cref="MessageResult"/>.</returns>
public MessageResult Show(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None) {
#if WinRT
return ShowMessageBox(message, caption, button, icon).Result;
#else
return ShowMessageBox(message, caption, button, icon);
#endif
}
public override Task<MessageResult> ShowAsync(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None)
{
Argument.IsNotNullOrWhitespace("message", message);
Log.Info("Showing message to the user:\n\n{0}", this.GetAsText(message, button));
var tcs = new TaskCompletionSource<MessageResult>();
_dispatcherService.BeginInvoke(async () =>
{
var previousCursor = Mouse.OverrideCursor;
Mouse.OverrideCursor = null;
var vm = _viewModelFactory.CreateViewModel<MessageBoxViewModel>(null, null);
vm.Message = message;
vm.Button = button;
vm.Icon = icon;
vm.SetTitle(caption);
await _uiVisualizerService.ShowDialogAsync(vm);
Mouse.OverrideCursor = previousCursor;
Log.Info("Result of message: {0}", vm.Result);
tcs.TrySetResult(vm.Result);
});
return tcs.Task;
}
/// <summary>
/// Shows the message box.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="button">The button.</param>
/// <param name="icon">The icon.</param>
/// <returns>The message result.</returns>
/// <exception cref="ArgumentException">The <paramref name="message"/> is <c>null</c> or whitespace.</exception>
protected virtual async Task<MessageResult> ShowMessageBox(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None)
{
// TODO: Add translations for system
var result = MessageBoxResult.None;
var messageBoxButton = TranslateMessageButton(button);
var messageDialog = new MessageDialog(message, caption);
if (Enum<MessageButton>.Flags.IsFlagSet(button, MessageButton.OK) ||
Enum<MessageButton>.Flags.IsFlagSet(button, MessageButton.OKCancel))
{
messageDialog.Commands.Add(new UICommand("OK", cmd => result = MessageBoxResult.OK));
}
if (Enum<MessageButton>.Flags.IsFlagSet(button, MessageButton.YesNo) ||
Enum<MessageButton>.Flags.IsFlagSet(button, MessageButton.YesNoCancel))
{
messageDialog.Commands.Add(new UICommand("Yes", cmd => result = MessageBoxResult.Yes));
messageDialog.Commands.Add(new UICommand("No", cmd => result = MessageBoxResult.No));
}
if (Enum<MessageButton>.Flags.IsFlagSet(button, MessageButton.OKCancel) ||
Enum<MessageButton>.Flags.IsFlagSet(button, MessageButton.YesNoCancel))
{
messageDialog.Commands.Add(new UICommand("Cancel", cmd => result = MessageBoxResult.Cancel));
messageDialog.CancelCommandIndex = (uint)messageDialog.Commands.Count - 1;
}
await messageDialog.ShowAsync();
return TranslateMessageBoxResult(result);
}
private MessageResult ShowMessage(string messageBoxText, string caption, MessageButton button, MessageImage icon,
MessageResult defaultResult)
{
DialogResult result = MessageBox.Show(messageBoxText, caption, ConvertButtons(button), ConvertImage(icon),
ConvertDefaultResult(button, defaultResult));
return ConvertResult(result);
}
public NicoCommentViewModel(NicoSitePlugin.INicoComment comment, IMessageMetadata metadata, IMessageMethods methods, IConnectionStatus connectionStatus, IOptions options)
: this(comment as NicoSitePlugin.INicoMessage, metadata, methods, connectionStatus, options)
{
//if (!string.IsNullOrEmpty(comment.UserName))
//{
// _nameItems = MessagePartFactory.CreateMessageItems(comment.UserName);
//}
var siteOptions = (INicoSiteOptions)metadata.SiteOptions;
siteOptions.PropertyChanged += (s, e) =>
{
switch (e.PropertyName)
{
case nameof(siteOptions.IsAutoSetNickname):
{
SetNameItems(comment, metadata, siteOptions);
}
break;
}
};
SetNameItems(comment, metadata, siteOptions);
MessageItems = MessagePartFactory.CreateMessageItems(comment.Text);
if (IsValudThumbnailUrl(comment.ThumbnailUrl))
{
Thumbnail = new MessageImage
{
Url = comment.ThumbnailUrl,
Height = 40,
Width = 40,
};
}
Id = comment.Id;
PostTime = comment.PostedAt.ToLocalTime().ToString("HH:mm:ss");
}
protected override async Task<MessageResult> ShowMessageBoxAsync(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None)
{
var window = Application.Current.MainWindow as MetroWindow;
if (window == null)
{
return MessageResult.Cancel;
}
var style = MessageDialogStyle.Affirmative;
var affirmativeResult = MessageResult.OK;
var negativeResult = MessageResult.No;
var auxiliaryResult = MessageResult.Cancel;
switch (button)
{
case MessageButton.OK:
style = MessageDialogStyle.Affirmative;
affirmativeResult = MessageResult.OK;
break;
case MessageButton.OKCancel:
style = MessageDialogStyle.AffirmativeAndNegative;
affirmativeResult = MessageResult.OK;
negativeResult = MessageResult.Cancel;
break;
case MessageButton.YesNo:
style = MessageDialogStyle.AffirmativeAndNegative;
affirmativeResult = MessageResult.Yes;
negativeResult = MessageResult.No;
break;
case MessageButton.YesNoCancel:
style = MessageDialogStyle.AffirmativeAndNegativeAndSingleAuxiliary;
affirmativeResult = MessageResult.Yes;
negativeResult = MessageResult.No;
auxiliaryResult = MessageResult.Cancel;
break;
default:
throw new ArgumentOutOfRangeException("button");
}
var result = await window.ShowMessageAsync(caption, message, style);
switch (result)
{
case MessageDialogResult.Negative:
return negativeResult;
case MessageDialogResult.Affirmative:
return affirmativeResult;
case MessageDialogResult.FirstAuxiliary:
return auxiliaryResult;
default:
throw new ArgumentOutOfRangeException();
}
}
public static void Show(string msg, string caption, MessageBoxButton button, MessageImage msgImage, Action <MessageBoxResult> callback)
{
DialogMessage result = new DialogMessage(null, msg, callback);
result.Caption = caption + ";" + ((int)msgImage).ToString();
result.Button = button;
AppMessages.SendMessage.Send(result);
}
/// <summary>
/// Creates and shows a dialog with the specified <paramref name="message" />, <paramref name="caption" />, <paramref name="image" /> and <paramref name="buttons" />.
/// Returns the index of the clicked button (0 = first button, 1 = second button, ...).
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="image">The image.</param>
/// <param name="buttons">The buttons.</param>
public int ShowDialog(string message, string caption, MessageImage image, params string[] buttons)
{
var viewModel = new MessageDialogViewModel(message, caption, image, buttons);
this._windowManager.ShowDialog(viewModel, null, WindowSettings.With().AutoSize().NoResize().NoWindowButtons().NoIcon());
return(viewModel.Buttons.IndexOf(viewModel.SelectedButton));
}
/// <summary>
/// Shows an information message to the user and allows a callback operation when the message is completed.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="button">The button.</param>
/// <param name="icon">The icon.</param>
/// <param name="completedCallback">The callback to invoke when the message is completed. Can be <c>null</c>.</param>
/// <remarks>
/// There is no garantuee that the method will be executed asynchronous, only that the <paramref name="completedCallback"/>
/// will be invoked when the message is dismissed.
/// </remarks>
/// <exception cref="ArgumentException">The <paramref name="message"/> is <c>null</c> or whitespace.</exception>
public virtual void ShowAsync(string message, string caption = "", MessageButton button = MessageButton.OK,
MessageImage icon = MessageImage.None, Action <MessageResult> completedCallback = null)
{
var result = Show(message, caption, button, icon);
if (completedCallback != null)
{
completedCallback(result);
}
}
private static MessageBoxImage MessageImageToMessageBoxImage(MessageImage image)
{
return(image switch
{
MessageImage.Question => MessageBoxImage.Question,
MessageImage.Error => MessageBoxImage.Error,
MessageImage.Warning => MessageBoxImage.Warning,
MessageImage.Success => MessageBoxImage.None,
_ => throw new ArgumentOutOfRangeException()
});
static async Task<MessageResult> ShowMessageBox(string message, string caption, MessageButton button, MessageImage icon) {
if (string.IsNullOrEmpty(message))
throw new ArgumentNullException("message");
if (icon != MessageImage.None)
throw new NotSupportedException("Unfortunately, the default MessageBox class does not support setting an icon.");
var messageBoxButton = TranslateMessageButton(button);
var result = await MessageBox.ShowAsync(message, caption, messageBoxButton);
return TranslateMessageBoxResult(result);
}
public Task<MessageResult> ShowAsync(string message, string caption = "",
MessageButton button = MessageButton.Ok, MessageImage icon = MessageImage.None,
MessageResult defaultResult = MessageResult.None, IDataContext context = null)
{
var tcs = new TaskCompletionSource<MessageResult>();
if (_threadManager.IsUiThread)
ShowMessage(message, caption, button, tcs);
else
_threadManager.InvokeOnUiThreadAsync(() => ShowMessage(message, caption, button, tcs));
return tcs.Task;
}
public Task<MessageResult> ShowAsync(string messageBoxText, string caption = "",
MessageButton button = MessageButton.Ok, MessageImage icon = MessageImage.None,
MessageResult defaultResult = MessageResult.None, IDataContext context = null)
{
if (_threadManager.IsUiThread)
return ToolkitExtensions.FromResult(ShowMessage(messageBoxText, caption, button, icon, defaultResult));
var tcs = new TaskCompletionSource<MessageResult>();
_threadManager.InvokeOnUiThreadAsync(
() => tcs.SetResult(ShowMessage(messageBoxText, caption, button, icon, defaultResult)));
return tcs.Task;
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageDialogViewModel"/> class.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="title">The title.</param>
/// <param name="image">The image.</param>
/// <param name="buttons">The buttons.</param>
public MessageDialogViewModel(string message, string title, MessageImage image, params string[] buttons)
{
Guard.AgainstNullArgument("message", message);
Guard.AgainstNullArgument("title", title);
Guard.AgainstNullArgument("buttons", buttons);
this.Message = message;
this.DisplayName = title;
this.Image = image;
this.Buttons = new BindableCollection <string>(buttons);
}
/// <summary>
/// Shows an information message to the user and allows a callback operation when the message is completed.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <exception cref="ArgumentException">The <paramref name="message"/> is <c>null</c> or whitespace.</exception>
public virtual Task <MessageResult> ShowInformationAsync(string message, string caption = "")
{
if (string.IsNullOrEmpty(caption))
{
caption = Catel.ResourceHelper.GetString("InfoTitle");
}
const MessageButton button = MessageButton.OK;
const MessageImage icon = MessageImage.Information;
return(ShowAsync(message, caption, button, icon));
}
private static MessageBoxResult MuestraMensaje(
Window ventanaPadre,
string mensaje,
MessageBoxButton boton = MessageBoxButton.OK,
MessageImage icono = MessageImage.None,
MessageBoxResult resultadoDefecto = MessageBoxResult.None,
MessageBoxOptions opciones = MessageBoxOptions.None)
{
return(SkMessageBoxWindow.Show(
delegate(Window messageBoxWindow) { messageBoxWindow.Owner = ventanaPadre; },
mensaje, boton, icono, resultadoDefecto, opciones));
}
/// <summary>
/// Shows the message box.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="button">The button.</param>
/// <param name="icon">The icon.</param>
/// <returns>The message result.</returns>
/// <exception cref="ArgumentException">The <paramref name="message"/> is <c>null</c> or whitespace.</exception>
protected virtual Task<MessageResult> ShowMessageBoxAsync(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None)
{
Argument.IsNotNullOrWhitespace("message", message);
return TaskHelper.Run(() =>
{
var messageBoxButton = TranslateMessageButton(button);
var result = MessageBox.Show(message, caption, messageBoxButton);
return TranslateMessageBoxResult(result);
}, true);
}
/// <summary>
/// Shows an error message to the user and allows a callback operation when the message is completed.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <exception cref="ArgumentException">The <paramref name="message"/> is <c>null</c> or whitespace.</exception>
public virtual Task <MessageResult> ShowError(string message, string caption = "")
{
if (string.IsNullOrEmpty(caption))
{
caption = Catel.ResourceHelper.GetString("ErrorTitle");
}
const MessageButton button = MessageButton.OK;
const MessageImage icon = MessageImage.Error;
return(Show(message, caption, button, icon));
}
/// <summary>
/// Shows the message box.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="button">The button.</param>
/// <param name="icon">The icon.</param>
/// <returns>The message result.</returns>
/// <exception cref="ArgumentException">The <paramref name="message"/> is <c>null</c> or whitespace.</exception>
protected virtual Task<MessageResult> ShowMessageBox(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None)
{
Argument.IsNotNullOrWhitespace("message", message);
return Task.Factory.StartNew<MessageResult>(() =>
{
var messageBoxButton = TranslateMessageButton(button);
var result = MessageBox.Show(message, caption, messageBoxButton);
return TranslateMessageBoxResult(result);
});
}
public OpenrecCommentViewModel(IOpenrecCommentData commentData, ICommentOptions options, IOpenrecSiteOptions siteOptions, ICommentProvider commentProvider, bool isFirstComment, IUser user)
: base(options, user, commentProvider, isFirstComment)
{
MessageType = MessageType.Comment;
_options = options;
_siteOptions = siteOptions;
UserId = commentData.UserId;
Id = commentData.Id;
PostDate = commentData.PostTime.ToString("HH:mm:ss");
var elapsed = commentData.Elapsed;
Elapsed = Tools.ElapsedToString(elapsed);
IsStamp = commentData.Stamp != null;
IsYell = commentData.IsYell;
if (!string.IsNullOrEmpty(commentData.UserIconUrl))
{
Thumbnail = new MessageImage {
Url = commentData.UserIconUrl
};
}
if (siteOptions.IsAutoSetNickname)
{
var nick = ExtractNickname(commentData.Message.Text);
if (!string.IsNullOrEmpty(nick))
{
user.Nickname = nick;
}
}
//Name
{
var nameItems = new List <IMessagePart>();
nameItems.Add(MessagePartFactory.CreateMessageText(commentData.Name));
nameItems.AddRange(commentData.NameIcons);
NameItemsInternal = nameItems;
}
//Message
{
var messageItems = new List <IMessagePart>();
if (commentData.IsYell)
{
MessageType = MessageType.BroadcastInfo;
messageItems.Add(MessagePartFactory.CreateMessageText("エールポイント：" + commentData.YellPoints + Environment.NewLine));
}
messageItems.Add(commentData.Message);
if (commentData.Stamp != null)
{
MessageType = MessageType.BroadcastInfo;
messageItems.Add(commentData.Stamp);
}
MessageItems = messageItems;
}
Init();
}
public void MostrarMensaje(string mensaje, MessageBoxButton boton, MessageImage imagen)
{
if (EnviarMensaje != null)
{
var msg = new
{
mensaje,
boton,
imagen
};
EnviarMensaje(msg, EventArgs.Empty);
}
}
private void SetImageSource(MessageImage image)
{
if (image == MessageImage.None)
{
MessageImageSource = null;
}
else
{
var ruta = new Uri(string.Format("/SuKarne.Controls;component/Recursos/Imagenes/{0}.png", image.ToString()), UriKind.Relative);
var imagen = new BitmapImage(ruta);
MessageImageSource = imagen;
}
}
private void RadWindow_Loaded(object sender, RoutedEventArgs e)
{
try
{
if (Diaglog != null)
{
string[] strs = Diaglog.Caption.Split(';');
Diaglog.Caption = string.Empty;
for (int i = 0; i < strs.Length - 1; i++)
{
Diaglog.Caption += strs[i];
}
Header = Diaglog.Caption;
txtMessage.Text = Diaglog.Content;
switch (Diaglog.Button)
{
case MessageBoxButton.OK:
btnCancel.Visibility = Visibility.Collapsed;
break;
}
MessageImage img = (MessageImage)(Convert.ToInt32(strs[strs.Length - 1]));
imgAlert.Visibility = imgInfo.Visibility = imgWarning.Visibility = imgQues.Visibility = Visibility.Collapsed;
switch (img)
{
case MessageImage.Alert:
imgAlert.Visibility = Visibility.Visible;
break;
case MessageImage.Information:
imgInfo.Visibility = Visibility.Visible;
break;
case MessageImage.Warning:
imgWarning.Visibility = Visibility.Visible;
break;
case MessageImage.Question:
imgQues.Visibility = Visibility.Visible;
break;
}
this.KeyUp += new KeyEventHandler(MessageView_KeyUp);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public MessageResult Show(string message, string caption, MessageButton button, MessageImage icon)
{
var vm = new DialogViewModel
{
Title = caption,
Message = message,
Buttons = button,
Icon = icon
};
_windowManager.ShowDialog(vm);
return vm.Result;
}
public async static Task Run([QueueTrigger("queue-image-insert")]
MessageImage message,
IBinder binder,
ILogger log)
{
log.LogInformation($"Função ativada!");
using var webClient = new WebClient();
byte[] imageBytes = webClient.DownloadData(message.ImageUri.ToString());
var blobAtributte = new BlobAttribute($"imagens/{Guid.NewGuid()}.jpg", FileAccess.Write);
var cloudBlobStream = await binder.BindAsync <ICloudBlob>(blobAtributte);
await cloudBlobStream.UploadFromByteArrayAsync(imageBytes, 0, imageBytes.Length);
await cloudBlobStream.Container.SetPermissionsAsync(new BlobContainerPermissions()
{
PublicAccess = BlobContainerPublicAccessType.Blob
});
using (var output = new MemoryStream())
using (Image <Rgba32> image = SixLabors.ImageSharp.Image.Load(imageBytes))
{
var width = image.Width / 200;
var height = Convert.ToInt32(Math.Round((decimal)(image.Height / width)));
image.Mutate(x => x.Resize(200, height));
image.Save(output, new JpegEncoder());
output.Position = 0;
await cloudBlobStream.UploadFromStreamAsync(output);
}
var connectionString = Environment.GetEnvironmentVariable("SqlConnectionString");
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
var textSql = $@"UPDATE [dbo].[BibliotecaMusical] SET [ImageUri] = '{cloudBlobStream.Uri}' WHERE Id = {message.Id}";
using (SqlCommand cmd = new SqlCommand(textSql, conn))
{
var rowsAffected = cmd.ExecuteNonQuery();
log.LogInformation($"rowsAffected: {rowsAffected}");
}
}
log.LogInformation($"Função encerrada!");
}
/// <summary>
/// Show a message box dialog
/// </summary>
public static int ShwDlg(Screen screen, IntPtr ownerHandle, MessageImage type, string heading, string text, List <string> buttonsList, bool waitResponse, EventHandler <HtmlLinkClickedEventArgs> onLinkClicked = null)
{
text = @"
<table style='margin-bottom: 7px;>
<tr>
<td rowspan='2'><img style='padding-right: 10px;' src='" + type + @"' width='64' height='64' /></td>
<td class='NotificationTitle'>" + heading + @"</td>
</tr>
<tr>
<td class='NotificationSubTitle'></td>
</tr>
</table><br>" + text;
return(ShwDlg(screen, ownerHandle, text, heading, buttonsList, waitResponse, onLinkClicked));
}
/// <summary>
/// Shows the specified message and allows to await for the message to complete.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="button">The button.</param>
/// <param name="icon">The icon.</param>
/// <returns>A Task containing the <see cref="MessageResult"/>.</returns>
public Task<MessageResult> ShowAsync(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None) {
#if WinRT
return ShowMessageBox(message, caption, button, icon);
#else
var taskSource = new TaskCompletionSource<MessageResult>();
try {
var result = ShowMessageBox(message, caption, button, icon);
taskSource.SetResult(result);
}
catch (Exception ex) {
taskSource.SetException(ex);
}
return taskSource.Task;
#endif
}
public Task <MessageResult> ShowAsyncWithDontShowAgain(string message, string dontShowAgainId,
string caption = "", string helpLink = null,
MessageImage icon = MessageImage.None, string dontText = "")
{
Argument.IsNotNullOrWhitespace("message", message);
var tcs = new TaskCompletionSource <MessageResult>();
if (_globalService.DontShowAgainDialogs.Contains(dontShowAgainId))
{
tcs.TrySetResult(MessageResult.OK);
return(tcs.Task);
}
#pragma warning disable AvoidAsyncVoid
_dispatcherService.BeginInvoke(async() =>
#pragma warning restore AvoidAsyncVoid
{
var previousCursor = Mouse.OverrideCursor;
Mouse.OverrideCursor = null;
var vm = _viewModelFactory.CreateViewModel <HelpLinkMessageBoxViewModel>(null, null);
vm.Message = message;
vm.Button = MessageButton.OK;
vm.Icon = icon;
vm.HelpLink = helpLink;
vm.DontMode = DontMode.DONT_SHOW_AGAIN;
vm.DontId = dontShowAgainId;
if (string.IsNullOrWhiteSpace(dontText))
{
dontText = "Don't show again";
}
vm.DontText = dontText;
vm.SetTitle(caption);
await _uiVisualizerService.ShowDialogAsync(vm);
Mouse.OverrideCursor = previousCursor;
tcs.TrySetResult(vm.Result);
});
return(tcs.Task);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="message"></param>
/// <param name="title"></param>
/// <param name="detail"></param>
/// <param name="msgImage"></param>
public ErrorReport(string message, string title, MessageImage msgImage, string detail)
{
InitializeComponent();
this.Size = new System.Drawing.Size(this.Size.Width, panTop.Height + 30);
mMessage = message;
mTitle = title;
mDetail = detail;
txtErrorMsg.Text = mMessage;
txtDetails.Text = mDetail;
this.Text = mTitle;
ErrorImage = msgImage;
btnViewDetails.Visible = !string.IsNullOrEmpty(detail);
this.MaximizeBox = !string.IsNullOrEmpty(detail);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="message"></param>
/// <param name="title"></param>
/// <param name="detail"></param>
/// <param name="msgImage"></param>
public ErrorReport(string message, string title, MessageImage msgImage, string detail)
{
InitializeComponent();
this.Size = new System.Drawing.Size(this.Size.Width, panTop.Height + 30);
mMessage = message;
mTitle = title;
mDetail = detail;
txtErrorMsg.Text = mMessage;
txtDetails.Text = mDetail;
this.Text = mTitle;
ErrorImage = msgImage;
btnViewDetails.Visible = !string.IsNullOrEmpty(detail);
this.MaximizeBox = !string.IsNullOrEmpty(detail);
}
public SkMessageBoxViewModel(
SkMessageBoxWindow view,
string message,
MessageBoxButton buttonOption,
MessageImage image,
MessageBoxResult defaultResult,
MessageBoxOptions options)
{
Message = message;
ButtonOption = buttonOption;
Options = options;
SetDirections(options);
SetButtonVisibility(buttonOption);
SetImageSource(image);
SetButtonDefault(defaultResult);
_view = view;
}
/// <summary>
/// Shows the message box.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="button">The button.</param>
/// <param name="icon">The icon.</param>
/// <returns>The message result.</returns>
/// <exception cref="ArgumentException">The <paramref name="message"/> is <c>null</c> or whitespace.</exception>
protected virtual Task<MessageResult> ShowMessageBox(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None)
{
Argument.IsNotNullOrWhitespace("message", message);
var tcs = new TaskCompletionSource<MessageResult>();
_dispatcherService.BeginInvoke(() =>
{
MessageBoxResult result;
var messageBoxButton = TranslateMessageButton(button);
result = MessageBox.Show(message, caption, messageBoxButton);
tcs.SetResult(TranslateMessageBoxResult(result));
});
return tcs.Task;
}
/// <summary>
/// Shows an error message to the user and allows a callback operation when the message is completed.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="completedCallback">The callback to invoke when the message is completed. Can be <c>null</c>.</param>
/// <remarks>
/// There is no garantuee that the method will be executed asynchronous, only that the <paramref name="completedCallback"/>
/// will be invoked when the message is dismissed.
/// </remarks>
/// <exception cref="ArgumentException">The <paramref name="message"/> is <c>null</c> or whitespace.</exception>
public virtual void ShowError(string message, string caption = "", Action completedCallback = null)
{
if (string.IsNullOrEmpty(caption))
{
caption = Catel.ResourceHelper.GetString(typeof(MessageService), "Resources", "ErrorTitle");
}
const MessageButton button = MessageButton.OK;
const MessageImage icon = MessageImage.Error;
if (completedCallback != null)
{
ShowAsync(message, caption, button, icon, result => completedCallback());
}
else
{
Show(message, caption, button, icon);
}
}
/// <summary>
/// Shows an information message to the user and allows a callback operation when the message is completed.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="completedCallback">The callback to invoke when the message is completed. Can be <c>null</c>.</param>
/// <remarks>
/// There is no garantuee that the method will be executed asynchronous, only that the <paramref name="completedCallback"/>
/// will be invoked when the message is dismissed.
/// </remarks>
/// <exception cref="ArgumentException">The <paramref name="message"/> is <c>null</c> or whitespace.</exception>
public virtual void ShowInformation(string message, string caption = "", Action completedCallback = null)
{
if (string.IsNullOrEmpty(caption))
{
caption = Catel.ResourceHelper.GetString("InfoTitle");
}
const MessageButton button = MessageButton.OK;
const MessageImage icon = MessageImage.Information;
if (completedCallback != null)
{
ShowAsync(message, caption, button, icon, result => completedCallback());
}
else
{
Show(message, caption, button, icon);
}
}
public async static Task Run([QueueTrigger("queue-image-insert")]
MessageImage message,
IBinder binder,
ILogger log)
{
log.LogInformation($"Função ativada!");
using var webClient = new WebClient();
byte[] imageBytes = webClient.DownloadData(message.ImageUri.ToString());
var image = (Image)(new Bitmap(Image.FromStream(new MemoryStream(imageBytes)), new Size(150, 150)));
var converter = new ImageConverter();
var img = (byte[])converter.ConvertTo(image, typeof(byte[]));
var blobAttribute = new BlobAttribute($"imagens/{Guid.NewGuid()}.jpg", FileAccess.Write);
var cloudBlobStream = await binder.BindAsync <ICloudBlob>(blobAttribute);
await cloudBlobStream.UploadFromByteArrayAsync(img, 0, img.Length);
await cloudBlobStream.Container.SetPermissionsAsync(new BlobContainerPermissions()
{
PublicAccess = BlobContainerPublicAccessType.Blob
});
var connectionString = Environment.GetEnvironmentVariable("PostContext");
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
var textSql = $@"UPDATE [dbo].[Posts] SET [UrlFoto] = '{cloudBlobStream.Uri}' WHERE Id = {message.Id}";
using (SqlCommand cmd = new SqlCommand(textSql, conn))
{
var rowsAffected = cmd.ExecuteNonQuery();
log.LogInformation($"rowsAffected: {rowsAffected}");
}
}
log.LogInformation($"Função encerrada!");
}
private void Initialize(MessageImage image, string text)
{
var uriImage = GetImageUri(image);
if (string.IsNullOrWhiteSpace(uriImage))
{
imgMessage.Visibility = Visibility.Collapsed;
}
else
{
imgMessage.Source = new BitmapImage(new Uri(uriImage, UriKind.Relative));
if (GetTextWidth(text) > (MinWidth - 60))
{
MessageBlock.Padding = new Thickness(25, 0, 0, 0);
}
}
MessageBlock.Text = text;
}
private string GetImageUri(MessageImage image)
{
switch (image)
{
case MessageImage.Error:
return("Images\\Error.png");
case MessageImage.Warning:
return("Images\\Warning.png");
case MessageImage.Question:
return("Images\\Question.png");
case MessageImage.Information:
return("Images\\Information.png");
default:
return(null);
}
}
private MessageBoxImage GetMessageBoxImage(MessageImage image)
{
switch (image)
{
case MessageImage.Information:
return(MessageBoxImage.Information);
case MessageImage.Error:
return(MessageBoxImage.Error);
case MessageImage.Question:
return(MessageBoxImage.Question);
case MessageImage.Warning:
return(MessageBoxImage.Warning);
default:
throw new NotSupportedException($"The {image} is not supported in method '{nameof(GetMessageBoxImage)}'!");
}
}
/// <summary>
/// Shows the message box.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="button">The button.</param>
/// <param name="icon">The icon.</param>
/// <returns>The message result.</returns>
/// <exception cref="ArgumentException">The <paramref name="message" /> is <c>null</c> or whitespace.</exception>
protected virtual async Task<MessageResult> ShowMessageBoxAsync(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None)
{
if (!_configurationResultMap.ContainsKey(button))
{
throw new ArgumentOutOfRangeException("button");
}
var messageResult = MessageResult.None;
var currentPage = Application.Current.CurrentPage();
if (currentPage != null)
{
var configuration = _configurationResultMap[button];
var result = Xamarin.Forms.MessagingCenter.SendAlert(currentPage, caption, message, configuration.PositiveButton, configuration.NegativeButton);
await result.Task;
messageResult = result.Task.Result ? configuration.PositiveResult: configuration.NegativeResult;
}
return messageResult;
}
public NicoCommentViewModel(NicoSitePlugin.INicoComment comment, IMessageMetadata metadata, IMessageMethods methods, IConnectionStatus connectionStatus, IOptions options)
: this(comment as NicoSitePlugin.INicoMessage, metadata, methods, connectionStatus, options)
{
if (!string.IsNullOrEmpty(comment.UserName))
{
_nameItems = MessagePartFactory.CreateMessageItems(comment.UserName);
}
MessageItems = MessagePartFactory.CreateMessageItems(comment.Text);
if (IsValudThumbnailUrl(comment.ThumbnailUrl))
{
Thumbnail = new MessageImage
{
Url = comment.ThumbnailUrl,
Height = 40,
Width = 40,
};
}
Id = comment.Id;
PostTime = comment.PostedAt.ToLocalTime().ToString("HH:mm:ss");
}
public static MessageImage uploadImage(string type, Stream imgstream)
{
try
{
Task <JObject> json = WebHelper.postImageAsync($"http://{HOST}:{PORT}/uploadImage", SESSION, type, imgstream);
json.Wait();
string imageId = json.Result["imageId"].ToString();
string url = json.Result["url"].ToString();
string path = json.Result["path"].ToString();
MessageImage img = new MessageImage();
img.id = imageId;
img.path = path;
img.url = url;
return(img);
}
catch (Exception ex)
{
FileHelper.Log(ex);
return(null);
}
}
public Task<MessageResult> ShowAsync(string messageBoxText, string caption = "",
MessageButton button = MessageButton.Ok, MessageImage icon = MessageImage.None,
MessageResult defaultResult = MessageResult.None, IDataContext context = null)
{
bool success;
MessageBoxButton buttons = ConvertMessageBoxButtons(button, out success);
Should.BeSupported(success, "The MessageBoxAdapter doesn't support {0} value", button);
if (_threadManager.IsUiThread)
{
MessageBoxResult result = MessageBox.Show(messageBoxText, caption, buttons);
return ToolkitExtensions.FromResult(ConvertMessageBoxResult(result, button));
}
var tcs = new TaskCompletionSource<MessageResult>();
_threadManager.InvokeOnUiThreadAsync(() =>
{
MessageBoxResult result = MessageBox.Show(messageBoxText, caption, buttons);
tcs.SetResult(ConvertMessageBoxResult(result, button));
});
return tcs.Task;
}
/// <summary>
/// Shows the message box.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="button">The button.</param>
/// <param name="icon">The icon.</param>
/// <returns>The message result.</returns>
/// <exception cref="ArgumentException">The <paramref name="message"/> is <c>null</c> or whitespace.</exception>
protected virtual Task<MessageResult> ShowMessageBox(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None)
{
var messageResult = MessageResult.Cancel;
var context = Catel.Android.ContextHelper.CurrentContext;
var builder = new AlertDialog.Builder(context);
switch (button)
{
case MessageButton.OK:
builder.SetPositiveButton("OK", (sender, e) => { messageResult = MessageResult.OK; });
break;
case MessageButton.OKCancel:
builder.SetPositiveButton("OK", (sender, e) => { messageResult = MessageResult.OK; });
builder.SetCancelable(true);
break;
case MessageButton.YesNo:
builder.SetPositiveButton("Yes", (sender, e) => { messageResult = MessageResult.Yes; });
builder.SetNegativeButton("No", (sender, e) => { messageResult = MessageResult.No; });
break;
case MessageButton.YesNoCancel:
builder.SetPositiveButton("Yes", (sender, e) => { messageResult = MessageResult.Yes; });
builder.SetNegativeButton("No", (sender, e) => { messageResult = MessageResult.No; });
builder.SetCancelable(true);
break;
default:
throw new ArgumentOutOfRangeException("button");
}
return Task<MessageResult>.Run(() =>
{
builder.SetMessage(message).SetTitle(caption);
builder.Show();
return messageResult;
});
}
/// <summary>
/// Translates the message image.
/// </summary>
/// <param name="image">The image.</param>
/// <returns>
/// Corresponding <see cref="MessageBoxImage"/>.
/// </returns>
protected static MessageBoxImage TranslateMessageImage(MessageImage image)
{
return Enum<MessageBoxImage>.ConvertFromOtherEnumValue(image);
}
protected override Task <MessageResult> ShowMessageBoxAsync(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None)
{
var style = MessageDialogStyle.Affirmative;
var affirmativeResult = MessageResult.OK;
var negativeResult = MessageResult.No;
var auxiliaryResult = MessageResult.Cancel;
switch (button)
{
case MessageButton.OK:
style = MessageDialogStyle.Affirmative;
affirmativeResult = MessageResult.OK;
break;
case MessageButton.OKCancel:
style = MessageDialogStyle.AffirmativeAndNegative;
affirmativeResult = MessageResult.OK;
negativeResult = MessageResult.Cancel;
break;
case MessageButton.YesNo:
style = MessageDialogStyle.AffirmativeAndNegative;
affirmativeResult = MessageResult.Yes;
negativeResult = MessageResult.No;
break;
case MessageButton.YesNoCancel:
style = MessageDialogStyle.AffirmativeAndNegativeAndSingleAuxiliary;
affirmativeResult = MessageResult.Yes;
negativeResult = MessageResult.No;
auxiliaryResult = MessageResult.Cancel;
break;
default:
throw new ArgumentOutOfRangeException("button");
}
var tcs = new TaskCompletionSource <MessageResult>();
_dispatcherService.BeginInvoke(async() =>
{
var window = Application.Current.MainWindow as MetroWindow;
if (window == null)
{
tcs.TrySetResult(MessageResult.Cancel);
return;
}
var result = await window.ShowMessageAsync(caption, message, style);
switch (result)
{
case MessageDialogResult.Negative:
tcs.TrySetResult(negativeResult);
break;
case MessageDialogResult.Affirmative:
tcs.TrySetResult(affirmativeResult);
break;
case MessageDialogResult.FirstAuxiliary:
tcs.TrySetResult(auxiliaryResult);
break;
default:
throw new ArgumentOutOfRangeException();
}
});
return(tcs.Task);
}
protected virtual int? GetIconResource(MessageImage icon)
{
return null;
}
private void ShowMessage(string messageBoxText, string caption, MessageButton button, MessageImage icon,
MessageResult defaultResult,
TaskCompletionSource<MessageResult> tcs)
{
#if XAMARIN_FORMS
var activity = global::Xamarin.Forms.Forms.Context;
#else
var activity = PlatformExtensions.CurrentActivity as IActivityView;
#endif
Should.BeSupported(activity != null, "The current top activity is null.");
AlertDialog.Builder builder = new AlertDialog.Builder((Context)activity)
.SetTitle(caption)
.SetMessage(messageBoxText)
.SetCancelable(false);
switch (button)
{
case MessageButton.Ok:
builder.SetPositiveButton(GetButtonText(MessageResult.Ok),
(sender, args) => tcs.TrySetResult(MessageResult.Ok));
break;
case MessageButton.OkCancel:
builder.SetPositiveButton(GetButtonText(MessageResult.Ok),
(sender, args) => tcs.TrySetResult(MessageResult.Ok));
builder.SetNegativeButton(GetButtonText(MessageResult.Cancel),
(sender, args) => tcs.TrySetResult(MessageResult.Cancel));
break;
case MessageButton.YesNo:
builder.SetPositiveButton(GetButtonText(MessageResult.Yes),
(sender, args) => tcs.TrySetResult(MessageResult.Yes));
builder.SetNegativeButton(GetButtonText(MessageResult.No),
(sender, args) => tcs.TrySetResult(MessageResult.No));
break;
case MessageButton.YesNoCancel:
builder.SetPositiveButton(GetButtonText(MessageResult.Yes),
(sender, args) => tcs.TrySetResult(MessageResult.Yes));
if (Build.VERSION.SdkInt >= BuildVersionCodes.Lollipop)
{
builder.SetNegativeButton(GetButtonText(MessageResult.No),
(sender, args) => tcs.TrySetResult(MessageResult.No));
builder.SetNeutralButton(GetButtonText(MessageResult.Cancel),
(sender, args) => tcs.TrySetResult(MessageResult.Cancel));
}
else
{
builder.SetNeutralButton(GetButtonText(MessageResult.No),
(sender, args) => tcs.TrySetResult(MessageResult.No));
builder.SetNegativeButton(GetButtonText(MessageResult.Cancel),
(sender, args) => tcs.TrySetResult(MessageResult.Cancel));
}
break;
case MessageButton.AbortRetryIgnore:
builder.SetPositiveButton(GetButtonText(MessageResult.Abort),
(sender, args) => tcs.TrySetResult(MessageResult.Abort));
builder.SetNeutralButton(GetButtonText(MessageResult.Retry),
(sender, args) => tcs.TrySetResult(MessageResult.Retry));
builder.SetNegativeButton(GetButtonText(MessageResult.Ignore),
(sender, args) => tcs.TrySetResult(MessageResult.Ignore));
break;
case MessageButton.RetryCancel:
builder.SetPositiveButton(GetButtonText(MessageResult.Retry),
(sender, args) => tcs.TrySetResult(MessageResult.Retry));
builder.SetNegativeButton(GetButtonText(MessageResult.Cancel),
(sender, args) => tcs.TrySetResult(MessageResult.Cancel));
break;
default:
throw new ArgumentOutOfRangeException("button");
}
int? drawable = GetIconResource(icon);
if (drawable != null)
builder.SetIcon(drawable.Value);
AlertDialog dialog = builder.Create();
#if !XAMARIN_FORMS
EventHandler<Activity, EventArgs> handler = null;
handler = (sender, args) =>
{
((IActivityView)sender).Mediator.Destroyed -= handler;
tcs.TrySetResult(defaultResult);
};
activity.Mediator.Destroyed += handler;
#endif
dialog.Show();
}
/// <summary>
/// Shows the specified message and returns the result.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="button">The button.</param>
/// <param name="icon">The icon.</param>
/// <returns>The <see cref="MessageResult"/>.</returns>
/// <exception cref="ArgumentException">The <paramref name="message"/> is <c>null</c> or whitespace.</exception>
public virtual MessageResult Show(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None)
{
#if NETFX_CORE
var task = ShowMessageBox(message, caption, button, icon);
task.Wait();
return task.Result;
#else
return ShowMessageBox(message, caption, button, icon);
#endif
}
/// <summary>
/// Shows an information message to the user and allows a callback operation when the message is completed.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="button">The button.</param>
/// <param name="icon">The icon.</param>
/// <param name="completedCallback">The callback to invoke when the message is completed. Can be <c>null</c>.</param>
/// <remarks>
/// There is no garantuee that the method will be executed asynchronous, only that the <paramref name="completedCallback"/>
/// will be invoked when the message is dismissed.
/// </remarks>
/// <exception cref="ArgumentException">The <paramref name="message"/> is <c>null</c> or whitespace.</exception>
public virtual void ShowAsync(string message, string caption = "", MessageButton button = MessageButton.OK,
MessageImage icon = MessageImage.None, Action<MessageResult> completedCallback = null)
{
var result = Show(message, caption, button, icon);
if (completedCallback != null)
{
completedCallback(result);
}
}
private static MessageBoxIcon ConvertImage(MessageImage images)
{
switch (images)
{
case MessageImage.Asterisk:
return MessageBoxIcon.Asterisk;
case MessageImage.Error:
return MessageBoxIcon.Error;
case MessageImage.Exclamation:
return MessageBoxIcon.Exclamation;
case MessageImage.Hand:
return MessageBoxIcon.Hand;
case MessageImage.Information:
return MessageBoxIcon.Information;
case MessageImage.None:
return MessageBoxIcon.None;
case MessageImage.Question:
return MessageBoxIcon.Question;
case MessageImage.Stop:
return MessageBoxIcon.Stop;
case MessageImage.Warning:
return MessageBoxIcon.Warning;
default:
return MessageBoxIcon.None;
}
}
/// <summary>
/// Shows the message box.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="button">The button.</param>
/// <param name="icon">The icon.</param>
/// <returns>The message result.</returns>
/// <exception cref="ArgumentException">The <paramref name="message"/> is <c>null</c> or whitespace.</exception>
#if NETFX_CORE
protected async virtual Task<MessageResult> ShowMessageBox(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None)
/// <summary>
/// Show a message box dialog
/// </summary>
public static int ShwDlg(Screen screen, IntPtr ownerHandle, MessageImage type, string heading, string text, List<string> buttonsList, bool waitResponse, EventHandler<HtmlLinkClickedEventArgs> onLinkClicked = null)
{
text = @"
<table style='margin-bottom: 7px;>
<tr>
<td rowspan='2'><img style='padding-right: 10px;' src='" + type + @"' width='64' height='64' /></td>
<td class='NotificationTitle'>" + heading + @"</td>
</tr>
<tr>
<td class='NotificationSubTitle'></td>
</tr>
</table><br>" + text;
return ShwDlg(screen, ownerHandle, text, heading, buttonsList, waitResponse, onLinkClicked);
}
protected virtual MessageResult ShowMessageBox(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None)
#endif
{
Argument.IsNotNullOrWhitespace("message", message);
var result = MessageBoxResult.None;
var messageBoxButton = TranslateMessageButton(button);
#if NET
var messageBoxImage = TranslateMessageImage(icon);
var activeWindow = Application.Current.GetActiveWindow();
if (activeWindow != null)
{
result = MessageBox.Show(activeWindow, message, caption, messageBoxButton, messageBoxImage);
}
else
{
result = MessageBox.Show(message, caption, messageBoxButton, messageBoxImage);
}
#elif NETFX_CORE
// TODO: Add translations for system
var messageDialog = new MessageDialog(message, caption);
if (Enum<MessageButton>.Flags.IsFlagSet(button, MessageButton.OK) ||
Enum<MessageButton>.Flags.IsFlagSet(button, MessageButton.OKCancel))
{
messageDialog.Commands.Add(new UICommand("OK", cmd => result = MessageBoxResult.OK));
}
if (Enum<MessageButton>.Flags.IsFlagSet(button, MessageButton.YesNo) ||
Enum<MessageButton>.Flags.IsFlagSet(button, MessageButton.YesNoCancel))
{
messageDialog.Commands.Add(new UICommand("Yes", cmd => result = MessageBoxResult.Yes));
messageDialog.Commands.Add(new UICommand("No", cmd => result = MessageBoxResult.No));
}
if (Enum<MessageButton>.Flags.IsFlagSet(button, MessageButton.OKCancel) ||
Enum<MessageButton>.Flags.IsFlagSet(button, MessageButton.YesNoCancel))
{
messageDialog.Commands.Add(new UICommand("Cancel", cmd => result = MessageBoxResult.Cancel));
messageDialog.CancelCommandIndex = (uint)messageDialog.Commands.Count - 1;
}
await messageDialog.ShowAsync();
#else
result = MessageBox.Show(message, caption, messageBoxButton);
#endif
return TranslateMessageBoxResult(result);
}
/// <summary>
/// Shows an information message to the user and allows a callback operation when the message is completed.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="button">The button.</param>
/// <param name="icon">The icon.</param>
/// <exception cref="ArgumentException">The <paramref name="message"/> is <c>null</c> or whitespace.</exception>
public virtual Task<MessageResult> ShowAsync(string message, string caption = "", MessageButton button = MessageButton.OK,
MessageImage icon = MessageImage.None)
{
return ShowMessageBoxAsync(message, caption, button, icon);
}
/// <summary>
/// Shows the message box.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="caption">The caption.</param>
/// <param name="button">The button.</param>
/// <param name="icon">The icon.</param>
/// <returns>The message result.</returns>
/// <exception cref="ArgumentException">The <paramref name="message"/> is <c>null</c> or whitespace.</exception>
protected virtual Task<MessageResult> ShowMessageBox(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None)
{
throw new MustBeImplementedException();
}
