public void ShowDialogWithDelay(IWin32Window owner, OpenLiveWriter.CoreServices.AsyncOperation asyncOperation, int delayMs)
        {
            // JJA: THIS TECHNIQUE DOES NOT WORK AND CAUSES ALL KINDS OF PROBLEMS! WE NEED A DIFFERENT
            // TECHNIQUE THAT DOES NOT STARVE THE UI THREAD. DO NOT UNDER ANY CONDITIONS RESTORE
            // THIS CODE!!!!!!
            /*
            // start out by polling the get post operation for completion for the delay interval
            using ( new WaitCursor() )
            {
                const int SPLICE_MS = 100 ;
                int waitMs = 0 ;
                while( waitMs < delayMs )
                {
                    if ( asyncOperation.IsDone )
                    {
                        return ;
                    }
                    else
                    {
                        Thread.Sleep(SPLICE_MS);
                        waitMs += SPLICE_MS ;
                    }
                }
            }
            */

            // got past the delay interval, need to signup for events and show the dialog
            _asyncOperation = asyncOperation;

            if (_asyncOperation.IsDone)
                return;

            // show the dialog
            ShowDialog(owner);
        }
 protected internal override void HandleResult(OpenLiveWriter.Extensibility.BlogClient.BlogPost blogPost, ITestResults results)
 {
     if (blogPost.Categories.Length == 2)
         results.AddResult("supportsMultipleCategories", YES);
     else
         results.AddResult("supportsMultipleCategories", NO);
 }
 internal ExtendedHtmlEditorMashallingHandler(IHtmlMarshallingTarget editorContext, IContentSourceSite sourceSite, IHtmlEditorHost blogEditor, OpenLiveWriter.Interop.Com.IDropTarget unhandledDropTarget)
     : base(editorContext)
 {
     _insertionSite = sourceSite;
     _blogEditor = blogEditor;
     _unhandledDropTarget = unhandledDropTarget;
 }
 protected internal override void PreparePost(Blog blog, IBlogClient blogClient, OpenLiveWriter.Extensibility.BlogClient.BlogPost blogPost, ref bool? publish)
 {
     BlogPostCategory[] categories = blogClient.GetCategories(blog.BlogId);
     if (categories.Length < 2)
         throw new InvalidOperationException("Blog " + blog.HomepageUrl + " does not have enough categories for the SupportsMultipleCategories test to be performed");
     BlogPostCategory[] newCategories = new BlogPostCategory[2];
     newCategories[0] = categories[0];
     newCategories[1] = categories[1];
     blogPost.Categories = newCategories;
 }
        protected override void ConfigureClientOptions(OpenLiveWriter.BlogClient.Providers.BlogClientOptions clientOptions)
        {
            base.ConfigureClientOptions(clientOptions);

            clientOptions.SupportsCategories = true;
            clientOptions.SupportsMultipleCategories = true;
            clientOptions.SupportsNewCategories = true;
            clientOptions.SupportsCustomDate = true;
            clientOptions.SupportsExcerpt = true;
            clientOptions.SupportsSlug = true;
            clientOptions.SupportsFileUpload = true;
        }
        /// <summary>
        /// Method that is delegated to by the presentation editor's implementation of
        /// IDocHostCustomUI.GetDropTarget. Replaces the default drop target implementation
        /// with our own. Note that the main purpose of this method for us is to get a reference
        /// to the MSHTML drop target implementaiton. While in this method we do in fact replace
        /// thier implementation with our own, this is probabaly redundant as we also disable
        /// their drop target (see below comment on Initialize). We replace their implementation
        /// in any case just so that if they have any internal state or behavior that depends
        /// upon knowing whether their drop target implementation is active then it can be
        /// set correctly.
        /// </summary>
        /// <param name="pDropTarget">default implementation</param>
        /// <param name="ppDropTarget">our implemetation</param>
        /// <returns>S_OK to indicate that we replaced implementation, otherwise E_NOTIMPL</returns>
        public int GetDropTarget(OpenLiveWriter.Interop.Com.IDropTarget pDropTarget, out OpenLiveWriter.Interop.Com.IDropTarget ppDropTarget)
        {
            // Note: Drop target can be null after the user clicks on an <option> element.

            // save a reference to the mshtml drop target
            mshtmlDropTargetImpl = pDropTarget;

            // replace the mshtml implementaiton with our own (will delegate as necessary)
            ppDropTarget = this;

            // indicate that we replaced the implementation
            return HRESULT.S_OK;
        }
        internal RefreshableContentManager(BlogPostExtensionDataList extensionDataList, OpenLiveWriter.PostEditor.ContentEditor editor)
        {
            _missedCallbackExtensionData = new List<IExtensionData>();
            _extensionDataList = extensionDataList;
            _editor = editor;

            _editor.UndoExecuted += new EventHandler(_editorContentsChanged);
            _editor.RedoExecuted += new EventHandler(_editorContentsChanged);
            _editor.PasteExecuted += new EventHandler(_editorContentsChanged);
            _editor.PasteSpecialExecuted += new EventHandler(_editorContentsChanged);

            _extensionDataList.RefreshableCallbackTriggered += _extensionDataList_RefreshableCallbackTriggered;

            _refreshableContentTimer = new Timer();
            _refreshableContentTimer.Interval = INTERVAL_TICK;
            _refreshableContentTimer.Tick += refreshableContentTimer_Tick;
        }
        public override void DoTest(BlogRunner.Core.Config.Blog blog, OpenLiveWriter.Extensibility.BlogClient.IBlogClient blogClient, ITestResults results)
        {
            BlogPost post = new BlogPost();
            post.Contents = "foo";
            post.Title = "";

            string etag;
            XmlDocument remotePost;
            try
            {
                string newPostId = blogClient.NewPost(blog.BlogId, post, null, true, out etag, out remotePost);
                results.AddResult("supportsEmptyTitles", YES);

                if (CleanUpPosts)
                    blogClient.DeletePost(blog.BlogId, newPostId, true);
            }
            catch
            {
                results.AddResult("supportsEmptyTitles", NO);
            }
        }
 internal void Add(OpenLiveWriter.Mshtml.MarkupRange SelectedMarkupRange)
 {
     listBoxSelection.Items.Insert(0, new SelectionItem(SelectedMarkupRange));
 }
        internal static string ReferenceFixer(BeginTag tag, string reference, ISupportingFileService _fileService, OpenLiveWriter.PostEditor.ContentEditor editor)
        {
            // If it isnt a file url, then it wont be an image from supporting files.
            if (!UrlHelper.IsFile(reference))
                return reference;

            Uri uri = new Uri(reference);
            BlogPostImageData imageData = BlogPostImageDataList.LookupImageDataByInlineUri(editor.ImageList, uri);

            if (imageData == null)
            {
                if (BlogPostImageDataList.LookupImageDataByLinkedUri(editor.ImageList, uri) != null)
                    return null;

                return reference;
            }

            return imageData.ImageSourceFile.Uri.AbsoluteUri;
        }
 public void DragOver(MK grfKeyState, POINT pt, ref OpenLiveWriter.Interop.Com.DROPEFFECT pdwEffect)
 {
     _contentEditorSite.DragOver(grfKeyState, pt, ref pdwEffect);
 }
 private void DocumentEvents_Click(object o, OpenLiveWriter.Mshtml.HtmlEventArgs e)
 {
     //fix bug 306300 - if the editor is clicked in the body outside of the editor's main
     //editable regions, we may not receive a selection change event (even though the selection
     //will be changed to none), so we also update the sidebar state on click.
     if (!e.WasCancelled)
         UpdateSidebarState();
 }
 public int InvalidateUICommand(uint commandId, OpenLiveWriter.Interop.Com.Ribbon.CommandInvalidationFlags flags, IntPtr keyPtr)
 {
     return 0;
 }
 public int Initialize(IntPtr frameWnd, OpenLiveWriter.Interop.Com.Ribbon.IUIApplication application)
 {
     return 0;
 }
 public override int ShowContextMenu(int dwID, ref OpenLiveWriter.Interop.Windows.POINT ppt, object pcmdtReserved, object pdispReserved)
 {
     return HRESULT.S_OK;
 }
 private static void screenCapture_HtmlDocumentAvailable(object sender, OpenLiveWriter.Api.HtmlDocumentAvailableEventArgs e)
 {
     IHTMLDocument3 document = (IHTMLDocument3)e.Document;
     IHTMLElement mapElement = document.getElementById("map");
     if (mapElement == null || mapElement.getAttribute("loaded", 2) == System.DBNull.Value)
         e.DocumentReady = false;
     else
         e.DocumentReady = true;
 }
        public int GetDropTarget(OpenLiveWriter.Interop.Com.IDropTarget pDropTarget, out OpenLiveWriter.Interop.Com.IDropTarget ppDropTarget)
        {
            // log access to method
            LOG("IDocHostUIHandler", "GetDropTarget");

            return docHostUIHandler.GetDropTarget(pDropTarget, out ppDropTarget);
        }
 public void DragOver(OpenLiveWriter.Interop.Windows.MK grfKeyState, OpenLiveWriter.Interop.Windows.POINT pt, ref OpenLiveWriter.Interop.Com.DROPEFFECT pdwEffect)
 {
     pdwEffect = DROPEFFECT.NONE;
 }
 public int _mshtmlEditor_GetDropTarget(OpenLiveWriter.Interop.Com.IDropTarget pDropTarget, out OpenLiveWriter.Interop.Com.IDropTarget ppDropTarget)
 {
     try
     {
         return mshtmlEditorDragAndDropTarget.GetDropTarget(pDropTarget, out ppDropTarget);
     }
     catch (Exception e)
     {
         UnexpectedErrorMessage.Show(e);
         ppDropTarget = null;
         return HRESULT.E_NOTIMPL;
     }
 }
 public void Drop(OpenLiveWriter.Interop.Com.IOleDataObject pDataObj, OpenLiveWriter.Interop.Windows.MK grfKeyState, OpenLiveWriter.Interop.Windows.POINT pt, ref OpenLiveWriter.Interop.Com.DROPEFFECT pdwEffect)
 {
     pdwEffect = DROPEFFECT.NONE;
 }
        private void _editorControl_KeyDown(object o, OpenLiveWriter.Mshtml.HtmlEventArgs e)
        {
            switch ((Keys)e.htmlEvt.keyCode)
            {
                case Keys.Back:
                    //Bug fix: The backspace key triggers an extra selection change event that causes word damage to be
                    //inappropriately committed, so we use a flag to suppress the selection change event for
                    //this case.
                    suppressSelectionChangeForDelete = true;
                    break;
            }

            wordRangeDamager.OnKeyDown(e);
            _commitStrategy.OnKeyDown(e);
        }
        public EmlMessageHandler(DataObjectMeister dataObject, DataFormatHandlerContext handlerContext, OpenLiveWriter.Interop.Com.IDropTarget unhandledDropTarget)
            : base(dataObject, handlerContext, unhandledDropTarget)
        {

        }
 /// <summary>
 /// Delegate to DragAndDropManager for GetDropTarget
 /// </summary>
 /// <param name="pDropTarget">default implementation</param>
 /// <param name="ppDropTarget">our implemetation</param>
 /// <returns>S_OK to indicate that we replaced implementation, otherwise E_NOTIMPL</returns>
 int IDocHostUIHandler2.GetDropTarget(OpenLiveWriter.Interop.Com.IDropTarget pDropTarget, out OpenLiveWriter.Interop.Com.IDropTarget ppDropTarget)
 {
     if (DropTargetHandler != null)
     {
         return DropTargetHandler(pDropTarget, out ppDropTarget);
     }
     else
     {
         ppDropTarget = null;
         return HRESULT.E_NOTIMPL;
     }
 }
 public UnhandledDropTarget(DataObjectMeister dataObject, DataFormatHandlerContext handlerContext, OpenLiveWriter.Interop.Com.IDropTarget unhandledDropTarget)
     : base(dataObject, handlerContext)
 {
     _unhandledDropTarget = unhandledDropTarget;
     _oleDataObject = MshtmlEditorDragAndDropTarget.ExtractOleDataObject(DataMeister.IDataObject);
 }
 public void Drop(OpenLiveWriter.Interop.Com.IOleDataObject pDataObj, MK grfKeyState, POINT pt, ref OpenLiveWriter.Interop.Com.DROPEFFECT pdwEffect)
 {
     _contentEditorSite.Drop(pDataObj, grfKeyState, pt, ref pdwEffect);
 }
        /// <summary>
        /// Inserts a set of images into the current editor, optionally assigning each image an id.
        /// </summary>
        /// <param name="imagePaths">paths of the images to insert</param>
        internal static void InsertImagesCore(IBlogPostHtmlEditor currentEditor, ISupportingFileService fileService, IEditorAccount editorAccount, OpenLiveWriter.PostEditor.ContentEditor editor, string[] imagePaths)
        {
            using (OpenLiveWriter.PostEditor.ContentEditor.EditorUndoUnit undo = new OpenLiveWriter.PostEditor.ContentEditor.EditorUndoUnit(currentEditor))
            {
                StringBuilder htmlBuilder = new StringBuilder();

                //calculate the size for inserted images (based on the user's saved default for this blog)
                DefaultImageSettings defaultImageSettings = new DefaultImageSettings(editorAccount.Id, editor.DecoratorsManager);
                Size defaultImageSize = defaultImageSettings.GetDefaultInlineImageSize();

                //Generate the default img HTML for the image paths.  Initially, the images are linked to the source image
                //path so that the DOM version of the HTML can be loaded.  Once the images are loaded into the DOM, we can apply
                //the image decorators to generate scaled images, borders, etc.
                ImagePropertiesInfo[] imageInfos = new ImagePropertiesInfo[imagePaths.Length];

                // don't insert into the title
                currentEditor.FocusBody();

                for (int i = 0; i < imageInfos.Length; i++)
                {
                    string imagePath = imagePaths[i];

                    Uri imgUri;
                    if (UrlHelper.IsUrl(imagePath))
                        imgUri = new Uri(imagePath);
                    else
                        imgUri = new Uri(UrlHelper.CreateUrlFromPath(imagePath));

                    Size imageSize = new Size(1, 1);
                    if (imgUri.IsFile && File.Exists(imagePath))
                    {
                        if (!File.Exists(imgUri.LocalPath))
                            Trace.Fail("Error inserting image - the image URL was corrupted: " + imagePath);
                        else
                        {
                            try
                            {
                                //check the validity of the image file
                                imageSize = ImageUtils.GetImageSize(imagePath);
                            }
                            catch (Exception)
                            {
                                Trace.WriteLine("There is a problem with the image file: " + imagePath);

                                // Insert anyway, MSHTML will show a red X in place of the image.
                                htmlBuilder.AppendFormat(CultureInfo.InvariantCulture, "<img src=\"{0}\" />", HtmlUtils.EscapeEntities(UrlHelper.SafeToAbsoluteUri(imgUri)));

                                continue;
                            }
                        }
                    }

                    // If the image has an embedded thumbnail, we'll use it as a place holder for the <img src="...">
                    // until we generate an inline image and apply decorators.
                    Stream embeddedThumbnailStream = ImageHelper2.GetEmbeddedThumbnailStream(imagePath);

                    if (embeddedThumbnailStream != null)
                    {
                        // Save thumbnail to disk.
                        ISupportingFile imageFileEmbeddedThumbnail = fileService.CreateSupportingFile(Path.GetFileName(imagePath), Guid.NewGuid().ToString(), embeddedThumbnailStream);

                        imageSize = ImageUtils.GetScaledImageSize(defaultImageSize.Width, defaultImageSize.Height, imageSize);
                        //insert the default image html
                        String imageElementAttrs = String.Format(CultureInfo.InvariantCulture, " width=\"{0}\" height=\"{1}\"", imageSize.Width, imageSize.Height);

                        htmlBuilder.AppendFormat(CultureInfo.InvariantCulture, "<img src=\"{0}\" srcDelay=\"{1}\" {2} />", HtmlUtils.EscapeEntities(UrlHelper.SafeToAbsoluteUri(imageFileEmbeddedThumbnail.FileUri)), HtmlUtils.EscapeEntities(imgUri.ToString()), imageElementAttrs);
                    }
                    else if (currentEditor is BlogPostHtmlEditorControl && (imagePaths.Length > DELAYED_IMAGE_THRESHOLD || imageSize.Width * imageSize.Height > 16777216/*4096 X 4096*/))
                    {
                        // If we are using a delayed loading tactic then we insert using the srcdelay
                        htmlBuilder.Append(MakeHtmlForImageSourceDelay(imgUri.ToString()));
                    }
                    else
                    {
                        imageSize = ImageUtils.GetScaledImageSize(defaultImageSize.Width, defaultImageSize.Height, imageSize);
                        //insert the default image html
                        String imageElementAttrs = imgUri.IsFile ? String.Format(CultureInfo.InvariantCulture, " width=\"{0}\" height=\"{1}\"", imageSize.Width, imageSize.Height) : String.Empty;

                        htmlBuilder.AppendFormat(CultureInfo.InvariantCulture, "<img src=\"{0}\" {1} />", HtmlUtils.EscapeEntities(UrlHelper.SafeToAbsoluteUri(imgUri)), imageElementAttrs);
                    }
                }

                //insert the HTML into the editor
                currentEditor.InsertHtml(htmlBuilder.ToString(), false);

                selectionChanged = false;
                BlogPostHtmlEditorControl blogPostEditor = currentEditor as BlogPostHtmlEditorControl;
                if (blogPostEditor != null)
                    blogPostEditor.SelectionChanged += blogPostEditor_SelectionChanged;

                //now that the image HTML is inserted into the editor, apply the default settings to the new images.
                undo.Commit();
            }
        }