private async void Popup_CommandHandler_Paste(FlyoutCommand command)
 {
     try
     {
         _editor.Paste(_lastPointerPosition.X, _lastPointerPosition.Y);
     }
     catch (Exception ex)
     {
         var msgDialog = new MessageDialog(ex.ToString());
         await msgDialog.ShowAsync();
     }
 }
 private async void Popup_CommandHandler_Remove(FlyoutCommand command)
 {
     try
     {
         if (_lastSelectedBlock != null && _lastSelectedBlock.Type != "Container")
         {
             _editor.RemoveBlock(_lastSelectedBlock);
         }
     }
     catch (Exception ex)
     {
         var msgDialog = new MessageDialog(ex.ToString());
         await msgDialog.ShowAsync();
     }
 }
 private async void Popup_CommandHandler_Copy(FlyoutCommand command)
 {
     try
     {
         if (_lastSelectedBlock != null)
         {
             _editor.Copy(_lastSelectedBlock);
         }
     }
     catch (Exception ex)
     {
         var msgDialog = new MessageDialog(ex.ToString());
         await msgDialog.ShowAsync();
     }
 }
        private async void Popup_CommandHandler_Import(FlyoutCommand command)
        {
            var part = _editor.Part;

            if (part == null)
            {
                return;
            }

            if (_lastSelectedBlock == null)
            {
                return;
            }

            var mimeTypes = _editor.GetSupportedImportMimeTypes(_lastSelectedBlock);

            if (mimeTypes == null)
            {
                return;
            }

            if (mimeTypes.Count() == 0)
            {
                return;
            }

            var result = await EnterImportData("Import", mimeTypes);

            if (result != null)
            {
                var idx  = result.Item1;
                var data = result.Item2;

                if ((idx >= 0) && (idx < mimeTypes.Count()) && (String.IsNullOrWhiteSpace(data) == false))
                {
                    try
                    {
                        _editor.Import_(mimeTypes[idx], data, _lastSelectedBlock);
                    }
                    catch (Exception ex)
                    {
                        var msgDialog = new MessageDialog(ex.ToString());
                        await msgDialog.ShowAsync();
                    }
                }
            }
        }
        private async void Popup_CommandHandler_Convert(FlyoutCommand command)
        {
            try
            {
                if (_lastSelectedBlock != null)
                {
                    var supportedStates = _editor.GetSupportedTargetConversionStates(_lastSelectedBlock);

                    if ((supportedStates != null) && (supportedStates.Count() > 0))
                    {
                        _editor.Convert(_lastSelectedBlock, supportedStates[0]);
                    }
                }
            }
            catch (Exception ex)
            {
                var msgDialog = new MessageDialog(ex.ToString());
                await msgDialog.ShowAsync();
            }
        }
        private async void Popup_CommandHandler_OfficeClipboard(FlyoutCommand command)
        {
            try
            {
                MimeType[] mimeTypes = null;

                if (_lastSelectedBlock != null)
                {
                    mimeTypes = _editor.GetSupportedExportMimeTypes(_lastSelectedBlock);
                }

                if (mimeTypes != null && mimeTypes.Contains(MimeType.OFFICE_CLIPBOARD))
                {
                    // export block to a file
                    var localFolder   = ApplicationData.Current.LocalFolder.Path;
                    var clipboardPath = System.IO.Path.Combine(localFolder.ToString(), "tmp/clipboard.gvml");
                    var drawer        = new ImageDrawer(_editor.Renderer.DpiX, _editor.Renderer.DpiY);

                    drawer.ImageLoader = UcEditor.ImageLoader;

                    _editor.Export_(_lastSelectedBlock, clipboardPath.ToString(), MimeType.OFFICE_CLIPBOARD, drawer);

                    // read back exported data
                    var clipboardData   = File.ReadAllBytes(clipboardPath);
                    var clipboardStream = new MemoryStream(clipboardData);

                    // store the data into clipboard
                    Windows.ApplicationModel.DataTransfer.Clipboard.Clear();
                    var clipboardContent = new Windows.ApplicationModel.DataTransfer.DataPackage();
                    clipboardContent.SetData(MimeTypeF.GetTypeName(MimeType.OFFICE_CLIPBOARD), clipboardStream.AsRandomAccessStream());
                    Windows.ApplicationModel.DataTransfer.Clipboard.SetContent(clipboardContent);
                }
            }
            catch (Exception ex)
            {
                MessageDialog msgDialog = new MessageDialog(ex.ToString());
                await msgDialog.ShowAsync();
            }
        }
        private async void Popup_CommandHandler_AddBlock(FlyoutCommand command)
        {
            try
            {
                // Uses Id as block type
                var blockType = command.Id.ToString();
                var mimeTypes = _editor.GetSupportedAddBlockDataMimeTypes(blockType);
                var useDialog = (mimeTypes != null) && (mimeTypes.Count() > 0);

                if (!useDialog)
                {
                    _editor.AddBlock(_lastPointerPosition.X, _lastPointerPosition.Y, blockType);
                    UcEditor.Invalidate(LayerType.LayerType_ALL);
                }
                else
                {
                    var result = await EnterImportData("Add Content Block", mimeTypes);

                    if (result != null)
                    {
                        var idx  = result.Item1;
                        var data = result.Item2;

                        if ((idx >= 0) && (idx < mimeTypes.Count()) && (String.IsNullOrWhiteSpace(data) == false))
                        {
                            _editor.AddBlock(_lastPointerPosition.X, _lastPointerPosition.Y, blockType, mimeTypes[idx], data);
                            UcEditor.Invalidate(LayerType.LayerType_ALL);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                var msgDialog = new MessageDialog(ex.ToString());
                await msgDialog.ShowAsync();
            }
        }
        private async void Popup_CommandHandler_Export(FlyoutCommand command)
        {
            var part = _editor.Part;

            if (part == null)
            {
                return;
            }

            if (_lastSelectedBlock == null)
            {
                return;
            }

            var mimeTypes = _editor.GetSupportedExportMimeTypes(_lastSelectedBlock);

            if (mimeTypes == null)
            {
                return;
            }

            if (mimeTypes.Count() == 0)
            {
                return;
            }

            // Show export dialog
            var fileName = await ChooseExportFilename(mimeTypes);

            if (!string.IsNullOrEmpty(fileName))
            {
                var localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
                var item        = await localFolder.TryGetItemAsync(fileName);

                string filePath = null;

                if (item != null)
                {
                    ContentDialog overwriteDialog = new ContentDialog
                    {
                        Title               = "File Already Exists",
                        Content             = "A file with that name already exists, overwrite it?",
                        PrimaryButtonText   = "Cancel",
                        SecondaryButtonText = "Overwrite"
                    };

                    ContentDialogResult result = await overwriteDialog.ShowAsync();

                    if (result == ContentDialogResult.Primary)
                    {
                        return;
                    }

                    filePath = item.Path.ToString();
                }
                else
                {
                    filePath = System.IO.Path.Combine(localFolder.Path.ToString(), fileName);
                }

                try
                {
                    var drawer = new ImageDrawer(_editor.Renderer.DpiX, _editor.Renderer.DpiY);

                    drawer.ImageLoader = UcEditor.ImageLoader;

                    _editor.WaitForIdle();
                    _editor.Export_(_lastSelectedBlock, filePath, drawer);

                    var file = await StorageFile.GetFileFromPathAsync(filePath);

                    await Windows.System.Launcher.LaunchFileAsync(file);
                }
                catch (Exception ex)
                {
                    var msgDialog = new MessageDialog(ex.ToString());
                    await msgDialog.ShowAsync();
                }
            }
        }
 private void Popup_CommandHandler_AddImage(FlyoutCommand command)
 {
     // TODO
 }
        private void DisplayContextualMenu(Windows.Foundation.Point globalPos)
        {
            var contentBlock = _lastSelectedBlock;

            var supportedTypes       = _editor.SupportedAddBlockTypes;
            var supportedExports     = _editor.GetSupportedExportMimeTypes(contentBlock);
            var supportedImportTypes = _editor.GetSupportedImportMimeTypes(contentBlock);

            var isContainer = contentBlock.Type == "Container";
            var isRoot      = contentBlock.Id == _editor.GetRootBlock().Id;

            var displayConvert         = !isContainer && !_editor.IsEmpty(contentBlock);
            var displayAddBlock        = supportedTypes != null && supportedTypes.Any() && isContainer;
            var displayAddImage        = false; // supportedTypes != null && supportedTypes.Any() && isContainer;
            var displayRemove          = !isRoot && !isContainer;
            var displayCopy            = !isRoot && !isContainer;
            var displayPaste           = supportedTypes != null && supportedTypes.Any() && isContainer;
            var displayImport          = supportedImportTypes != null && supportedImportTypes.Any();
            var displayExport          = supportedExports != null && supportedExports.Any();
            var displayOfficeClipboard = (supportedExports != null) && supportedExports.Contains(MimeType.OFFICE_CLIPBOARD);

            var flyoutMenu = new MenuFlyout();

            if (displayConvert)
            {
                var command    = new FlyoutCommand("Convert", (cmd) => { Popup_CommandHandler_Convert(cmd); });
                var flyoutItem = new MenuFlyoutItem {
                    Text = "Convert", Command = command
                };
                flyoutMenu.Items.Add(flyoutItem);
            }

            if (displayRemove)
            {
                var command    = new FlyoutCommand("Remove", (cmd) => { Popup_CommandHandler_Remove(cmd); });
                var flyoutItem = new MenuFlyoutItem {
                    Text = "Remove", Command = command
                };
                flyoutMenu.Items.Add(flyoutItem);
            }

            if (displayCopy)
            {
                var command    = new FlyoutCommand("Copy", (cmd) => { Popup_CommandHandler_Copy(cmd); });
                var flyoutItem = new MenuFlyoutItem {
                    Text = "Copy", Command = command
                };
                flyoutMenu.Items.Add(flyoutItem);
            }

            if (displayPaste)
            {
                var command    = new FlyoutCommand("Paste", (cmd) => { Popup_CommandHandler_Paste(cmd); });
                var flyoutItem = new MenuFlyoutItem {
                    Text = "Paste", Command = command
                };
                flyoutMenu.Items.Add(flyoutItem);
            }

            if (displayOfficeClipboard)
            {
                var command    = new FlyoutCommand("Copy To Clipboard (Microsoft Office)", (cmd) => { Popup_CommandHandler_OfficeClipboard(cmd); });
                var flyoutItem = new MenuFlyoutItem {
                    Text = "Copy To Clipboard (Microsoft Office)", Command = command
                };
                flyoutMenu.Items.Add(flyoutItem);
            }

            if (displayAddBlock || displayAddImage)
            {
                var flyoutSubItem = new MenuFlyoutSubItem {
                    Text = "Add..."
                };

                if (displayAddBlock)
                {
                    for (var i = 0; i < supportedTypes.Count(); ++i)
                    {
                        var command    = new FlyoutCommand(supportedTypes[i], (cmd) => { Popup_CommandHandler_AddBlock(cmd); });
                        var flyoutItem = new MenuFlyoutItem {
                            Text = "Add " + supportedTypes[i], Command = command
                        };
                        flyoutSubItem.Items.Add(flyoutItem);
                    }
                }

                if (displayAddImage)
                {
                    var command    = new FlyoutCommand("Image", (cmd) => { Popup_CommandHandler_AddImage(cmd); });
                    var flyoutItem = new MenuFlyoutItem {
                        Text = "Add Image", Command = command
                    };
                    flyoutSubItem.Items.Add(flyoutItem);
                }

                flyoutMenu.Items.Add(flyoutSubItem);
            }

            if (displayImport || displayExport)
            {
                var flyoutSubItem = new MenuFlyoutSubItem {
                    Text = "Import/Export..."
                };

                if (displayImport)
                {
                    var command    = new FlyoutCommand("Import", (cmd) => { Popup_CommandHandler_Import(cmd); });
                    var flyoutItem = new MenuFlyoutItem {
                        Text = "Import", Command = command
                    };
                    flyoutSubItem.Items.Add(flyoutItem);
                }

                if (displayExport)
                {
                    var command    = new FlyoutCommand("Export", (cmd) => { Popup_CommandHandler_Export(cmd); });
                    var flyoutItem = new MenuFlyoutItem {
                        Text = "Export", Command = command
                    };
                    flyoutSubItem.Items.Add(flyoutItem);
                }

                flyoutMenu.Items.Add(flyoutSubItem);
            }

            flyoutMenu.ShowAt(null, globalPos);
        }
        private void DisplayContextualMenu(Windows.Foundation.Point globalPos)
        {
            var part = _editor.Part;

            if (_editor.Part == null)
            {
                return;
            }

            using (var rootBlock = _editor.GetRootBlock())
            {
                var contentBlock = _lastSelectedBlock;
                if (contentBlock == null)
                {
                    return;
                }

                var isRoot = contentBlock.Id == rootBlock.Id;
                if (!isRoot && (contentBlock.Type == "Container"))
                {
                    return;
                }

                var onRawContent   = part.Type == "Raw Content";
                var onTextDocument = part.Type == "Text Document";

                var isEmpty = _editor.IsEmpty(contentBlock);

                var supportedTypes   = _editor.SupportedAddBlockTypes;
                var supportedExports = _editor.GetSupportedExportMimeTypes(onRawContent ? rootBlock : contentBlock);
                var supportedImports = _editor.GetSupportedImportMimeTypes(contentBlock);
                var supportedStates  = _editor.GetSupportedTargetConversionStates(contentBlock);

                var hasTypes   = (supportedTypes != null) && supportedTypes.Any();
                var hasExports = (supportedExports != null) && supportedExports.Any();
                var hasImports = (supportedImports != null) && supportedImports.Any();
                var hasStates  = (supportedStates != null) && supportedStates.Any();

                var displayConvert   = hasStates && !isEmpty;
                var displayAddBlock  = hasTypes && isRoot;
                var displayAddImage  = false; // hasTypes && isRoot;
                var displayRemove    = !isRoot;
                var displayCopy      = (onTextDocument ? !isRoot : !onRawContent);
                var displayPaste     = hasTypes && isRoot;
                var displayImport    = hasImports;
                var displayExport    = hasExports;
                var displayClipboard = hasExports && supportedExports.Contains(MimeType.OFFICE_CLIPBOARD);

                var flyoutMenu = new MenuFlyout();

                if (displayAddBlock || displayAddImage)
                {
                    var flyoutSubItem = new MenuFlyoutSubItem {
                        Text = "Add..."
                    };
                    flyoutMenu.Items.Add(flyoutSubItem);

                    if (displayAddBlock)
                    {
                        for (var i = 0; i < supportedTypes.Count(); ++i)
                        {
                            var command    = new FlyoutCommand(supportedTypes[i], (cmd) => { Popup_CommandHandler_AddBlock(cmd); });
                            var flyoutItem = new MenuFlyoutItem {
                                Text = "Add " + supportedTypes[i], Command = command
                            };
                            flyoutSubItem.Items.Add(flyoutItem);
                        }
                    }

                    if (displayAddImage)
                    {
                        var command    = new FlyoutCommand("Image", (cmd) => { Popup_CommandHandler_AddImage(cmd); });
                        var flyoutItem = new MenuFlyoutItem {
                            Text = "Add Image", Command = command
                        };
                        flyoutSubItem.Items.Add(flyoutItem);
                    }
                }

                if (displayRemove)
                {
                    var command    = new FlyoutCommand("Remove", (cmd) => { Popup_CommandHandler_Remove(cmd); });
                    var flyoutItem = new MenuFlyoutItem {
                        Text = "Remove", Command = command
                    };
                    flyoutMenu.Items.Add(flyoutItem);
                }

                if (displayConvert)
                {
                    var command    = new FlyoutCommand("Convert", (cmd) => { Popup_CommandHandler_Convert(cmd); });
                    var flyoutItem = new MenuFlyoutItem {
                        Text = "Convert", Command = command
                    };
                    flyoutMenu.Items.Add(flyoutItem);
                }

                if (displayCopy || displayClipboard || displayPaste)
                {
                    var flyoutSubItem = new MenuFlyoutSubItem {
                        Text = "Copy/Paste..."
                    };
                    flyoutMenu.Items.Add(flyoutSubItem);

                    //if (displayCopy)
                    {
                        var command    = new FlyoutCommand("Copy", (cmd) => { Popup_CommandHandler_Copy(cmd); });
                        var flyoutItem = new MenuFlyoutItem {
                            Text = "Copy", Command = command, IsEnabled = displayCopy
                        };
                        flyoutSubItem.Items.Add(flyoutItem);
                    }

                    //if (displayClipboard)
                    {
                        var command    = new FlyoutCommand("Copy To Clipboard (Microsoft Office)", (cmd) => { Popup_CommandHandler_OfficeClipboard(cmd); });
                        var flyoutItem = new MenuFlyoutItem {
                            Text = "Copy To Clipboard (Microsoft Office)", Command = command, IsEnabled = displayClipboard
                        };
                        flyoutSubItem.Items.Add(flyoutItem);
                    }

                    //if (displayPaste)
                    {
                        var command    = new FlyoutCommand("Paste", (cmd) => { Popup_CommandHandler_Paste(cmd); });
                        var flyoutItem = new MenuFlyoutItem {
                            Text = "Paste", Command = command, IsEnabled = displayPaste
                        };
                        flyoutSubItem.Items.Add(flyoutItem);
                    }
                }

                if (displayImport || displayExport)
                {
                    var flyoutSubItem = new MenuFlyoutSubItem {
                        Text = "Import/Export..."
                    };
                    flyoutMenu.Items.Add(flyoutSubItem);

                    //if (displayImport)
                    {
                        var command    = new FlyoutCommand("Import", (cmd) => { Popup_CommandHandler_Import(cmd); });
                        var flyoutItem = new MenuFlyoutItem {
                            Text = "Import", Command = command, IsEnabled = displayImport
                        };
                        flyoutSubItem.Items.Add(flyoutItem);
                    }

                    //if (displayExport)
                    {
                        var command    = new FlyoutCommand("Export", (cmd) => { Popup_CommandHandler_Export(cmd); });
                        var flyoutItem = new MenuFlyoutItem {
                            Text = "Export", Command = command, IsEnabled = displayExport
                        };
                        flyoutSubItem.Items.Add(flyoutItem);
                    }
                }

                if (flyoutMenu.Items.Count > 0)
                {
                    flyoutMenu.ShowAt(null, globalPos);
                }
            }
        }