private bool InsertSmartContentFromEmbed(string embed)
{
ContentSourceInfo contentSource = ContentSourceManager.FindContentSource(typeof(VideoContentSource));
if (contentSource != null)
{
SmartContentSource smartSource = contentSource.Instance as SmartContentSource;
VideoContentSource videoSource = smartSource as VideoContentSource;
IExtensionData extensionData = _contentSourceSite.CreateExtensionData(Guid.NewGuid().ToString());
ISmartContent smartContent = new SmartContent(extensionData);
videoSource.CreateContentFromEmbed(embed, smartContent);
// generate html and insert it
string content = videoSource.GenerateEditorHtml(smartContent, _contentSourceSite);
if (content != null)
{
_contentSourceSite.InsertContent(VideoContentSource.ID, content, extensionData);
return(true);
}
else
{
Trace.Fail("Video Source content generated from embed tag was empty");
return(false);
}
}
Trace.Fail("Cannot find the video plugin");
return(false);
}
private static bool TableElementIsContainedInSmartContent(MarkupRange elementRange)
{
// table elements inside smart content regions are not editable
IHTMLElement parentSmartContent = elementRange.Start.GetParentElement(ContentSourceManager.CreateSmartContentElementFilter());
return(parentSmartContent != null);
}
private void SelectNextControlElement(bool forward)
{
MarkupPointer p;
if (forward)
{
p = EditorContext.Selection.SelectedMarkupRange.End.Clone();
}
else
{
p = EditorContext.Selection.SelectedMarkupRange.Start.Clone();
}
IHTMLElement htmlElement = GetNextElement(p, ElementRange, new IHTMLElementFilter(IsSelectableControlElement), forward);
if (ContentSourceManager.IsSmartContent(htmlElement))
{
SmartContentSelection.SelectIfSmartContentElement(EditorContext, htmlElement);
}
else if (htmlElement is IHTMLControlElement)
{
_editor.SelectControlElement((IHTMLControlElement)htmlElement);
}
if (htmlElement != null)
{
htmlElement.scrollIntoView(!forward);
}
}
public IExtensionData[] CalculateReferencedExtensionData(string content)
{
Hashtable datas = new Hashtable();
ContentSourceManager.SmartContentPredicate predicate = new ContentSourceManager.SmartContentPredicate();
SimpleHtmlParser p = new SimpleHtmlParser(content);
for (Element el; null != (el = p.Next());)
{
if (predicate.IsMatch(el))
{
BeginTag bt = el as BeginTag;
Attr idAttr = bt.GetAttribute("id");
if (idAttr != null) //Synchronized WP posts will strip ID attrs (bug 488143)
{
string smartContentSourceId;
string smartContentId;
string smartContentElementId = idAttr.Value;
ContentSourceManager.ParseContainingElementId(smartContentElementId, out smartContentSourceId, out smartContentId);
IExtensionData data = GetExtensionData(smartContentId);
if (data != null)
{
datas[smartContentId] = data;
}
}
}
}
return((IExtensionData[])ArrayHelper.CollectionToArray(datas.Values, typeof(IExtensionData)));
}
public static ContentSourceInfo FindContentSourceForLiveClipboardFormat(LiveClipboardFormat format)
{
// see if the preferred content source is noted in the registry
string contentSourceId = GetContentSourceIdForFormat(format);
if (contentSourceId != null)
{
// if the content-source is still installed and active then return it
ContentSourceInfo contentSourceInfo = ContentSourceManager.FindContentSource(contentSourceId);
if (contentSourceInfo != null)
{
return(contentSourceInfo);
}
}
// didn't find a valid preconfigured entry, scan all sources to see if we've got one
foreach (ContentSourceInfo contentSourceInfo in ContentSourceManager.ActiveContentSources)
{
foreach (LiveClipboardFormatHandler csFormatHandler in contentSourceInfo.LiveClipboardFormatHandlers)
{
if (csFormatHandler.Format.Equals(format))
{
// note that this is now our default
SetContentSourceForFormat(format, contentSourceInfo.Id);
// return the source
return(contentSourceInfo);
}
}
}
// no match found
return(null);
}
/// <summary>
/// global initialization which may show error dialogs or cause
/// failure of the entire product to load
/// </summary>
public static bool Initialize()
{
// can show error dialog if plugin has missing or incorrect attributes
ContentSourceManager.Initialize();
return(true);
}
public void Initialize(string registrySettingsPath, IContentEditorLogger logger, IContentTarget contentTarget, ISettingsProvider settingsProvider)
{
try
{
GlobalEditorOptions.Init(contentTarget, settingsProvider);
HtmlEditorControl.AllowCachedEditor();
Assembly assembly = Assembly.GetExecutingAssembly();
ApplicationEnvironment.Initialize(assembly, Path.GetDirectoryName(assembly.Location), registrySettingsPath, contentTarget.ProductName);
ContentSourceManager.Initialize(false);
Trace.Listeners.Clear();
if (logger != null)
{
_logger = new RedirectionLogger(logger);
Trace.Listeners.Add(_logger);
}
#if DEBUG
Trace.Listeners.Add(new DefaultTraceListener());
#endif
}
catch (Exception e)
{
Trace.Fail("Failed to initialize Shared Canvas: " + e);
Trace.Flush();
throw;
}
}
private void buttonOptions_Click(object sender, System.EventArgs e)
{
ContentSourceInfo selectedContentSource = GetSelectedPlugin();
if (selectedContentSource != null)
{
if (selectedContentSource.WriterPluginHasEditableOptions)
{
try
{
selectedContentSource.Instance.EditOptions(FindForm());
}
catch (NotImplementedException ex)
{
ContentSourceManager.DisplayContentRetreivalError(FindForm(), ex, selectedContentSource);
}
catch (Exception exception)
{
Trace.Fail(exception.ToString());
DisplayableException dex = new DisplayableException(
Res.Get(StringId.UnexpectedErrorPluginTitle),
string.Format(CultureInfo.CurrentCulture, Res.Get(StringId.UnexpectedErrorPluginDescription), selectedContentSource.Name, exception.Message));
DisplayableExceptionDisplayForm.Show(FindForm(), dex);
}
}
}
}
public static string GenerateContentBlock(string contentSourceId, string blockId, string content, ISmartContent sContent, IHTMLElement element)
{
string className = ContentSourceManager.EDITABLE_SMART_CONTENT;
string elementId = ContentSourceManager.MakeContainingElementId(contentSourceId, blockId);
bool inline = true;
return(GenerateBlock(className, elementId, sContent, inline, content, false, element));
}
/// <summary>Initializes the manager.</summary>
internal static void Init(IModHelper helper, IMonitor monitor)
{
config = helper.ReadConfig <BetterArtisanGoodIconsConfig>();
foreach (ArtisanGoodTextureProvider provider in ContentSourceManager.GetTextureProviders(helper, monitor))
{
TextureProviders.Add(provider);
}
}
public void SaveEditedSmartContent()
{
//update the element ID with the new smart content id (this preserves undo-ability)
_smartContentElement.id = ContentSourceManager.MakeContainingElementId(_contentSourceId, _smartContentId);
SmartContentInsertionHelper.InsertEditorHtmlIntoElement(_contentSourceContext, _contentSource, _smartContent, _smartContentElement);
//reinit the smart content so it is re-cloned
MakeSmartContentEditable();
}
/// <summary>
/// global initializaiton which may show error dialogs or cause
/// failure of the entire product to load
/// </summary>
public static bool Initialize()
{
// can show error dialog if plugin has missing or incorrect attributes
ContentSourceManager.Initialize();
// auto-update manager
//BlogSettingsAutoUpdateManager.Instance.Startup();
return(true);
}
protected override bool DoInsertData(DataAction action, MarkupPointer begin, MarkupPointer end)
{
// get the live clipboard data
LiveClipboardData lcData = DataMeister.LiveClipboardData;
if (lcData == null)
{
Trace.Fail("Unexpected failure to get LC data!");
return(false);
}
// lookup the content-source
ContentSourceInfo contentSource =
LiveClipboardManager.FindContentSourceForLiveClipboard(lcData.Formats);
if (contentSource == null)
{
Trace.Fail("Unexpected failure to find content soure!");
return(false);
}
using (new WaitCursor())
{
try
{
// HACK: drive the selection textRange to the caret so we can call generic
// content-source routines that work off the current selection
// Note that we do the same thing below for Images so we can use the common
// InsertImages method -- we may want to bake this into core marshalling
// or add MarkupRange parameters to the image and content-source routines
EditorContext.MarkupServices.CreateMarkupRange(begin, end).ToTextRange().select();
if (contentSource.Instance is SmartContentSource)
{
return(InsertSmartContentFromLiveClipboard(contentSource, lcData.Document));
}
else if (contentSource.Instance is ContentSource)
{
return(InsertSimpleContentFromLiveClipboard(contentSource, lcData.Document));
}
else
{
Debug.Fail("Unexpected content source type: " + contentSource.GetType());
return(false);
}
}
catch (Exception ex)
{
ContentSourceManager.DisplayContentRetreivalError(EditorContext.FrameWindow, ex, contentSource);
return(false);
}
}
}
protected override void OnResizeStart(Size size, bool preserveAspectRatio)
{
_resizeUndo = EditorContext.CreateUndoUnit();
base.OnResizeStart(size, preserveAspectRatio);
// save references
_initialParentSize = size;
_preserveAspectRatio = preserveAspectRatio;
// initialize smart content
string contentSourceId;
string contentId;
ContentSourceManager.ParseContainingElementId(HTMLElement.id, out contentSourceId, out contentId);
// clone the smart content for resizing so that settings changes made during the resize
//operation are undoable
String newContentId = Guid.NewGuid().ToString();
SmartContent content = (SmartContent)_contentSourceContext.CloneSmartContent(contentId, newContentId);
if (content == null)
{
Trace.WriteLine("Could not clone smart content for resize.");
return;
}
HTMLElement.id = ContentSourceManager.MakeContainingElementId(contentSourceId, newContentId);
// call sizer
ResizeOptions resizeOptions = new ResizeOptions();
_contentSource.OnResizeStart(content, resizeOptions);
// determine the target size
IHTMLElement targetSizeElement = GetResizeTargetElement(resizeOptions.ResizeableElementId);
_initialTargetSize = new Size(targetSizeElement.offsetWidth, targetSizeElement.offsetHeight);
// Account for areas of the smart content that are not being scaled when preserving aspect ratio.
// For example, in YouTube plugin, label text below the image.
UpdateResizerAspectRatioOffset(_initialParentSize - _initialTargetSize);
// determine the aspect ratio
if (resizeOptions.AspectRatio > 0)
{
_aspectRatio = resizeOptions.AspectRatio;
}
else
{
_aspectRatio = ((double)_initialTargetSize.Width) / _initialTargetSize.Height;
}
}
/// <summary>
/// Clones active smart content contained in the provided HTML, and disables unknown smart content.
/// </summary>
public static string PrepareSmartContentHtmlForEditorInsertion(string html, IContentSourceSidebarContext sourceContext)
{
StringBuilder output = new StringBuilder();
ContentSourceManager.SmartContentPredicate predicate = new ContentSourceManager.SmartContentPredicate();
SimpleHtmlParser p = new SimpleHtmlParser(html);
for (Element el; null != (el = p.Next());)
{
if (predicate.IsMatch(el))
{
BeginTag bt = el as BeginTag;
Attr idAttr = bt.GetAttribute("id");
String contentSourceId, contentItemId;
ContentSourceManager.ParseContainingElementId(idAttr.Value, out contentSourceId, out contentItemId);
ISmartContent smartContent = sourceContext.FindSmartContent(contentItemId);
if (smartContent != null)
{
String newId = Guid.NewGuid().ToString();
sourceContext.CloneSmartContent(contentItemId, newId);
if (RefreshableContentManager.ContentSourcesWithRefreshableContent.Contains(contentSourceId))
{
IExtensionData extensionData = sourceContext.FindExtentsionData(newId);
Debug.Assert(extensionData != null);
// Since we just made a new id for the smart content just about to be inserted
// we want to give it a chance to get a callback because its callback might have happened while
// it was on the clipboard(in the event of cut). This means the refreshable content manager doesnt know
// to watch out for this smart content on paste, it only knows to look out for who created it. Thus
// we just force the callback, and if it didnt need it, nothing will happen.
if (extensionData.RefreshCallBack == null)
{
extensionData.RefreshCallBack = DateTime.UtcNow;
}
}
idAttr.Value = ContentSourceManager.MakeContainingElementId(contentSourceId, newId);
}
else
{
ContentSourceManager.RemoveSmartContentAttributes(bt);
}
}
output.Append(el.ToString());
}
return(output.ToString());
}
public static SmartContentSelection SelectIfSmartContentElement(IHtmlEditorComponentContext editorComponentContext, IHTMLElement e, SmartContentState contentState)
{
if (e != null)
{
IHTMLElement smartContent = ContentSourceManager.GetContainingSmartContent(e);
if (smartContent == null)
{
return(null);
}
return(SelectElement(editorComponentContext, smartContent, contentState));
}
return(null);
}
private static void ContentSourceManagerGetTextureProvidersPostfix(IModHelper helper, IMonitor monitor)
{
var providers = helper.ContentPacks.GetOwned()
.Select(pack => ContentSourceManager.TryLoadContentSource(new ContentPackSource(pack), monitor));
var textureProviders = (IList)"BetterArtisanGoodIcons.ArtisanGoodsManager".ToType().RequireField("TextureProviders")
.GetValue(null) !;
foreach (var provider in providers)
{
if (provider is not null)
textureProviders.Add(provider);
}
}
public LiveClipboardComponentDisplay(ContentSourceInfo contentSource)
{
// if this format handler is "built-in" then override the content-source to
// list it as "windows-live writer"
if (ContentSourceManager.ContentSourceIsPlugin(contentSource.Id))
{
_icon = contentSource.Image;
_name = contentSource.Name;
}
else
{
_icon = _writerLogoBitmap;
_name = ApplicationEnvironment.ProductName;
}
}
public static new bool CanCreateFrom(DataObjectMeister data)
{
if (!GlobalEditorOptions.SupportsFeature(ContentEditorFeature.UrlContentSourcePaste))
{
return(false);
}
if (HasUrl(data))
{
return(ContentSourceManager.FindContentSourceForUrl(ExtractUrl(data)) != null);
}
else
{
return(false);
}
}
public EditableSmartContent(IContentSourceSidebarContext context, SmartContentSource contentSource, IHTMLElement smartContentElement)
{
GC.SuppressFinalize(this);
_contentSourceContext = context;
_contentSource = contentSource;
_smartContentElement = smartContentElement;
ContentSourceManager.ParseContainingElementId(_smartContentElement.id, out _contentSourceId, out _smartContentId);
_smartContent = _contentSourceContext.FindSmartContent(_smartContentId);
_extensionData = _contentSourceContext.FindExtentsionData(_smartContentId);
_properties = new EditableRootProperties();
_layout = new EditableLayoutStyle();
_supportingFiles = new EditableSupportingFiles();
MakeSmartContentEditable();
}
public static bool ExecuteSimpleContentRetreival(
IWin32Window dialogOwner, ContentSourceInfo contentSourceInfo, string url, ref string title, ref string newContent)
{
try
{
// if there is progress requested then just do it on the main UI thread
if (contentSourceInfo.UrlContentSourceRequiresProgress)
{
// create the progress dialog and the async operation
UrlContentRetreivalWithProgressDialog progressDialog = new UrlContentRetreivalWithProgressDialog(contentSourceInfo);
progressDialog.CreateControl();
SimpleUrlContentRetreivalAsyncOperation asyncOperation = new SimpleUrlContentRetreivalAsyncOperation(progressDialog, contentSourceInfo.Instance as ContentSource, url, title);
// execute and retrieve results
if (ExecuteWithProgress(dialogOwner, progressDialog, asyncOperation, contentSourceInfo))
{
title = asyncOperation.Title;
newContent = asyncOperation.NewContent;
return(true);
}
else
{
return(false);
}
}
else
{
try
{
(contentSourceInfo.Instance as ContentSource).CreateContentFromUrl(url, ref title, ref newContent);
return(true);
}
catch (Exception ex)
{
ContentSourceManager.DisplayContentRetreivalError(dialogOwner, ex, contentSourceInfo);
return(false);
}
}
}
catch (Exception ex)
{
Trace.Fail("Unexpected exception executing network operation for content source: " + ex.ToString());
return(false);
}
}
protected override void OnElementAttached()
{
base.OnElementAttached();
(HTMLElement as IHTMLElement3).contentEditable = "false";
string sourceId;
string contentId;
if (HTMLElement.id != null)
{
try
{
if (HTMLElement.className == HtmlPreserver.PRESERVE_CLASS)
{
_contentState = SmartContentState.Preserve;
}
else
{
ContentSourceManager.ParseContainingElementId(HTMLElement.id, out sourceId, out contentId);
if (sourceId == null || contentId == null)
{
_contentState = SmartContentState.Broken;
}
else
{
if (_contentSourceContext.FindSmartContent(contentId) == null)
{
_contentState = SmartContentState.Broken;
}
}
}
}
catch (Exception)
{
_contentState = SmartContentState.Broken;
}
}
else
{
_contentState = SmartContentState.Broken;
}
}
protected override bool DoInsertData(DataAction action, MarkupPointer begin, MarkupPointer end)
{
// lookup the content-source
ContentSourceInfo contentSource = ContentSourceManager.FindContentSourceForUrl(Url);
if (contentSource != null)
{
// HACK: drive the selection textRange to the caret so we can call generic
// content-source routines that work off the current selection
// Note that we do the same thing below for Images so we can use the common
// InsertImages method -- we may want to bake this into core marshalling
// or add MarkupRange parameters to the image and content-source routines
EditorContext.MarkupServices.CreateMarkupRange(begin, end).ToTextRange().select();
try
{
if (contentSource.Instance is SmartContentSource)
{
return(InsertSmartContentFromUrl(contentSource, Url));
}
else if (contentSource.Instance is ContentSource)
{
return(InsertSimpleContentFromUrl(contentSource, Url));
}
else
{
Debug.Fail("Unexpected content source type: " + contentSource.GetType());
return(false);
}
}
catch (Exception ex)
{
Trace.Fail("Unexpected exception inserting content: " + ex.ToString());
return(false);
}
}
else
{
Debug.Fail("No content source found during marshalling!");
return(false);
}
}
private void UpdatePluginList()
{
BlogPublishingPluginSettings settings = TemporaryBlogSettings.PublishingPluginSettings;
List <ContentSourceInfo> plugins = new List <ContentSourceInfo>(
Join(ContentSourceManager.EnabledPublishNotificationPlugins, ContentSourceManager.EnabledHeaderFooterPlugins));
plugins.Sort(ContentSourceManager.CreateComparison(settings));
listViewPlugins.BeginUpdate();
try
{
listViewPlugins.Items.Clear();
imgListPlugins.Images.Clear();
foreach (ContentSourceInfo csi in plugins)
{
imgListPlugins.Images.Add(BidiHelper.Mirror(csi.Image));
ListViewItem item = new ListViewItem();
item.Tag = csi;
item.Text = " " + csi.Name;
item.ImageIndex = imgListPlugins.Images.Count - 1;
item.Checked = settings.IsEnabled(csi.Id) ?? false;
listViewPlugins.Items.Add(item);
}
if (listViewPlugins.Items.Count > 0)
{
listViewPlugins.Items[0].Selected = true;
}
}
finally
{
listViewPlugins.EndUpdate();
}
ManageMoveButtons();
}
private static bool ExecuteWithProgress(
IWin32Window dialogOwner,
UrlContentRetreivalWithProgressDialog progressDialog,
UrlContentRetreivalAsyncOperation asyncOperation,
ContentSourceInfo contentSourceInfo)
{
try
{
// show the progress dialog
using (progressDialog)
{
asyncOperation.Start();
progressDialog.ShowProgress(dialogOwner, asyncOperation);
}
// handle the result
if (asyncOperation.Error != null)
{
ContentSourceManager.DisplayContentRetreivalError(dialogOwner, asyncOperation.Error, contentSourceInfo);
return(false);
}
else if (asyncOperation.WasCancelled)
{
return(false);
}
else
{
return(true);
}
}
catch (Exception ex)
{
Trace.Fail("Unexpected exception executing network operation for content source: " + ex.ToString());
return(false);
}
}
public static void InsertContentIntoElement(string content, ISmartContent sContent, IContentSourceSidebarContext contentSourceContext, IHTMLElement element)
{
MshtmlMarkupServices MarkupServices = new MshtmlMarkupServices((IMarkupServicesRaw)element.document);
//Note: undo/redo disabled for smart content since undo causes the HTML to get out of sync
//with the inserter's settings state, so undo changes will be blown away the next time the
//the inserter's HTML is regenerated. Also note that making this insertion without wrapping it
//in an undo clears the undo/redo stack, which is what we want for beta.
//string undoId = Guid.NewGuid().ToString();
MarkupRange htmlRange = MarkupServices.CreateMarkupRange(element, false);
htmlRange.Start.PushCling(true);
htmlRange.End.PushCling(true);
MarkupServices.Remove(htmlRange.Start, htmlRange.End);
htmlRange.Start.PopCling();
htmlRange.End.PopCling();
element.style.padding = ToPaddingString(sContent.Layout);
if (sContent.Layout.Alignment == Alignment.None ||
sContent.Layout.Alignment == Alignment.Right ||
sContent.Layout.Alignment == Alignment.Left)
{
element.style.display = "inline";
element.style.marginLeft = "0px";
element.style.marginRight = "0px";
element.style.styleFloat = sContent.Layout.Alignment.ToString().ToLower(CultureInfo.InvariantCulture);
}
else if (sContent.Layout.Alignment == Alignment.Center)
{
element.style.styleFloat = Alignment.None.ToString().ToLower(CultureInfo.InvariantCulture);
element.style.display = "block";
element.style.marginLeft = "auto";
element.style.marginRight = "auto";
}
// Clear out any width on the overall smart content block, if the element is centered, we will add the width back in later
// after we calcuate it from the childern, the current width value is stale.
element.style.width = "";
//Note: we use MarkupServices to insert the content so that IE doesn't try to fix up URLs.
//Element.insertAdjacentHTML() is a no-no because it rewrites relaive URLs to include
//the fullpath from the local filesytem.
//MarkupServices.ParseString() doesn't attempt to fix up URLs, so its safe to use.
//We will now stage the new content into a MarkupContainer, and then move it into
//the working document.
MarkupPointer sc1 = MarkupServices.CreateMarkupPointer();
MarkupPointer sc2 = MarkupServices.CreateMarkupPointer();
//Create a temporary document from the html and set the start/end pointers to the
//start and end of the document.
MarkupServices.ParseString(content, sc1, sc2);
IHTMLDocument2 doc = sc1.GetDocument();
MarkupRange stagingRange = MarkupServices.CreateMarkupRange(sc1, sc2);
stagingRange.MoveToElement(doc.body, false);
//IE7 hack: fixes bug 305512. Note that this will destroy the inner content of the element,
//so make sure it is called before the refreshed content is inserted.
BeforeInsertInvalidateHackForIE7(element);
//move the content from the staging area into the actual insertion point.
MarkupServices.Move(stagingRange.Start, stagingRange.End, htmlRange.End);
if (sContent.Layout.Alignment == Alignment.Center)
{
MarkupContext mc = htmlRange.End.Right(false);
MarkupRange range = MarkupServices.CreateMarkupRange(mc.Element, false);
IHTMLElement[] childern = range.GetTopLevelElements(MarkupRange.FilterNone);
int maxWidth = 0;
foreach (IHTMLElement child in childern)
{
maxWidth = Math.Max(maxWidth, child.offsetWidth);
}
if (maxWidth != 0)
{
mc.Element.style.width = maxWidth;
}
}
// Let the context provider know the smart content was edited.
string contentSourceId, contentId;
ContentSourceManager.ParseContainingElementId(element.id, out contentSourceId, out contentId);
contentSourceContext.OnSmartContentEdited(contentId);
}
private static List <NewImageInfo> ScanImages(IBlogPostHtmlEditor currentEditor, IEditorAccount editorAccount, ContentEditor editor, bool useDefaultTargetSettings)
{
List <NewImageInfo> newImages = new List <NewImageInfo>();
ApplicationPerformance.ClearEvent("InsertImage");
ApplicationPerformance.StartEvent("InsertImage");
using (new WaitCursor())
{
IHTMLElement2 postBodyElement = (IHTMLElement2)((BlogPostHtmlEditorControl)currentEditor).PostBodyElement;
if (postBodyElement != null)
{
foreach (IHTMLElement imgElement in postBodyElement.getElementsByTagName("img"))
{
string imageSrc = imgElement.getAttribute("srcDelay", 2) as string;
if (string.IsNullOrEmpty(imageSrc))
{
imageSrc = imgElement.getAttribute("src", 2) as string;
}
// WinLive 96840 - Copying and pasting images within shared canvas should persist source
// decorator settings. "wlCopySrcUrl" is inserted while copy/pasting within canvas.
bool copyDecoratorSettings = false;
string attributeCopySrcUrl = imgElement.getAttribute("wlCopySrcUrl", 2) as string;
if (!string.IsNullOrEmpty(attributeCopySrcUrl))
{
copyDecoratorSettings = true;
imgElement.removeAttribute("wlCopySrcUrl", 0);
}
// Check if we need to apply default values for image decorators
bool applyDefaultDecorator = true;
string attributeNoDefaultDecorator = imgElement.getAttribute("wlNoDefaultDecorator", 2) as string;
if (!string.IsNullOrEmpty(attributeNoDefaultDecorator) && string.Compare(attributeNoDefaultDecorator, "TRUE", StringComparison.OrdinalIgnoreCase) == 0)
{
applyDefaultDecorator = false;
imgElement.removeAttribute("wlNoDefaultDecorator", 0);
}
string applyDefaultMargins = imgElement.getAttribute("wlApplyDefaultMargins", 2) as string;
if (!String.IsNullOrEmpty(applyDefaultMargins))
{
DefaultImageSettings defaultImageSettings = new DefaultImageSettings(editorAccount.Id, editor.DecoratorsManager);
MarginStyle defaultMargin = defaultImageSettings.GetDefaultImageMargin();
// Now apply it to the image
imgElement.style.marginTop = String.Format(CultureInfo.InvariantCulture, "{0} px", defaultMargin.Top);
imgElement.style.marginLeft = String.Format(CultureInfo.InvariantCulture, "{0} px", defaultMargin.Left);
imgElement.style.marginBottom = String.Format(CultureInfo.InvariantCulture, "{0} px", defaultMargin.Bottom);
imgElement.style.marginRight = String.Format(CultureInfo.InvariantCulture, "{0} px", defaultMargin.Right);
imgElement.removeAttribute("wlApplyDefaultMargins", 0);
}
if ((UrlHelper.IsFileUrl(imageSrc) || IsFullPath(imageSrc)) && !ContentSourceManager.IsSmartContent(imgElement))
{
Uri imageSrcUri = new Uri(imageSrc);
try
{
BlogPostImageData imageData = BlogPostImageDataList.LookupImageDataByInlineUri(editor.ImageList, imageSrcUri);
Emoticon emoticon = EmoticonsManager.GetEmoticon(imgElement);
if (imageData == null && emoticon != null)
{
// This is usually an emoticon copy/paste and needs to be cleaned up.
Uri inlineImageUri = editor.EmoticonsManager.GetInlineImageUri(emoticon);
imgElement.setAttribute("src", UrlHelper.SafeToAbsoluteUri(inlineImageUri), 0);
}
else if (imageData == null)
{
if (!File.Exists(imageSrcUri.LocalPath))
{
throw new FileNotFoundException(imageSrcUri.LocalPath);
}
// WinLive 188841: Manually attach the behavior so that the image cannot be selected or resized while its loading.
DisabledImageElementBehavior disabledImageBehavior = new DisabledImageElementBehavior(editor.IHtmlEditorComponentContext);
disabledImageBehavior.AttachToElement(imgElement);
Size sourceImageSize = ImageUtils.GetImageSize(imageSrcUri.LocalPath);
ImagePropertiesInfo imageInfo = new ImagePropertiesInfo(imageSrcUri, sourceImageSize, new ImageDecoratorsList(editor.DecoratorsManager, new BlogPostSettingsBag()));
DefaultImageSettings defaultImageSettings = new DefaultImageSettings(editorAccount.Id, editor.DecoratorsManager);
// Make sure this is set because some imageInfo properties depend on it.
imageInfo.ImgElement = imgElement;
bool isMetafile = ImageHelper2.IsMetafile(imageSrcUri.LocalPath);
ImageClassification imgClass = ImageHelper2.Classify(imageSrcUri.LocalPath);
if (!isMetafile && ((imgClass & ImageClassification.AnimatedGif) != ImageClassification.AnimatedGif))
{
// WinLive 96840 - Copying and pasting images within shared canvas should persist source
// decorator settings.
if (copyDecoratorSettings)
{
// Try to look up the original copied source image.
BlogPostImageData imageDataOriginal = BlogPostImageDataList.LookupImageDataByInlineUri(editor.ImageList, new Uri(attributeCopySrcUrl));
if (imageDataOriginal != null && imageDataOriginal.GetImageSourceFile() != null)
{
// We have the original image reference, so lets make a clone of it.
BlogPostSettingsBag originalBag = (BlogPostSettingsBag)imageDataOriginal.ImageDecoratorSettings.Clone();
ImageDecoratorsList originalDecoratorsList = new ImageDecoratorsList(editor.DecoratorsManager, originalBag);
ImageFileData originalImageFileData = imageDataOriginal.GetImageSourceFile();
Size originalImageSize = new Size(originalImageFileData.Width, originalImageFileData.Height);
imageInfo = new ImagePropertiesInfo(originalImageFileData.Uri, originalImageSize, originalDecoratorsList);
}
else
{
// There are probably decorators applied to the image, but in a different editor so we can't access them.
// We probably don't want to apply any decorators to this image, so apply blank decorators and load the
// image as full size so it looks like it did before.
imageInfo.ImageDecorators = defaultImageSettings.LoadBlankLocalImageDecoratorsList();
imageInfo.InlineImageSizeName = ImageSizeName.Full;
}
}
else if (applyDefaultDecorator)
{
imageInfo.ImageDecorators = defaultImageSettings.LoadDefaultImageDecoratorsList();
if ((imgClass & ImageClassification.TransparentGif) == ImageClassification.TransparentGif)
{
imageInfo.ImageDecorators.AddDecorator(NoBorderDecorator.Id);
}
}
else
{
// Don't use default values for decorators
imageInfo.ImageDecorators = defaultImageSettings.LoadBlankLocalImageDecoratorsList();
imageInfo.InlineImageSizeName = ImageSizeName.Full;
}
}
else
{
ImageDecoratorsList decorators = new ImageDecoratorsList(editor.DecoratorsManager, new BlogPostSettingsBag());
decorators.AddDecorator(editor.DecoratorsManager.GetDefaultRemoteImageDecorators());
imageInfo.ImageDecorators = decorators;
}
imageInfo.ImgElement = imgElement;
imageInfo.DhtmlImageViewer = editorAccount.EditorOptions.DhtmlImageViewer;
//discover the "natural" target settings from the DOM
string linkTargetUrl = imageInfo.LinkTargetUrl;
if (linkTargetUrl == imageSrc)
{
imageInfo.LinkTarget = LinkTargetType.IMAGE;
}
else if (!String.IsNullOrEmpty(linkTargetUrl) && !UrlHelper.IsFileUrl(linkTargetUrl))
{
imageInfo.LinkTarget = LinkTargetType.URL;
}
else
{
imageInfo.LinkTarget = LinkTargetType.NONE;
}
if (useDefaultTargetSettings)
{
if (!GlobalEditorOptions.SupportsFeature(ContentEditorFeature.SupportsImageClickThroughs) && imageInfo.DefaultLinkTarget == LinkTargetType.IMAGE)
{
imageInfo.DefaultLinkTarget = LinkTargetType.NONE;
}
if (imageInfo.LinkTarget == LinkTargetType.NONE)
{
imageInfo.LinkTarget = imageInfo.DefaultLinkTarget;
}
if (imageInfo.DefaultLinkOptions.ShowInNewWindow)
{
imageInfo.LinkOptions.ShowInNewWindow = true;
}
imageInfo.LinkOptions.UseImageViewer = imageInfo.DefaultLinkOptions.UseImageViewer;
imageInfo.LinkOptions.ImageViewerGroupName = imageInfo.DefaultLinkOptions.ImageViewerGroupName;
}
Size defaultImageSize = defaultImageSettings.GetDefaultInlineImageSize();
Size initialSize = ImageUtils.GetScaledImageSize(defaultImageSize.Width, defaultImageSize.Height, sourceImageSize);
// add to list of new images
newImages.Add(new NewImageInfo(imageInfo, imgElement, initialSize, disabledImageBehavior));
}
else
{
// When switching blogs, try to adapt image viewer settings according to the blog settings.
ImagePropertiesInfo imageInfo = new ImagePropertiesInfo(imageSrcUri, ImageUtils.GetImageSize(imageSrcUri.LocalPath), new ImageDecoratorsList(editor.DecoratorsManager, imageData.ImageDecoratorSettings));
imageInfo.ImgElement = imgElement;
// Make sure the new crop and tilt decorators get loaded
imageInfo.ImageDecorators.MergeDecorators(DefaultImageSettings.GetImplicitLocalImageDecorators());
string viewer = imageInfo.DhtmlImageViewer;
if (viewer != editorAccount.EditorOptions.DhtmlImageViewer)
{
imageInfo.DhtmlImageViewer = editorAccount.EditorOptions.DhtmlImageViewer;
imageInfo.LinkOptions = imageInfo.DefaultLinkOptions;
}
// If the image is an emoticon, update the EmoticonsManager with the image's uri so that duplicate emoticons can point to the same file.
if (emoticon != null)
{
editor.EmoticonsManager.SetInlineImageUri(emoticon, imageData.InlineImageFile.Uri);
}
}
}
catch (ArgumentException e)
{
Trace.WriteLine("Could not initialize image: " + imageSrc);
Trace.WriteLine(e.ToString());
}
catch (DirectoryNotFoundException)
{
Debug.WriteLine("Image file does not exist: " + imageSrc);
}
catch (FileNotFoundException)
{
Debug.WriteLine("Image file does not exist: " + imageSrc);
}
catch (IOException e)
{
Debug.WriteLine("Image file cannot be read: " + imageSrc + " " + e);
DisplayMessage.Show(MessageId.FileInUse, imageSrc);
}
}
}
}
}
return(newImages);
}
/// <summary>
/// Only edit tables that are not contained within SmartContent blocks and which
/// are marked with the "unselectable" attribute. Since this is an attribute which
/// applies only to editing scenarios it is almost certain never to enter the editor
/// "from the wild" so it is a reasonable way to determine whether we created the
/// table (and thus can guarantee that it conforms to our editing capabilities). The
/// only other reasonable choice would be to mark the table up with some other
/// pseudo-hidden metadata, which seems even more undesirable.
/// </summary>
public static bool TableElementIsEditable(IHTMLElement element)
{
return(TableElementContainsWriterEditingMark(element) &&
!ContentSourceManager.IsSmartContent(element));
}
public override void UpdateView(object htmlSelection, bool force)
{
if (htmlSelection == null) //true when the a non-smartcontent element is selected
{
//reset the selected smart content (fixes bug 492456)
_selectedElement = null;
_selectedSmartContentId = null;
UnloadCurrentEditor();
return;
}
Debug.Assert(htmlSelection is SmartContentSelection || (htmlSelection is IHtmlEditorSelection && InlineEditField.IsEditField(htmlSelection)));
IHTMLElement selectedElement = null;
SmartContentSelection smartContentSelection = htmlSelection as SmartContentSelection;
if (smartContentSelection != null && smartContentSelection.ContentState == SmartContentState.Enabled)
{
selectedElement = smartContentSelection.HTMLElement;
}
else if (htmlSelection is IHtmlEditorSelection)
{
selectedElement = ContentSourceManager.GetContainingSmartContent(
((IHtmlEditorSelection)(htmlSelection)).SelectedMarkupRange.ParentElement());
}
_currentSelection = htmlSelection;
if (selectedElement != null)
{
//if the selected element id is still the same, then the sidebar is currently
//in synch with the smart content.
//Note: the element id will change each time an edit is made to the smart content
if (!force && _selectedElement != null && _selectedSmartContentId != null && selectedElement.id == _selectedSmartContentId)
{
return;
}
else
{
_selectedElement = selectedElement;
_selectedSmartContentId = selectedElement.id;
if (_currentEditor != null)
{
UnloadCurrentEditor();
}
}
ContentSourceManager.ParseContainingElementId(_selectedElement.id, out _contentSourceId, out _contentItemId);
SmartContentEditor editor = (SmartContentEditor)_contentSourceControls[_contentSourceId];
ContentSourceInfo contentSource = _contentSourceContext.FindContentSource(_contentSourceId);
if (contentSource != null && contentSource.Instance is SmartContentSource)
{
_contentSource = (SmartContentSource)contentSource.Instance;
if (_editableSmartContent != null)
{
_editableSmartContent.Dispose();
}
_editableSmartContent = new EditableSmartContent(_contentSourceContext, _contentSource, _selectedElement);
if (editor == null)
{
editor = _contentSource.CreateEditor(this);
if (editor is IActiveSmartContentEditor)
{
((IActiveSmartContentEditor)editor).ForceContentEdited += new EventHandler(ContentSourceSidebarControl_ForceContentEdited);
}
//apply the current scale the new control
if (editor != null)
{
editor.Scale(new SizeF(scale.Width, scale.Height));
}
_contentSourceControls[_contentSourceId] = editor;
}
if (editor != null)
{
editor.ContentEdited += new EventHandler(_editor_ContentEdited);
editor.SelectedContent = _editableSmartContent;
EnableableSmartContentEditor enableableSmartContentEditor = editor as EnableableSmartContentEditor;
if (enableableSmartContentEditor != null)
{
enableableSmartContentEditor.ContentEnabled = true;
}
if (editor != _currentEditor)
{
if (enableableSmartContentEditor != null)
{
Controls.Clear();
}
else
{
//load the new editor
editor.Dock = DockStyle.Fill;
editor.Width = Width - DockPadding.Left - DockPadding.Right;
this.Controls.Add(editor);
}
// set the title caption
// Text = String.Format( CultureInfo.CurrentCulture, Res.Get(StringId.PluginSidebarTitle), contentSource.InsertableContentSourceSidebarText ) ;
}
}
}
_currentEditor = editor;
}
else
{
_currentEditor = null;
}
}
private bool IsSelectableControlElement(IHTMLElement e)
{
return(ElementFilters.IsImageElement(e) || ContentSourceManager.IsSmartContent(e));
}