From 9bdf130cc9ec64a09cfd84afb2566475ccdf1060 Mon Sep 17 00:00:00 2001 From: jtkech Date: Tue, 20 Oct 2015 05:40:01 +0200 Subject: [PATCH 01/30] Update WorkContextAccessor.cs --- .../Environment/WorkContextAccessor.cs | 40 +++++++------------ 1 file changed, 14 insertions(+), 26 deletions(-) diff --git a/src/Orchard/Environment/WorkContextAccessor.cs b/src/Orchard/Environment/WorkContextAccessor.cs index e572d21f6..f878f6689 100644 --- a/src/Orchard/Environment/WorkContextAccessor.cs +++ b/src/Orchard/Environment/WorkContextAccessor.cs @@ -1,6 +1,6 @@ -using System; -using System.Collections.Concurrent; +using System; using System.Collections.Generic; +using System.Runtime.Remoting.Messaging; using System.Web; using Autofac; using Orchard.Logging; @@ -16,9 +16,6 @@ namespace Orchard.Environment { // this guarantees the correct accessor is being resolved. readonly object _workContextKey = new object(); - [ThreadStatic] - static ConcurrentDictionary _threadStaticContexts; - public WorkContextAccessor( IHttpContextAccessor httpContextAccessor, ILifetimeScope lifetimeScope) { @@ -30,8 +27,7 @@ namespace Orchard.Environment { if (!httpContext.IsBackgroundContext()) return httpContext.Items[_workContextKey] as WorkContext; - WorkContext workContext; - return EnsureThreadStaticContexts().TryGetValue(_workContextKey, out workContext) ? workContext : null; + return CallContext.LogicalGetData("WorkContext") as WorkContext; } public WorkContext GetContext() { @@ -39,8 +35,7 @@ namespace Orchard.Environment { if (!httpContext.IsBackgroundContext()) return GetContext(httpContext); - WorkContext workContext; - return EnsureThreadStaticContexts().TryGetValue(_workContextKey, out workContext) ? workContext : null; + return CallContext.LogicalGetData("WorkContext") as WorkContext; } public IWorkContextScope CreateWorkContextScope(HttpContextBase httpContext) { @@ -57,7 +52,6 @@ namespace Orchard.Environment { _workContextKey); } - public IWorkContextScope CreateWorkContextScope() { var httpContext = _httpContextAccessor.Current(); if (!httpContext.IsBackgroundContext()) @@ -68,18 +62,9 @@ namespace Orchard.Environment { var events = workLifetime.Resolve>(); events.Invoke(e => e.Started(), NullLogger.Instance); - return new ThreadStaticScopeImplementation( - events, - workLifetime, - EnsureThreadStaticContexts(), - _workContextKey); + return new CallContextScopeImplementation(events, workLifetime); } - static ConcurrentDictionary EnsureThreadStaticContexts() { - return _threadStaticContexts ?? (_threadStaticContexts = new ConcurrentDictionary()); - } - - class HttpContextScopeImplementation : IWorkContextScope { readonly WorkContext _workContext; readonly Action _disposer; @@ -113,19 +98,22 @@ namespace Orchard.Environment { } } - class ThreadStaticScopeImplementation : IWorkContextScope { + class CallContextScopeImplementation : IWorkContextScope { readonly WorkContext _workContext; readonly Action _disposer; - public ThreadStaticScopeImplementation(IEnumerable events, ILifetimeScope lifetimeScope, ConcurrentDictionary contexts, object workContextKey) { + public CallContextScopeImplementation(IEnumerable events, ILifetimeScope lifetimeScope) { _workContext = lifetimeScope.Resolve(); - contexts.AddOrUpdate(workContextKey, _workContext, (a, b) => _workContext); + CallContext.LogicalSetData("WorkContext", _workContext); + + CallContext.LogicalSetData("HttpContext", null); + var httpContext = lifetimeScope.Resolve(); + CallContext.LogicalSetData("HttpContext", httpContext); _disposer = () => { events.Invoke(e => e.Finished(), NullLogger.Instance); - - WorkContext removedContext; - contexts.TryRemove(workContextKey, out removedContext); + CallContext.FreeNamedDataSlot("WorkContext"); + CallContext.FreeNamedDataSlot("HttpContext"); lifetimeScope.Dispose(); }; } From afd80a8c727256a99e499287a66208909e9d4a36 Mon Sep 17 00:00:00 2001 From: jtkech Date: Tue, 20 Oct 2015 05:44:28 +0200 Subject: [PATCH 02/30] Update HttpContextAccessor.cs --- src/Orchard/Mvc/HttpContextAccessor.cs | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/src/Orchard/Mvc/HttpContextAccessor.cs b/src/Orchard/Mvc/HttpContextAccessor.cs index b13d6fe25..f2e35cbab 100644 --- a/src/Orchard/Mvc/HttpContextAccessor.cs +++ b/src/Orchard/Mvc/HttpContextAccessor.cs @@ -1,13 +1,16 @@ -using System; +using System; +using System.Runtime.Remoting.Messaging; using System.Web; namespace Orchard.Mvc { + public class HttpContextAccessor : IHttpContextAccessor { private HttpContextBase _httpContext; public HttpContextBase Current() { var httpContext = GetStaticProperty(); - return !IsBackgroundHttpContext(httpContext) ? new HttpContextWrapper(httpContext) : _httpContext; + return !IsBackgroundHttpContext(httpContext) ? new HttpContextWrapper(httpContext) : + _httpContext ?? CallContext.LogicalGetData("HttpContext") as HttpContextBase; } public void Set(HttpContextBase httpContext) { @@ -15,7 +18,7 @@ namespace Orchard.Mvc { } private static bool IsBackgroundHttpContext(HttpContext httpContext) { - return httpContext == null || httpContext.Items.Contains(BackgroundHttpContextFactory.IsBackgroundHttpContextKey); + return httpContext == null || httpContext.Items.Contains(MvcModule.IsBackgroundHttpContextKey); } private static HttpContext GetStaticProperty() { @@ -36,4 +39,4 @@ namespace Orchard.Mvc { return httpContext; } } -} \ No newline at end of file +} From 0384c55011e18ec1fa912d697976ab9acf5aba5a Mon Sep 17 00:00:00 2001 From: jtkech Date: Tue, 20 Oct 2015 05:46:40 +0200 Subject: [PATCH 03/30] Update MvcModule.cs --- src/Orchard/Mvc/MvcModule.cs | 125 +++++++++++++++++++++++------------ 1 file changed, 83 insertions(+), 42 deletions(-) diff --git a/src/Orchard/Mvc/MvcModule.cs b/src/Orchard/Mvc/MvcModule.cs index 9b289749d..c90c6b804 100644 --- a/src/Orchard/Mvc/MvcModule.cs +++ b/src/Orchard/Mvc/MvcModule.cs @@ -1,20 +1,23 @@ -using System; +using System; using System.Collections; using System.Collections.Generic; using System.Collections.Specialized; using System.Globalization; +using System.IO; using System.Web; using System.Web.Caching; using System.Web.Instrumentation; using System.Web.Mvc; using System.Web.Routing; using Autofac; +using Orchard.Environment.Configuration; +using Orchard.Mvc.Extensions; using Orchard.Mvc.Routes; using Orchard.Settings; -using Orchard.Exceptions; namespace Orchard.Mvc { public class MvcModule : Module { + public const string IsBackgroundHttpContextKey = "IsBackgroundHttpContext"; protected override void Load(ContainerBuilder moduleBuilder) { moduleBuilder.RegisterType().InstancePerDependency(); @@ -24,37 +27,25 @@ namespace Orchard.Mvc { moduleBuilder.Register(UrlHelperFactory).As().InstancePerDependency(); } - private static bool IsRequestValid() { - if (HttpContext.Current == null) - return false; - - try { - // The "Request" property throws at application startup on IIS integrated pipeline mode. - var req = HttpContext.Current.Request; - } - catch (Exception ex) { - if (ex.IsFatal()) { - throw; - } - - return false; - } - - return true; - } - static HttpContextBase HttpContextBaseFactory(IComponentContext context) { - if (IsRequestValid()) { - return new HttpContextWrapper(HttpContext.Current); - } + + var httpContext = context.Resolve().Current(); + if (httpContext != null) + return httpContext; var siteService = context.Resolve(); + var prefix = context.Resolve().RequestUrlPrefix; // Wrapping the code accessing the SiteSettings in a function that will be executed later (in HttpContextPlaceholder), // so that the RequestContext will have been established when the time comes to actually load the site settings, // which requires activating the Site content item, which in turn requires a UrlHelper, which in turn requires a RequestContext, // thus preventing a StackOverflowException. - var baseUrl = new Func(() => siteService.GetSiteSettings().BaseUrl); + var baseUrl = new Func(() => { + var url = siteService.GetSiteSettings().BaseUrl; + return !string.IsNullOrWhiteSpace(url) ? !string.IsNullOrWhiteSpace(prefix) ? + url.TrimEnd('/') + "/" + prefix : url : "http://localhost" + + System.Web.Hosting.HostingEnvironment.ApplicationVirtualPath; + }); var httpContextBase = new HttpContextPlaceholder(baseUrl); return httpContextBase; @@ -63,7 +54,8 @@ namespace Orchard.Mvc { static RequestContext RequestContextFactory(IComponentContext context) { var httpContextAccessor = context.Resolve(); var httpContext = httpContextAccessor.Current(); - if (httpContext != null) { + + if (!httpContext.IsBackgroundContext()) { var mvcHandler = httpContext.Handler as MvcHandler; if (mvcHandler != null) { @@ -76,7 +68,11 @@ namespace Orchard.Mvc { return hasRequestContext.RequestContext; } } - else { + else if (httpContext is HttpContextPlaceholder) { + if (((HttpContextPlaceholder)httpContext).IsResolved) + return httpContext.Request.RequestContext; + } + else if (httpContext == null) { httpContext = HttpContextBaseFactory(context); } @@ -90,7 +86,8 @@ namespace Orchard.Mvc { /// /// Standin context for background tasks. /// - public class HttpContextPlaceholder : HttpContextBase { + public class HttpContextPlaceholder : HttpContextBase, IDisposable { + private HttpContext _httpContext; private readonly Lazy _baseUrl; private readonly IDictionary _items = new Dictionary(); @@ -98,8 +95,35 @@ namespace Orchard.Mvc { _baseUrl = new Lazy(baseUrl); } + public void Dispose() { + _httpContext = null; + if (HttpContext.Current != null) + HttpContext.Current = null; + } + + public bool IsResolved { + get { + return _baseUrl.IsValueCreated; + } + } + public override HttpRequestBase Request { - get { return new HttpRequestPlaceholder(new Uri(_baseUrl.Value)); } + get { + + if (_httpContext == null) { + var httpContext = new HttpContext(new HttpRequest("", _baseUrl.Value, ""), new HttpResponse(new StringWriter())); + httpContext.Items[IsBackgroundHttpContextKey] = true; + _httpContext = httpContext; + } + + if (HttpContext.Current != _httpContext) + HttpContext.Current = _httpContext; + return new HttpRequestPlaceholder(this, new Uri(_baseUrl.Value)); + } + } + + public override HttpSessionStateBase Session { + get { return new HttpSessionStatePlaceholder(); } } public override IHttpHandler Handler { get; set; } @@ -129,6 +153,14 @@ namespace Orchard.Mvc { } } + public class HttpSessionStatePlaceholder : HttpSessionStateBase { + public override object this[string name] { + get { + return null; + } + } + } + public class HttpResponsePlaceholder : HttpResponseBase { public override string ApplyAppPathModifier(string virtualPath) { return virtualPath; @@ -145,12 +177,32 @@ namespace Orchard.Mvc { /// standin context for background tasks. /// public class HttpRequestPlaceholder : HttpRequestBase { + private HttpContextBase _httpContext; private readonly Uri _uri; - public HttpRequestPlaceholder(Uri uri) { + public HttpRequestPlaceholder(HttpContextBase httpContext, Uri uri) { + _httpContext = httpContext; _uri = uri; } + public override RequestContext RequestContext { + get { + return new RequestContext(_httpContext, new RouteData()); + } + } + + public override NameValueCollection QueryString { + get { + return new NameValueCollection(); + } + } + + public override string RawUrl { + get { + return _uri.OriginalString; + } + } + /// /// anonymous identity provided for background task. /// @@ -158,17 +210,6 @@ namespace Orchard.Mvc { get { return false; } } - /// - /// Create an anonymous ID the same way as ASP.NET would. - /// Some users of an HttpRequestPlaceHolder object could expect this, - /// say CookieCultureSelector from module Orchard.CulturePicker. - /// - public override string AnonymousID { - get { - return Guid.NewGuid().ToString("D", CultureInfo.InvariantCulture); - } - } - // empty collection provided for background operation public override NameValueCollection Form { get { @@ -278,4 +319,4 @@ namespace Orchard.Mvc { public override int ScriptTimeout { get; set; } } } -} \ No newline at end of file +} From fbd0f878f5c058ff35caa37d5ebfe54d1b72e484 Mon Sep 17 00:00:00 2001 From: jtkech Date: Tue, 20 Oct 2015 05:56:27 +0200 Subject: [PATCH 04/30] Update MvcModule.cs --- src/Orchard/Mvc/MvcModule.cs | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/Orchard/Mvc/MvcModule.cs b/src/Orchard/Mvc/MvcModule.cs index c90c6b804..40d00287a 100644 --- a/src/Orchard/Mvc/MvcModule.cs +++ b/src/Orchard/Mvc/MvcModule.cs @@ -210,6 +210,17 @@ namespace Orchard.Mvc { get { return false; } } + /// + /// Create an anonymous ID the same way as ASP.NET would. + /// Some users of an HttpRequestPlaceHolder object could expect this, + /// say CookieCultureSelector from module Orchard.CulturePicker. + /// + public override string AnonymousID { + get { + return Guid.NewGuid().ToString("D", CultureInfo.InvariantCulture); + } + } + // empty collection provided for background operation public override NameValueCollection Form { get { From d2ef174479587a47c4f0be44d6ccaf678a3bb4dc Mon Sep 17 00:00:00 2001 From: jtkech Date: Tue, 20 Oct 2015 05:59:40 +0200 Subject: [PATCH 05/30] Update HttpContextBaseExtensions.cs --- src/Orchard/Mvc/Extensions/HttpContextBaseExtensions.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Orchard/Mvc/Extensions/HttpContextBaseExtensions.cs b/src/Orchard/Mvc/Extensions/HttpContextBaseExtensions.cs index 9a7864887..81fb1932f 100644 --- a/src/Orchard/Mvc/Extensions/HttpContextBaseExtensions.cs +++ b/src/Orchard/Mvc/Extensions/HttpContextBaseExtensions.cs @@ -1,4 +1,4 @@ -using System.Web; +using System.Web; namespace Orchard.Mvc.Extensions { public static class HttpContextBaseExtensions { From 348461d41f0f54fd8d710edb3a495b1ccba8db54 Mon Sep 17 00:00:00 2001 From: jtkech Date: Thu, 29 Oct 2015 00:24:44 +0100 Subject: [PATCH 06/30] Update MvcModule.cs --- src/Orchard/Mvc/MvcModule.cs | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/src/Orchard/Mvc/MvcModule.cs b/src/Orchard/Mvc/MvcModule.cs index 40d00287a..994e54952 100644 --- a/src/Orchard/Mvc/MvcModule.cs +++ b/src/Orchard/Mvc/MvcModule.cs @@ -10,7 +10,6 @@ using System.Web.Instrumentation; using System.Web.Mvc; using System.Web.Routing; using Autofac; -using Orchard.Environment.Configuration; using Orchard.Mvc.Extensions; using Orchard.Mvc.Routes; using Orchard.Settings; @@ -34,18 +33,12 @@ namespace Orchard.Mvc { return httpContext; var siteService = context.Resolve(); - var prefix = context.Resolve().RequestUrlPrefix; // Wrapping the code accessing the SiteSettings in a function that will be executed later (in HttpContextPlaceholder), // so that the RequestContext will have been established when the time comes to actually load the site settings, // which requires activating the Site content item, which in turn requires a UrlHelper, which in turn requires a RequestContext, // thus preventing a StackOverflowException. - var baseUrl = new Func(() => { - var url = siteService.GetSiteSettings().BaseUrl; - return !string.IsNullOrWhiteSpace(url) ? !string.IsNullOrWhiteSpace(prefix) ? - url.TrimEnd('/') + "/" + prefix : url : "http://localhost" - + System.Web.Hosting.HostingEnvironment.ApplicationVirtualPath; - }); + var baseUrl = new Func(() => siteService.GetSiteSettings().BaseUrl); var httpContextBase = new HttpContextPlaceholder(baseUrl); return httpContextBase; From a33471183fa13a3120627430a682e10ae8b89944 Mon Sep 17 00:00:00 2001 From: jtkech Date: Sun, 6 Dec 2015 05:18:48 +0100 Subject: [PATCH 07/30] Update MvcModule.cs --- src/Orchard/Mvc/MvcModule.cs | 78 ++++++++++++++++++++++++------------ 1 file changed, 52 insertions(+), 26 deletions(-) diff --git a/src/Orchard/Mvc/MvcModule.cs b/src/Orchard/Mvc/MvcModule.cs index 994e54952..ae873540a 100644 --- a/src/Orchard/Mvc/MvcModule.cs +++ b/src/Orchard/Mvc/MvcModule.cs @@ -38,6 +38,7 @@ namespace Orchard.Mvc { // so that the RequestContext will have been established when the time comes to actually load the site settings, // which requires activating the Site content item, which in turn requires a UrlHelper, which in turn requires a RequestContext, // thus preventing a StackOverflowException. + var baseUrl = new Func(() => siteService.GetSiteSettings().BaseUrl); var httpContextBase = new HttpContextPlaceholder(baseUrl); @@ -45,8 +46,8 @@ namespace Orchard.Mvc { } static RequestContext RequestContextFactory(IComponentContext context) { - var httpContextAccessor = context.Resolve(); - var httpContext = httpContextAccessor.Current(); + + var httpContext = HttpContextBaseFactory(context); if (!httpContext.IsBackgroundContext()) { @@ -62,11 +63,7 @@ namespace Orchard.Mvc { } } else if (httpContext is HttpContextPlaceholder) { - if (((HttpContextPlaceholder)httpContext).IsResolved) - return httpContext.Request.RequestContext; - } - else if (httpContext == null) { - httpContext = HttpContextBaseFactory(context); + return ((HttpContextPlaceholder)httpContext).RequestContext; } return new RequestContext(httpContext, new RouteData()); @@ -81,6 +78,7 @@ namespace Orchard.Mvc { /// public class HttpContextPlaceholder : HttpContextBase, IDisposable { private HttpContext _httpContext; + private HttpRequestPlaceholder _request; private readonly Lazy _baseUrl; private readonly IDictionary _items = new Dictionary(); @@ -93,16 +91,18 @@ namespace Orchard.Mvc { if (HttpContext.Current != null) HttpContext.Current = null; } - - public bool IsResolved { - get { - return _baseUrl.IsValueCreated; - } - } public override HttpRequestBase Request { - get { + // Note: To fully resolve the baseUrl, some factories are needed (HttpContextBase, RequestContext...), + // so, doing this in such a factory creates a circular dependency (see HttpContextBase factory comments). + + // When rendering a view in a background task, an Html Helper can access HttpContext.Current directly, + // so, here we create a fake HttpContext based on the baseUrl, and use it to update HttpContext.Current. + // We cannot do this before in a factory (see note above), anyway, by doing this on each Request access, + // we have a better chance to maintain the HttpContext.Current state even with some asynchronous code. + + get { if (_httpContext == null) { var httpContext = new HttpContext(new HttpRequest("", _baseUrl.Value, ""), new HttpResponse(new StringWriter())); httpContext.Items[IsBackgroundHttpContextKey] = true; @@ -111,7 +111,24 @@ namespace Orchard.Mvc { if (HttpContext.Current != _httpContext) HttpContext.Current = _httpContext; - return new HttpRequestPlaceholder(this, new Uri(_baseUrl.Value)); + + if (_request == null) { + _request = new HttpRequestPlaceholder(this, _baseUrl); + } + return _request; + } + } + + internal RequestContext RequestContext { + + // Uses the Request object but without creating an HttpContext which would need to resolve the baseUrl, + // so, can be used by the RequestContext factory without creating a circular dependency (see note above). + + get { + if (_request == null) { + _request = new HttpRequestPlaceholder(this, _baseUrl); + } + return _request.RequestContext; } } @@ -171,28 +188,34 @@ namespace Orchard.Mvc { /// public class HttpRequestPlaceholder : HttpRequestBase { private HttpContextBase _httpContext; - private readonly Uri _uri; + private RequestContext _requestContext; + private readonly Lazy _baseUrl; + private readonly NameValueCollection _queryString = new NameValueCollection(); + private Uri _uri; - public HttpRequestPlaceholder(HttpContextBase httpContext, Uri uri) { + public HttpRequestPlaceholder(HttpContextBase httpContext, Lazy baseUrl) { _httpContext = httpContext; - _uri = uri; + _baseUrl = baseUrl; } public override RequestContext RequestContext { get { - return new RequestContext(_httpContext, new RouteData()); + if (_requestContext == null) { + _requestContext = new RequestContext(_httpContext, new RouteData()); + } + return _requestContext; } } public override NameValueCollection QueryString { get { - return new NameValueCollection(); + return _queryString; } } public override string RawUrl { get { - return _uri.OriginalString; + return Url.OriginalString; } } @@ -223,13 +246,16 @@ namespace Orchard.Mvc { public override Uri Url { get { + if (_uri == null) { + _uri = new Uri(_baseUrl.Value); + } return _uri; } } public override NameValueCollection Headers { get { - return new NameValueCollection { { "Host", _uri.Authority } }; + return new NameValueCollection { { "Host", Url.Authority } }; } } @@ -253,16 +279,16 @@ namespace Orchard.Mvc { public override string ApplicationPath { get { - return _uri.LocalPath; + return Url.LocalPath; } } public override NameValueCollection ServerVariables { get { return new NameValueCollection { - { "SERVER_PORT", _uri.Port.ToString(CultureInfo.InvariantCulture) }, - { "HTTP_HOST", _uri.Authority.ToString(CultureInfo.InvariantCulture) }, - + { "SERVER_PORT", Url.Port.ToString(CultureInfo.InvariantCulture) }, + { "HTTP_HOST", Url.Authority.ToString(CultureInfo.InvariantCulture) }, + }; } } From f3b3e0a7fb4c19364060409fc9a812c689430ed8 Mon Sep 17 00:00:00 2001 From: jtkech Date: Tue, 8 Dec 2015 20:54:53 +0100 Subject: [PATCH 08/30] Update WorkContextAccessor.cs --- src/Orchard/Environment/WorkContextAccessor.cs | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/src/Orchard/Environment/WorkContextAccessor.cs b/src/Orchard/Environment/WorkContextAccessor.cs index f878f6689..e9f2fc4db 100644 --- a/src/Orchard/Environment/WorkContextAccessor.cs +++ b/src/Orchard/Environment/WorkContextAccessor.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using System.Runtime.Remoting; using System.Runtime.Remoting.Messaging; using System.Web; using Autofac; @@ -27,7 +28,8 @@ namespace Orchard.Environment { if (!httpContext.IsBackgroundContext()) return httpContext.Items[_workContextKey] as WorkContext; - return CallContext.LogicalGetData("WorkContext") as WorkContext; + var context = CallContext.LogicalGetData("WorkContext") as ObjectHandle; + return context != null ? context.Unwrap() as WorkContext : null; } public WorkContext GetContext() { @@ -35,7 +37,8 @@ namespace Orchard.Environment { if (!httpContext.IsBackgroundContext()) return GetContext(httpContext); - return CallContext.LogicalGetData("WorkContext") as WorkContext; + var context = CallContext.LogicalGetData("WorkContext") as ObjectHandle; + return context != null ? context.Unwrap() as WorkContext : null; } public IWorkContextScope CreateWorkContextScope(HttpContextBase httpContext) { @@ -104,11 +107,11 @@ namespace Orchard.Environment { public CallContextScopeImplementation(IEnumerable events, ILifetimeScope lifetimeScope) { _workContext = lifetimeScope.Resolve(); - CallContext.LogicalSetData("WorkContext", _workContext); + CallContext.LogicalSetData("WorkContext", new ObjectHandle(_workContext)); CallContext.LogicalSetData("HttpContext", null); var httpContext = lifetimeScope.Resolve(); - CallContext.LogicalSetData("HttpContext", httpContext); + CallContext.LogicalSetData("HttpContext", new ObjectHandle(httpContext)); _disposer = () => { events.Invoke(e => e.Finished(), NullLogger.Instance); From 9593155cb6eeed049c96d1eb633695bfd727d336 Mon Sep 17 00:00:00 2001 From: jtkech Date: Tue, 8 Dec 2015 20:56:20 +0100 Subject: [PATCH 09/30] Update HttpContextAccessor.cs --- src/Orchard/Mvc/HttpContextAccessor.cs | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/Orchard/Mvc/HttpContextAccessor.cs b/src/Orchard/Mvc/HttpContextAccessor.cs index f2e35cbab..bb1904df1 100644 --- a/src/Orchard/Mvc/HttpContextAccessor.cs +++ b/src/Orchard/Mvc/HttpContextAccessor.cs @@ -1,4 +1,5 @@ using System; +using System.Runtime.Remoting; using System.Runtime.Remoting.Messaging; using System.Web; @@ -9,8 +10,15 @@ namespace Orchard.Mvc { public HttpContextBase Current() { var httpContext = GetStaticProperty(); - return !IsBackgroundHttpContext(httpContext) ? new HttpContextWrapper(httpContext) : - _httpContext ?? CallContext.LogicalGetData("HttpContext") as HttpContextBase; + + if (!IsBackgroundHttpContext(httpContext)) + return new HttpContextWrapper(httpContext); + + if (_httpContext != null) + return _httpContext; + + var context = CallContext.LogicalGetData("HttpContext") as ObjectHandle; + return context != null ? context.Unwrap() as HttpContextBase : null; } public void Set(HttpContextBase httpContext) { From a7b4d8c6ca80761672113befe9c8ad48e1009449 Mon Sep 17 00:00:00 2001 From: jtkech Date: Fri, 11 Dec 2015 01:31:00 +0100 Subject: [PATCH 10/30] Update WorkContextAccessor.cs --- .../Environment/WorkContextAccessor.cs | 23 +++++++++++-------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/src/Orchard/Environment/WorkContextAccessor.cs b/src/Orchard/Environment/WorkContextAccessor.cs index e9f2fc4db..72380690c 100644 --- a/src/Orchard/Environment/WorkContextAccessor.cs +++ b/src/Orchard/Environment/WorkContextAccessor.cs @@ -16,19 +16,21 @@ namespace Orchard.Environment { // a different symbolic key is used for each tenant. // this guarantees the correct accessor is being resolved. readonly object _workContextKey = new object(); + private readonly string _workContextSlot; public WorkContextAccessor( IHttpContextAccessor httpContextAccessor, ILifetimeScope lifetimeScope) { _httpContextAccessor = httpContextAccessor; _lifetimeScope = lifetimeScope; + _workContextSlot = "WorkContext." + Guid.NewGuid().ToString("n"); } public WorkContext GetContext(HttpContextBase httpContext) { if (!httpContext.IsBackgroundContext()) return httpContext.Items[_workContextKey] as WorkContext; - var context = CallContext.LogicalGetData("WorkContext") as ObjectHandle; + var context = CallContext.LogicalGetData(_workContextSlot) as ObjectHandle; return context != null ? context.Unwrap() as WorkContext : null; } @@ -37,7 +39,7 @@ namespace Orchard.Environment { if (!httpContext.IsBackgroundContext()) return GetContext(httpContext); - var context = CallContext.LogicalGetData("WorkContext") as ObjectHandle; + var context = CallContext.LogicalGetData(_workContextSlot) as ObjectHandle; return context != null ? context.Unwrap() as WorkContext : null; } @@ -65,7 +67,7 @@ namespace Orchard.Environment { var events = workLifetime.Resolve>(); events.Invoke(e => e.Started(), NullLogger.Instance); - return new CallContextScopeImplementation(events, workLifetime); + return new CallContextScopeImplementation(events, workLifetime, _workContextSlot); } class HttpContextScopeImplementation : IWorkContextScope { @@ -105,18 +107,19 @@ namespace Orchard.Environment { readonly WorkContext _workContext; readonly Action _disposer; - public CallContextScopeImplementation(IEnumerable events, ILifetimeScope lifetimeScope) { - _workContext = lifetimeScope.Resolve(); - CallContext.LogicalSetData("WorkContext", new ObjectHandle(_workContext)); + public CallContextScopeImplementation(IEnumerable events, ILifetimeScope lifetimeScope, string workContextSlot) { - CallContext.LogicalSetData("HttpContext", null); + CallContext.LogicalSetData(workContextSlot, null); + + _workContext = lifetimeScope.Resolve(); var httpContext = lifetimeScope.Resolve(); - CallContext.LogicalSetData("HttpContext", new ObjectHandle(httpContext)); + _workContext.HttpContext = httpContext; + + CallContext.LogicalSetData(workContextSlot, new ObjectHandle(_workContext)); _disposer = () => { events.Invoke(e => e.Finished(), NullLogger.Instance); - CallContext.FreeNamedDataSlot("WorkContext"); - CallContext.FreeNamedDataSlot("HttpContext"); + CallContext.FreeNamedDataSlot(workContextSlot); lifetimeScope.Dispose(); }; } From d34eba4b99109c6db010c5799a730a1e986f6b65 Mon Sep 17 00:00:00 2001 From: jtkech Date: Fri, 11 Dec 2015 01:33:19 +0100 Subject: [PATCH 11/30] Update HttpContextAccessor.cs --- src/Orchard/Mvc/HttpContextAccessor.cs | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/src/Orchard/Mvc/HttpContextAccessor.cs b/src/Orchard/Mvc/HttpContextAccessor.cs index bb1904df1..826bec0ce 100644 --- a/src/Orchard/Mvc/HttpContextAccessor.cs +++ b/src/Orchard/Mvc/HttpContextAccessor.cs @@ -1,13 +1,16 @@ using System; -using System.Runtime.Remoting; -using System.Runtime.Remoting.Messaging; using System.Web; +using Autofac; namespace Orchard.Mvc { - public class HttpContextAccessor : IHttpContextAccessor { + readonly ILifetimeScope _lifetimeScope; private HttpContextBase _httpContext; + public HttpContextAccessor(ILifetimeScope lifetimeScope) { + _lifetimeScope = lifetimeScope; + } + public HttpContextBase Current() { var httpContext = GetStaticProperty(); @@ -17,8 +20,10 @@ namespace Orchard.Mvc { if (_httpContext != null) return _httpContext; - var context = CallContext.LogicalGetData("HttpContext") as ObjectHandle; - return context != null ? context.Unwrap() as HttpContextBase : null; + var workContext = _lifetimeScope.IsRegistered() ? + _lifetimeScope.Resolve().GetContext(null) : null; + + return workContext != null ? workContext.HttpContext : null; } public void Set(HttpContextBase httpContext) { From 095a22eb6eb5b9ef2f31db01832e3c866db58e36 Mon Sep 17 00:00:00 2001 From: jtkech Date: Fri, 11 Dec 2015 01:37:58 +0100 Subject: [PATCH 12/30] Update DefaultWorkContextAccessorTests.cs --- src/Orchard.Tests/Environment/DefaultWorkContextAccessorTests.cs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/Orchard.Tests/Environment/DefaultWorkContextAccessorTests.cs b/src/Orchard.Tests/Environment/DefaultWorkContextAccessorTests.cs index 27ab4873b..6725f4bd2 100644 --- a/src/Orchard.Tests/Environment/DefaultWorkContextAccessorTests.cs +++ b/src/Orchard.Tests/Environment/DefaultWorkContextAccessorTests.cs @@ -19,6 +19,7 @@ namespace Orchard.Tests.Environment { } protected override void Register(ContainerBuilder builder) { + builder.RegisterModule(new MvcModule()); builder.RegisterModule(new WorkContextModule()); builder.RegisterType().As(); builder.RegisterAutoMocking(); From e889288687495e216a4781efda561ac826454371 Mon Sep 17 00:00:00 2001 From: jtkech Date: Fri, 11 Dec 2015 01:39:35 +0100 Subject: [PATCH 13/30] Update DefaultShellContextFactoryTests.cs --- .../ShellBuilders/DefaultShellContextFactoryTests.cs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/Orchard.Tests/Environment/ShellBuilders/DefaultShellContextFactoryTests.cs b/src/Orchard.Tests/Environment/ShellBuilders/DefaultShellContextFactoryTests.cs index dc0b13a26..73d55e661 100644 --- a/src/Orchard.Tests/Environment/ShellBuilders/DefaultShellContextFactoryTests.cs +++ b/src/Orchard.Tests/Environment/ShellBuilders/DefaultShellContextFactoryTests.cs @@ -21,6 +21,7 @@ namespace Orchard.Tests.Environment.ShellBuilders { public void Init() { var builder = new ContainerBuilder(); builder.RegisterType().As(); + builder.RegisterModule(new MvcModule()); builder.RegisterModule(new WorkContextModule()); builder.RegisterType().As(); builder.RegisterAutoMocking(Moq.MockBehavior.Strict); @@ -93,4 +94,4 @@ namespace Orchard.Tests.Environment.ShellBuilders { Assert.That(context.Descriptor.Features, Has.Some.With.Property("Name").EqualTo("Orchard.Setup")); } } -} \ No newline at end of file +} From e72b8c4bed4eaec229aab7336cdb2df19f00eb35 Mon Sep 17 00:00:00 2001 From: jtkech Date: Fri, 11 Dec 2015 01:40:35 +0100 Subject: [PATCH 14/30] Update SweepGeneratorTests.cs --- src/Orchard.Tests/Tasks/SweepGeneratorTests.cs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/Orchard.Tests/Tasks/SweepGeneratorTests.cs b/src/Orchard.Tests/Tasks/SweepGeneratorTests.cs index 8e468800a..7f6cf6874 100644 --- a/src/Orchard.Tests/Tasks/SweepGeneratorTests.cs +++ b/src/Orchard.Tests/Tasks/SweepGeneratorTests.cs @@ -13,6 +13,7 @@ namespace Orchard.Tests.Tasks { public class SweepGeneratorTests : ContainerTestBase { protected override void Register(ContainerBuilder builder) { builder.RegisterAutoMocking(MockBehavior.Loose); + builder.RegisterModule(new MvcModule()); builder.RegisterModule(new WorkContextModule()); builder.RegisterType().As(); builder.RegisterType(); From b1b34e444a743741eeb911b4a7cc29855e74e13b Mon Sep 17 00:00:00 2001 From: Jwheuvel Date: Tue, 15 Dec 2015 09:34:57 +0100 Subject: [PATCH 15/30] All /lib dll files are now correctly taken into account when using git Changed the .gitignore so all /lib dependencies are included correctly. --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 4bdfee989..bb7b6a923 100644 --- a/.gitignore +++ b/.gitignore @@ -186,5 +186,6 @@ src/Orchard.Web/Properties/PublishProfiles src/Orchard.Azure/Orchard.Azure.CloudService/Staging/ #enable all /lib artifacts -!lib/*/*.* +!lib/**/*.* +!src/Orchard.Web/Modules/Orchard.Scripting.CSharp/Lib/*.* */.vs/* From 4fb1c18a7213ad3f09b3ac66ed43c15c0beefa6d Mon Sep 17 00:00:00 2001 From: Westley Harris Date: Tue, 15 Dec 2015 07:34:32 -0500 Subject: [PATCH 16/30] Update TaxonomyField.cshtml Re-submit of #6160. Fixed a bug in the taxonomy field editor template that allows you to click on "create some terms" for a non-existent taxonomy. This situation occurs when you assign a taxonomy field to a content type but do not specify a taxonomy. --- .../Views/EditorTemplates/Fields/TaxonomyField.cshtml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/Orchard.Web/Modules/Orchard.Taxonomies/Views/EditorTemplates/Fields/TaxonomyField.cshtml b/src/Orchard.Web/Modules/Orchard.Taxonomies/Views/EditorTemplates/Fields/TaxonomyField.cshtml index 717f1dd5a..bdd8b2678 100644 --- a/src/Orchard.Web/Modules/Orchard.Taxonomies/Views/EditorTemplates/Fields/TaxonomyField.cshtml +++ b/src/Orchard.Web/Modules/Orchard.Taxonomies/Views/EditorTemplates/Fields/TaxonomyField.cshtml @@ -42,7 +42,9 @@ } - @if (!Model.Terms.Any() && AuthorizedFor(Orchard.Taxonomies.Permissions.CreateTerm)) { + @if (Model.TaxonomyId == 0) { +

@T("Your haven't specified a taxonomy for {0}", Model.DisplayName)

+ }else if (!Model.Terms.Any() && AuthorizedFor(Orchard.Taxonomies.Permissions.CreateTerm)) {
@T("There are no terms defined for {0} yet.", Model.DisplayName) @T("Create some terms") From 67dd5abc31f7c796d032ad9965bdac6421ffdd2e Mon Sep 17 00:00:00 2001 From: Matt Varblow Date: Tue, 15 Dec 2015 16:07:34 -0500 Subject: [PATCH 17/30] Fixes #1978: Long-running Orchard commands crashed the command line due to expired leases on remote proxies for MarshalByRef parameters passed in cross-AppDomain calls. --- src/Orchard/Localization/LocalizedString.cs | 4 ++++ src/Orchard/Logging/OrchardLog4netLogger.cs | 4 ++++ src/Tools/Orchard/Host/CommandHost.cs | 24 ++++++++++++++++++- src/Tools/Orchard/Logger.cs | 5 ++++ src/Tools/Orchard/OrchardParameters.cs | 5 ++++ .../ResponseFiles/ResponseFileReader.cs | 5 ++++ 6 files changed, 46 insertions(+), 1 deletion(-) diff --git a/src/Orchard/Localization/LocalizedString.cs b/src/Orchard/Localization/LocalizedString.cs index 2b7024416..60bddd38b 100644 --- a/src/Orchard/Localization/LocalizedString.cs +++ b/src/Orchard/Localization/LocalizedString.cs @@ -78,5 +78,9 @@ namespace Orchard.Localization { return string.Equals(_localized, that._localized); } + public override object InitializeLifetimeService() { + // never expire the cross-AppDomain lease on this object + return null; + } } } diff --git a/src/Orchard/Logging/OrchardLog4netLogger.cs b/src/Orchard/Logging/OrchardLog4netLogger.cs index 34f52d21f..2e39b8f36 100644 --- a/src/Orchard/Logging/OrchardLog4netLogger.cs +++ b/src/Orchard/Logging/OrchardLog4netLogger.cs @@ -415,5 +415,9 @@ namespace Orchard.Logging { } } + public override object InitializeLifetimeService() { + // never expire the cross-AppDomain lease on this object + return null; + } } } \ No newline at end of file diff --git a/src/Tools/Orchard/Host/CommandHost.cs b/src/Tools/Orchard/Host/CommandHost.cs index 818e8aa6a..2e17ffd7b 100644 --- a/src/Tools/Orchard/Host/CommandHost.cs +++ b/src/Tools/Orchard/Host/CommandHost.cs @@ -2,6 +2,8 @@ using System.Collections.Generic; using System.IO; using System.Linq; +using System.Runtime.Remoting; +using System.Runtime.Remoting.Lifetime; using System.Security; using System.Web.Hosting; using Orchard.Parameters; @@ -32,28 +34,46 @@ namespace Orchard.Host { [SecurityCritical] public override object InitializeLifetimeService() { - // never expire the license + // never expire the cross-AppDomain lease on this object return null; } + private static void ExtendLifeTimeLeases(TextReader input, TextWriter output) { + // Orchard objects passed as parameters into this AppDomain should derive from MarshalByRefObject and have + // infinite lease timeouts by means of their InitializeLifetimeService overrides. For the input/output + // stream objects we approximate that behavior by immediately renewing the lease for 30 days. + ExtendLifeTimeLease(input); + ExtendLifeTimeLease(output); + } + + private static void ExtendLifeTimeLease(MarshalByRefObject obj) { + if (RemotingServices.IsObjectOutOfAppDomain(obj)) { + var lease = (ILease)RemotingServices.GetLifetimeService(obj); + lease.Renew(TimeSpan.FromDays(30)); + } + } + [SecuritySafeCritical] void IRegisteredObject.Stop(bool immediate) { HostingEnvironment.UnregisterObject(this); } public CommandReturnCodes StartSession(TextReader input, TextWriter output) { + ExtendLifeTimeLeases(input, output); _agent = CreateAgent(); return StartHost(_agent, input, output); } public void StopSession(TextReader input, TextWriter output) { if (_agent != null) { + ExtendLifeTimeLeases(input, output); StopHost(_agent, input, output); _agent = null; } } public CommandReturnCodes RunCommand(TextReader input, TextWriter output, Logger logger, OrchardParameters args) { + ExtendLifeTimeLeases(input, output); var agent = CreateAgent(); CommandReturnCodes result = (CommandReturnCodes)agent.GetType().GetMethod("RunSingleCommand").Invoke(agent, new object[] { input, @@ -66,6 +86,7 @@ namespace Orchard.Host { } public CommandReturnCodes RunCommandInSession(TextReader input, TextWriter output, Logger logger, OrchardParameters args) { + ExtendLifeTimeLeases(input, output); CommandReturnCodes result = (CommandReturnCodes)_agent.GetType().GetMethod("RunCommand").Invoke(_agent, new object[] { input, output, @@ -77,6 +98,7 @@ namespace Orchard.Host { } public CommandReturnCodes RunCommands(TextReader input, TextWriter output, Logger logger, IEnumerable responseLines) { + ExtendLifeTimeLeases(input, output); var agent = CreateAgent(); CommandReturnCodes result = StartHost(agent, input, output); diff --git a/src/Tools/Orchard/Logger.cs b/src/Tools/Orchard/Logger.cs index 759130101..d45124b6e 100644 --- a/src/Tools/Orchard/Logger.cs +++ b/src/Tools/Orchard/Logger.cs @@ -17,5 +17,10 @@ namespace Orchard { _output.WriteLine(format, args); } } + + public override object InitializeLifetimeService() { + // never expire the cross-AppDomain lease on this object + return null; + } } } diff --git a/src/Tools/Orchard/OrchardParameters.cs b/src/Tools/Orchard/OrchardParameters.cs index 3a5d74785..130c2265b 100644 --- a/src/Tools/Orchard/OrchardParameters.cs +++ b/src/Tools/Orchard/OrchardParameters.cs @@ -10,5 +10,10 @@ namespace Orchard { public IList Arguments { get; set; } public IList ResponseFiles { get; set; } public IDictionary Switches { get; set; } + + public override object InitializeLifetimeService() { + // never expire the cross-AppDomain lease on this object + return null; + } } } \ No newline at end of file diff --git a/src/Tools/Orchard/ResponseFiles/ResponseFileReader.cs b/src/Tools/Orchard/ResponseFiles/ResponseFileReader.cs index bb6a93804..d3329ba63 100644 --- a/src/Tools/Orchard/ResponseFiles/ResponseFileReader.cs +++ b/src/Tools/Orchard/ResponseFiles/ResponseFileReader.cs @@ -10,6 +10,11 @@ namespace Orchard.ResponseFiles { public string LineText { get; set; } public int LineNumber { get; set; } public string[] Args { get; set; } + + public override object InitializeLifetimeService() { + // never expire the cross-AppDomain lease on this object + return null; + } } public class ResponseFileReader { From 4362b00da17e0244838b96f4d9ae6643d1343091 Mon Sep 17 00:00:00 2001 From: Matt Varblow Date: Tue, 15 Dec 2015 16:09:24 -0500 Subject: [PATCH 18/30] Fixed indentation --- src/Tools/Orchard/Host/CommandHost.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Tools/Orchard/Host/CommandHost.cs b/src/Tools/Orchard/Host/CommandHost.cs index 2e17ffd7b..9ef6e29d6 100644 --- a/src/Tools/Orchard/Host/CommandHost.cs +++ b/src/Tools/Orchard/Host/CommandHost.cs @@ -34,7 +34,7 @@ namespace Orchard.Host { [SecurityCritical] public override object InitializeLifetimeService() { - // never expire the cross-AppDomain lease on this object + // never expire the cross-AppDomain lease on this object return null; } From e72e6fcb1f61e5882480d6aef2a38a21e51022aa Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Tue, 15 Dec 2015 22:35:29 +0100 Subject: [PATCH 19/30] Fixed layout editor javascript issue. As per the comments in https://github.com/OrchardCMS/Orchard/pull/6159, the issue was that the layout designer host has a dependency on the layout editor object, but the former would be created before the latter. This changeset moves the initialization code together in order to control the order in which what object is created first. --- .../Scripts/LayoutDesignerHost.js | 20 +++---------------- .../Views/EditorTemplates/LayoutEditor.cshtml | 14 ++++++++++++- 2 files changed, 16 insertions(+), 18 deletions(-) diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutDesignerHost.js b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutDesignerHost.js index 59d865c63..ab347d938 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutDesignerHost.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutDesignerHost.js @@ -1,9 +1,9 @@ (function ($) { - var LayoutDesignerHost = function (element) { + var LayoutDesignerHost = function (element, layoutEditor) { var self = this; this.element = element; this.element.data("layout-designer-host", this); - this.editor = window.layoutEditor; + this.editor = layoutEditor; this.isFormSubmitting = false; this.settings = { antiForgeryToken: self.element.data("anti-forgery-token"), @@ -120,20 +120,6 @@ // Export types. window.Orchard = window.Orchard || {}; window.Orchard.Layouts = window.Orchard.Layouts || {}; - window.Orchard.Layouts.LayoutEditorHost = window.Orchard.Layouts.LayoutEditorHost || {}; + window.Orchard.Layouts.LayoutDesignerHost = LayoutDesignerHost; - $(function () { - var host = new LayoutDesignerHost($(".layout-designer")); - $(".layout-designer").each(function (e) { - var designer = $(this); - var dialog = designer.find(".layout-editor-help-dialog"); - designer.find(".layout-editor-help-link").click(function (e) { - dialog.dialog({ - modal: true, - width: 840 - }); - e.preventDefault(); - }); - }); - }); })(jQuery); \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Views/EditorTemplates/LayoutEditor.cshtml b/src/Orchard.Web/Modules/Orchard.Layouts/Views/EditorTemplates/LayoutEditor.cshtml index ce5470d25..48bb3c63d 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Views/EditorTemplates/LayoutEditor.cshtml +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Views/EditorTemplates/LayoutEditor.cshtml @@ -42,8 +42,20 @@ jQuery(function () { var editorConfig = JSON.parse(LayoutEditor.decode("@Html.Raw(Url.Encode(Model.ConfigurationData))")); var editorCanvasData = JSON.parse(LayoutEditor.decode("@Html.Raw(Url.Encode(Model.Data))")); + var layoutEditor = window.layoutEditor = new LayoutEditor.Editor(editorConfig, editorCanvasData); - window.layoutEditor = new LayoutEditor.Editor(editorConfig, editorCanvasData); + var host = new window.Orchard.Layouts.LayoutDesignerHost($(".layout-designer"), layoutEditor); + $(".layout-designer").each(function (e) { + var designer = $(this); + var dialog = designer.find(".layout-editor-help-dialog"); + designer.find(".layout-editor-help-link").click(function (e) { + dialog.dialog({ + modal: true, + width: 840 + }); + e.preventDefault(); + }); + }); }); } From 83900802b7167c5398c54d8554cb7213770e9309 Mon Sep 17 00:00:00 2001 From: Piotr Szmyd Date: Wed, 16 Dec 2015 17:05:28 +0100 Subject: [PATCH 20/30] #6188: Using correct key when removing Redis cache entry. --- .../Modules/Orchard.Redis/Caching/RedisCacheStorageProvider.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Orchard.Web/Modules/Orchard.Redis/Caching/RedisCacheStorageProvider.cs b/src/Orchard.Web/Modules/Orchard.Redis/Caching/RedisCacheStorageProvider.cs index 1af97e04d..5f3c8896d 100644 --- a/src/Orchard.Web/Modules/Orchard.Redis/Caching/RedisCacheStorageProvider.cs +++ b/src/Orchard.Web/Modules/Orchard.Redis/Caching/RedisCacheStorageProvider.cs @@ -54,7 +54,7 @@ namespace Orchard.Redis.Caching { } public void Remove(string key) { - Database.KeyDelete(key); + Database.KeyDelete(GetLocalizedKey(key)); } public void Clear() { From 36c5f1070fcfc0145c3bf87d1166799669a28343 Mon Sep 17 00:00:00 2001 From: jtkech Date: Thu, 17 Dec 2015 00:23:12 +0100 Subject: [PATCH 21/30] Update Tokenizer.cs --- .../Modules/Orchard.Tokens/Implementation/Tokenizer.cs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/Orchard.Web/Modules/Orchard.Tokens/Implementation/Tokenizer.cs b/src/Orchard.Web/Modules/Orchard.Tokens/Implementation/Tokenizer.cs index 5a12b460d..683166ba5 100644 --- a/src/Orchard.Web/Modules/Orchard.Tokens/Implementation/Tokenizer.cs +++ b/src/Orchard.Web/Modules/Orchard.Tokens/Implementation/Tokenizer.cs @@ -53,7 +53,9 @@ namespace Orchard.Tokens.Implementation { var replacements = Evaluate(options.Predicate == null ? tokens : tokens.Where(options.Predicate), data); return replacements.Aggregate(tokenset.Item1, - (current, replacement) => current.Replace((hashMode ? "#{" : "{") + replacement.Key + "}", (options.Encoding ?? ReplaceOptions.NoEncode)(replacement.Key, replacement.Value))); + (current, replacement) => replacement.Value == null ? + current : current.Replace((hashMode ? "#{" : "{") + replacement.Key + "}", + (options.Encoding ?? ReplaceOptions.NoEncode)(replacement.Key, replacement.Value))); } private static Tuple> Parse(string text, bool hashMode) { @@ -111,4 +113,4 @@ namespace Orchard.Tokens.Implementation { } } -} \ No newline at end of file +} From 3e9259ab682d8638c906fd7320a4e440810e7d1c Mon Sep 17 00:00:00 2001 From: jtkech Date: Thu, 17 Dec 2015 03:22:26 +0100 Subject: [PATCH 22/30] Update DefaultLayerEvaluationService.cs --- .../Orchard.Widgets/Services/DefaultLayerEvaluationService.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Services/DefaultLayerEvaluationService.cs b/src/Orchard.Web/Modules/Orchard.Widgets/Services/DefaultLayerEvaluationService.cs index 55b4a0682..4f9633deb 100644 --- a/src/Orchard.Web/Modules/Orchard.Widgets/Services/DefaultLayerEvaluationService.cs +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Services/DefaultLayerEvaluationService.cs @@ -42,7 +42,7 @@ namespace Orchard.Widgets.Services{ // Once the Condition Engine is done: // Get Layers and filter by zone and rule // NOTE: .ForType("Layer") is faster than .Query() - var activeLayers = _orchardServices.ContentManager.Query().WithQueryHints(new QueryHints().ExpandParts()).ForType("Layer").List(); + var activeLayers = _orchardServices.ContentManager.Query().ForType("Layer").List(); var activeLayerIds = new List(); foreach (var activeLayer in activeLayers) { From 981c1cb0562204e085234e5b955dc7ad3d5cb64d Mon Sep 17 00:00:00 2001 From: jtkech Date: Thu, 17 Dec 2015 07:08:12 +0100 Subject: [PATCH 23/30] Update HttpContextAccessor.cs --- src/Orchard/Mvc/HttpContextAccessor.cs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/Orchard/Mvc/HttpContextAccessor.cs b/src/Orchard/Mvc/HttpContextAccessor.cs index 826bec0ce..0c5e3438a 100644 --- a/src/Orchard/Mvc/HttpContextAccessor.cs +++ b/src/Orchard/Mvc/HttpContextAccessor.cs @@ -6,6 +6,7 @@ namespace Orchard.Mvc { public class HttpContextAccessor : IHttpContextAccessor { readonly ILifetimeScope _lifetimeScope; private HttpContextBase _httpContext; + private IWorkContextAccessor _wca; public HttpContextAccessor(ILifetimeScope lifetimeScope) { _lifetimeScope = lifetimeScope; @@ -20,9 +21,10 @@ namespace Orchard.Mvc { if (_httpContext != null) return _httpContext; - var workContext = _lifetimeScope.IsRegistered() ? - _lifetimeScope.Resolve().GetContext(null) : null; + if (_wca == null && _lifetimeScope.IsRegistered()) + _wca = _lifetimeScope.Resolve(); + var workContext = _wca != null ? _wca.GetContext(null) : null; return workContext != null ? workContext.HttpContext : null; } From 2835a0db29fdb2bdb13cb880117f4a1731bb41b8 Mon Sep 17 00:00:00 2001 From: Lombiq Date: Sat, 19 Dec 2015 20:01:32 +0100 Subject: [PATCH 24/30] Creating helpers for settings based metadata scenarios to be used in migrations, fixes #4693 --- .../Modules/Orchard.Blogs/Migrations.cs | 9 ++- .../Orchard.Blogs/Orchard.Blogs.csproj | 4 ++ .../Orchard.DynamicForms/Migrations.cs | 16 +++-- .../Orchard.DynamicForms.csproj | 4 ++ .../Extensions/MetaDataExtensions.cs | 65 +++++++++++++++++++ .../Orchard.MediaLibrary/Migrations.cs | 30 ++------- .../Orchard.MediaLibrary.csproj | 1 + .../Modules/Orchard.Search/Migrations.cs | 5 +- .../Orchard.Search/Orchard.Search.csproj | 4 ++ .../Modules/Orchard.Tags/Migrations.cs | 4 +- .../Modules/Orchard.Tags/Orchard.Tags.csproj | 4 ++ .../Extensions/MetaDataExtensions.cs | 32 +++++++++ .../Modules/Orchard.Widgets/Migrations.cs | 5 +- .../Orchard.Widgets/Orchard.Widgets.csproj | 1 + 14 files changed, 140 insertions(+), 44 deletions(-) create mode 100644 src/Orchard.Web/Modules/Orchard.MediaLibrary/Extensions/MetaDataExtensions.cs create mode 100644 src/Orchard.Web/Modules/Orchard.Widgets/Extensions/MetaDataExtensions.cs diff --git a/src/Orchard.Web/Modules/Orchard.Blogs/Migrations.cs b/src/Orchard.Web/Modules/Orchard.Blogs/Migrations.cs index f9a7b674a..e4b00a464 100644 --- a/src/Orchard.Web/Modules/Orchard.Blogs/Migrations.cs +++ b/src/Orchard.Web/Modules/Orchard.Blogs/Migrations.cs @@ -68,9 +68,7 @@ namespace Orchard.Blogs { ContentDefinitionManager.AlterTypeDefinition("RecentBlogPosts", cfg => cfg .WithPart("RecentBlogPostsPart") - .WithPart("CommonPart") - .WithPart("WidgetPart") - .WithSetting("Stereotype", "Widget") + .AsWidgetWithIdentity() ); ContentDefinitionManager.AlterPartDefinition("BlogArchivesPart", part => part @@ -134,6 +132,11 @@ namespace Orchard.Blogs { } public int UpdateFrom6() { + ContentDefinitionManager.AlterTypeDefinition("RecentBlogPosts", + cfg => cfg + .WithPart("IdentityPart") + ); + ContentDefinitionManager.AlterTypeDefinition("BlogArchives", cfg => cfg .WithPart("IdentityPart") diff --git a/src/Orchard.Web/Modules/Orchard.Blogs/Orchard.Blogs.csproj b/src/Orchard.Web/Modules/Orchard.Blogs/Orchard.Blogs.csproj index 8eabc5568..31f5295d6 100644 --- a/src/Orchard.Web/Modules/Orchard.Blogs/Orchard.Blogs.csproj +++ b/src/Orchard.Web/Modules/Orchard.Blogs/Orchard.Blogs.csproj @@ -167,6 +167,10 @@ {f301ef7d-f19c-4d83-aa94-cb64f29c037d} Orchard.ContentPicker + + {194d3ccc-1153-474d-8176-fde8d7d0d0bd} + Orchard.Widgets + diff --git a/src/Orchard.Web/Modules/Orchard.DynamicForms/Migrations.cs b/src/Orchard.Web/Modules/Orchard.DynamicForms/Migrations.cs index 16acf01e1..cc20cd75a 100644 --- a/src/Orchard.Web/Modules/Orchard.DynamicForms/Migrations.cs +++ b/src/Orchard.Web/Modules/Orchard.DynamicForms/Migrations.cs @@ -56,15 +56,14 @@ namespace Orchard.DynamicForms { .Draftable()); ContentDefinitionManager.AlterTypeDefinition("FormWidget", type => type + .AsWidgetWithIdentity() + .WithPart("LayoutPart", p => p + .WithSetting("LayoutTypePartSettings.DefaultLayoutData", DefaultFormLayoutData)) .WithPart("CommonPart", p => p .WithSetting("OwnerEditorSettings.ShowOwnerEditor", "false") .WithSetting("DateEditorSettings.ShowDateEditor", "false")) - .WithPart("WidgetPart") - .WithPart("LayoutPart", p => p - .WithSetting("LayoutTypePartSettings.DefaultLayoutData", DefaultFormLayoutData)) - .WithSetting("Stereotype", "Widget") .DisplayedAs("Form Widget")); - return 2; + return 3; } public int UpdateFrom1() { @@ -107,6 +106,13 @@ namespace Orchard.DynamicForms { return 2; } + public int UpdateFrom2() { + ContentDefinitionManager.AlterTypeDefinition("FormWidget", type => type + .WithPart("IdentityPart")); + + return 3; + } + private byte[] GetMD5(string text) { byte[] encodedText = System.Text.Encoding.UTF8.GetBytes(text); return ((HashAlgorithm)CryptoConfig.CreateFromName("MD5")).ComputeHash(encodedText); diff --git a/src/Orchard.Web/Modules/Orchard.DynamicForms/Orchard.DynamicForms.csproj b/src/Orchard.Web/Modules/Orchard.DynamicForms/Orchard.DynamicForms.csproj index f81446fb4..31d0071b5 100644 --- a/src/Orchard.Web/Modules/Orchard.DynamicForms/Orchard.DynamicForms.csproj +++ b/src/Orchard.Web/Modules/Orchard.DynamicForms/Orchard.DynamicForms.csproj @@ -154,6 +154,10 @@ {79aed36e-abd0-4747-93d3-8722b042454b} Orchard.Users + + {194d3ccc-1153-474d-8176-fde8d7d0d0bd} + Orchard.Widgets + {7059493c-8251-4764-9c1e-2368b8b485bc} Orchard.Workflows diff --git a/src/Orchard.Web/Modules/Orchard.MediaLibrary/Extensions/MetaDataExtensions.cs b/src/Orchard.Web/Modules/Orchard.MediaLibrary/Extensions/MetaDataExtensions.cs new file mode 100644 index 000000000..154150808 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.MediaLibrary/Extensions/MetaDataExtensions.cs @@ -0,0 +1,65 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Web; +using Orchard.ContentManagement.MetaData.Builders; + +namespace Orchard.ContentManagement.MetaData { + public static class MetaDataExtensions { + /// + /// This extension method can be used for easy image part creation. Adds all necessary parts and settings to the part. + /// + public static ContentTypeDefinitionBuilder AsImage(this ContentTypeDefinitionBuilder builder) { + return builder + .AsMedia() + .WithPart("ImagePart"); + } + + /// + /// This extension method can be used for easy vector image part creation. Adds all necessary parts and settings to the part. + /// + public static ContentTypeDefinitionBuilder AsVectorImage(this ContentTypeDefinitionBuilder builder) { + return builder + .AsMedia() + .WithPart("VectorImagePart"); + } + + /// + /// This extension method can be used for easy audio part creation. Adds all necessary parts and settings to the part. + /// + public static ContentTypeDefinitionBuilder AsAudio(this ContentTypeDefinitionBuilder builder) { + return builder + .AsMedia() + .WithPart("AudioPart"); + } + + /// + /// This extension method can be used for video image part creation. Adds all necessary parts and settings to the part. + /// + public static ContentTypeDefinitionBuilder AsVideo(this ContentTypeDefinitionBuilder builder) { + return builder + .AsMedia() + .WithPart("VideoPart"); + } + + /// + /// This extension method can be used for easy document part creation. Adds all necessary parts and settings to the part. + /// + public static ContentTypeDefinitionBuilder AsDocument(this ContentTypeDefinitionBuilder builder) { + return builder + .AsMedia() + .WithPart("DocumentPart"); + } + + /// + /// This extension method can be used for easy media part creation. Adds all necessary parts and settings to the part. + /// + public static ContentTypeDefinitionBuilder AsMedia(this ContentTypeDefinitionBuilder builder) { + return builder + .WithSetting("Stereotype", "Media") + .WithPart("CommonPart") + .WithPart("MediaPart") + .WithPart("TitlePart"); + } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.MediaLibrary/Migrations.cs b/src/Orchard.Web/Modules/Orchard.MediaLibrary/Migrations.cs index f231d8125..8a6be0d4c 100644 --- a/src/Orchard.Web/Modules/Orchard.MediaLibrary/Migrations.cs +++ b/src/Orchard.Web/Modules/Orchard.MediaLibrary/Migrations.cs @@ -57,57 +57,37 @@ namespace Orchard.MediaLibrary { ContentDefinitionManager.AlterTypeDefinition("Image", td => td .DisplayedAs("Image") - .WithSetting("Stereotype", "Media") .WithSetting("MediaFileNameEditorSettings.ShowFileNameEditor", "True") + .AsImage() .WithPart("IdentityPart") - .WithPart("CommonPart") - .WithPart("MediaPart") - .WithPart("ImagePart") - .WithPart("TitlePart") ); ContentDefinitionManager.AlterTypeDefinition("VectorImage", td => td .DisplayedAs("Vector Image") - .WithSetting("Stereotype", "Media") .WithSetting("MediaFileNameEditorSettings.ShowFileNameEditor", "True") + .AsVectorImage() .WithPart("IdentityPart") - .WithPart("CommonPart") - .WithPart("MediaPart") - .WithPart("VectorImagePart") - .WithPart("TitlePart") ); ContentDefinitionManager.AlterTypeDefinition("Video", td => td .DisplayedAs("Video") - .WithSetting("Stereotype", "Media") .WithSetting("MediaFileNameEditorSettings.ShowFileNameEditor", "True") + .AsVideo() .WithPart("IdentityPart") - .WithPart("CommonPart") - .WithPart("MediaPart") - .WithPart("VideoPart") - .WithPart("TitlePart") ); ContentDefinitionManager.AlterTypeDefinition("Audio", td => td .DisplayedAs("Audio") - .WithSetting("Stereotype", "Media") .WithSetting("MediaFileNameEditorSettings.ShowFileNameEditor", "True") + .AsAudio() .WithPart("IdentityPart") - .WithPart("CommonPart") - .WithPart("MediaPart") - .WithPart("AudioPart") - .WithPart("TitlePart") ); ContentDefinitionManager.AlterTypeDefinition("Document", td => td .DisplayedAs("Document") - .WithSetting("Stereotype", "Media") .WithSetting("MediaFileNameEditorSettings.ShowFileNameEditor", "True") + .AsDocument() .WithPart("IdentityPart") - .WithPart("CommonPart") - .WithPart("MediaPart") - .WithPart("DocumentPart") - .WithPart("TitlePart") ); ContentDefinitionManager.AlterTypeDefinition("OEmbed", td => td diff --git a/src/Orchard.Web/Modules/Orchard.MediaLibrary/Orchard.MediaLibrary.csproj b/src/Orchard.Web/Modules/Orchard.MediaLibrary/Orchard.MediaLibrary.csproj index 788aa1a3a..dac14d392 100644 --- a/src/Orchard.Web/Modules/Orchard.MediaLibrary/Orchard.MediaLibrary.csproj +++ b/src/Orchard.Web/Modules/Orchard.MediaLibrary/Orchard.MediaLibrary.csproj @@ -101,6 +101,7 @@ + diff --git a/src/Orchard.Web/Modules/Orchard.Search/Migrations.cs b/src/Orchard.Web/Modules/Orchard.Search/Migrations.cs index a8634d9a5..abd815677 100644 --- a/src/Orchard.Web/Modules/Orchard.Search/Migrations.cs +++ b/src/Orchard.Web/Modules/Orchard.Search/Migrations.cs @@ -11,10 +11,7 @@ namespace Orchard.Search { ContentDefinitionManager.AlterTypeDefinition("SearchForm", cfg => cfg .WithPart("SearchFormPart") - .WithPart("CommonPart") - .WithPart("WidgetPart") - .WithPart("IdentityPart") - .WithSetting("Stereotype", "Widget") + .AsWidgetWithIdentity() ); return 3; diff --git a/src/Orchard.Web/Modules/Orchard.Search/Orchard.Search.csproj b/src/Orchard.Web/Modules/Orchard.Search/Orchard.Search.csproj index c001741b9..17359f424 100644 --- a/src/Orchard.Web/Modules/Orchard.Search/Orchard.Search.csproj +++ b/src/Orchard.Web/Modules/Orchard.Search/Orchard.Search.csproj @@ -105,6 +105,10 @@ {73a7688a-5bd3-4f7e-adfa-ce36c5a10e3b} Orchard.MediaLibrary + + {194d3ccc-1153-474d-8176-fde8d7d0d0bd} + Orchard.Widgets + diff --git a/src/Orchard.Web/Modules/Orchard.Tags/Migrations.cs b/src/Orchard.Web/Modules/Orchard.Tags/Migrations.cs index 9cbbf25f7..a14a0fd54 100644 --- a/src/Orchard.Web/Modules/Orchard.Tags/Migrations.cs +++ b/src/Orchard.Web/Modules/Orchard.Tags/Migrations.cs @@ -47,9 +47,7 @@ namespace Orchard.Tags { "TagCloud", cfg => cfg .WithPart("TagCloudPart") - .WithPart("CommonPart") - .WithPart("WidgetPart") - .WithSetting("Stereotype", "Widget") + .AsWidget() ); return 1; diff --git a/src/Orchard.Web/Modules/Orchard.Tags/Orchard.Tags.csproj b/src/Orchard.Web/Modules/Orchard.Tags/Orchard.Tags.csproj index c49663fbf..d2ebbd3ba 100644 --- a/src/Orchard.Web/Modules/Orchard.Tags/Orchard.Tags.csproj +++ b/src/Orchard.Web/Modules/Orchard.Tags/Orchard.Tags.csproj @@ -135,6 +135,10 @@ {66FCCD76-2761-47E3-8D11-B45D0001DDAA} Orchard.Autoroute + + {194d3ccc-1153-474d-8176-fde8d7d0d0bd} + Orchard.Widgets + diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Extensions/MetaDataExtensions.cs b/src/Orchard.Web/Modules/Orchard.Widgets/Extensions/MetaDataExtensions.cs new file mode 100644 index 000000000..720ace53a --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Extensions/MetaDataExtensions.cs @@ -0,0 +1,32 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Web; +using Orchard.ContentManagement.MetaData.Builders; + +namespace Orchard.ContentManagement.MetaData { + public static class MetaDataExtensions { + /// + /// This extension method can be used for easy widget creation. Adds all necessary parts and settings to the part. + /// + /// The ContentTypeDefinitionBuilder object on which this method is called. + public static ContentTypeDefinitionBuilder AsWidget(this ContentTypeDefinitionBuilder builder) { + return builder + .WithPart("CommonPart") + .WithPart("WidgetPart") + .WithSetting("Stereotype", "Widget"); + } + + /// + /// This extension method can be used for easy widget creation. Adds all necessary parts and settings to the part. And adds IdentityPart too. + /// + /// The ContentTypeDefinitionBuilder object on which this method is called. + public static ContentTypeDefinitionBuilder AsWidgetWithIdentity(this ContentTypeDefinitionBuilder builder) { + return builder + .WithPart("CommonPart") + .WithPart("WidgetPart") + .WithPart("IdentityPart") + .WithSetting("Stereotype", "Widget"); + } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Migrations.cs b/src/Orchard.Web/Modules/Orchard.Widgets/Migrations.cs index acf0be706..c1f2b91b0 100644 --- a/src/Orchard.Web/Modules/Orchard.Widgets/Migrations.cs +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Migrations.cs @@ -36,11 +36,8 @@ namespace Orchard.Widgets { ContentDefinitionManager.AlterTypeDefinition("HtmlWidget", cfg => cfg - .WithPart("WidgetPart") .WithPart("BodyPart") - .WithPart("CommonPart") - .WithPart("IdentityPart") - .WithSetting("Stereotype", "Widget") + .AsWidgetWithIdentity() ); return 5; diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Orchard.Widgets.csproj b/src/Orchard.Web/Modules/Orchard.Widgets/Orchard.Widgets.csproj index c2ba01fe1..8770c9dca 100644 --- a/src/Orchard.Web/Modules/Orchard.Widgets/Orchard.Widgets.csproj +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Orchard.Widgets.csproj @@ -72,6 +72,7 @@ + From c216480ca0662ec0e492c0ab61fb339be987fefe Mon Sep 17 00:00:00 2001 From: Lombiq Date: Sat, 19 Dec 2015 20:49:13 +0100 Subject: [PATCH 25/30] Adding the ability to specify tokenized default values for content fields, fixes #5934 And also fixing build error. *Shame!* --- .../Core/Common/Drivers/TextFieldDriver.cs | 9 +++++- .../Core/Common/Settings/TextFieldSettings.cs | 1 + .../Settings/TextFieldSettingsEvents.cs | 1 + .../TextFieldDefaultValueEditor.cshtml | 8 +++++ .../TextFieldSettingsEventsViewModel.cshtml | 3 ++ .../Fields.Common.Text.Edit.cshtml | 5 +++- src/Orchard.Web/Core/Orchard.Core.csproj | 3 ++ src/Orchard.Web/Core/Shapes/CoreShapes.cs | 5 ++++ .../Drivers/DateTimeFieldDriver.cs | 16 +++++----- .../Drivers/EnumerationFieldDriver.cs | 19 ++++++++++-- .../Drivers/InputFieldDriver.cs | 15 +++++++--- .../Orchard.Fields/Drivers/LinkFieldDriver.cs | 19 ++++++++++-- .../Drivers/NumericFieldDriver.cs | 26 ++++++++++++----- .../Orchard.Fields/Drivers/TextFieldDriver.cs | 29 +++++++++++++++++++ .../Modules/Orchard.Fields/Module.txt | 2 +- .../Orchard.Fields/Orchard.Fields.csproj | 8 +++++ .../Settings/DateTimeFieldEditorEvents.cs | 22 ++++++++++++-- .../Settings/DateTimeFieldSettings.cs | 7 ++++- .../Settings/EnumerationFieldEditorEvents.cs | 7 +++-- .../Settings/EnumerationFieldSettings.cs | 1 + .../Settings/InputFieldEditorEvents.cs | 6 ++-- .../Settings/InputFieldSettings.cs | 1 + .../Settings/LinkFieldEditorEvents.cs | 10 ++++--- .../Settings/LinkFieldSettings.cs | 2 ++ .../Settings/NumericFieldEditorEvents.cs | 7 +++-- .../Settings/NumericFieldSettings.cs | 1 + .../ViewModels/DateTimeFieldViewModel.cs | 1 + .../DateTimeFieldSettings.cshtml | 9 ++++++ .../EnumerationFieldSettings.cshtml | 8 +++++ .../InputFieldSettings.cshtml | 8 +++++ .../LinkFieldSettings.cshtml | 16 ++++++++++ .../NumericFieldSettings.cshtml | 8 +++++ .../TextFieldDefaultValueEditor.cshtml | 7 +++++ .../Fields/DateTime.Edit.cshtml | 3 ++ .../EditorTemplates/Fields/Input.Edit.cshtml | 3 ++ .../EditorTemplates/Fields/Link.Edit.cshtml | 12 ++++++-- .../Fields/Numeric.Edit.cshtml | 3 ++ ...tensions.cs => MediaMetaDataExtensions.cs} | 2 +- .../Orchard.MediaLibrary.csproj | 2 +- ...nsions.cs => WidgetsMetaDataExtensions.cs} | 2 +- .../Orchard.Widgets/Orchard.Widgets.csproj | 2 +- 41 files changed, 269 insertions(+), 50 deletions(-) create mode 100644 src/Orchard.Web/Core/Common/Views/DefinitionTemplates/TextFieldDefaultValueEditor.cshtml create mode 100644 src/Orchard.Web/Modules/Orchard.Fields/Drivers/TextFieldDriver.cs create mode 100644 src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/TextFieldDefaultValueEditor.cshtml rename src/Orchard.Web/Modules/Orchard.MediaLibrary/Extensions/{MetaDataExtensions.cs => MediaMetaDataExtensions.cs} (98%) rename src/Orchard.Web/Modules/Orchard.Widgets/Extensions/{MetaDataExtensions.cs => WidgetsMetaDataExtensions.cs} (96%) diff --git a/src/Orchard.Web/Core/Common/Drivers/TextFieldDriver.cs b/src/Orchard.Web/Core/Common/Drivers/TextFieldDriver.cs index f64f9c3f1..e7b72def7 100644 --- a/src/Orchard.Web/Core/Common/Drivers/TextFieldDriver.cs +++ b/src/Orchard.Web/Core/Common/Drivers/TextFieldDriver.cs @@ -72,7 +72,14 @@ namespace Orchard.Core.Common.Drivers { () => shapeHelper.EditorTemplate(TemplateName: "Fields.Common.Text.Edit", Model: viewModel, Prefix: GetPrefix(field, part))); } - field.Value = viewModel.Text; + var settings = field.PartFieldDefinition.Settings.GetModel(); + + if (String.IsNullOrEmpty(field.Value) && !String.IsNullOrEmpty(settings.DefaultValue)) { + field.Value = settings.DefaultValue; + } + else { + field.Value = viewModel.Text; + } } return Editor(part, field, shapeHelper); diff --git a/src/Orchard.Web/Core/Common/Settings/TextFieldSettings.cs b/src/Orchard.Web/Core/Common/Settings/TextFieldSettings.cs index 9b0b8d11d..651d1eb28 100644 --- a/src/Orchard.Web/Core/Common/Settings/TextFieldSettings.cs +++ b/src/Orchard.Web/Core/Common/Settings/TextFieldSettings.cs @@ -7,5 +7,6 @@ namespace Orchard.Core.Common.Settings { public string Flavor { get; set; } public bool Required { get; set; } public string Hint { get; set; } + public string DefaultValue { get; set; } } } diff --git a/src/Orchard.Web/Core/Common/Settings/TextFieldSettingsEvents.cs b/src/Orchard.Web/Core/Common/Settings/TextFieldSettingsEvents.cs index f9a35f5c8..9ae678cb9 100644 --- a/src/Orchard.Web/Core/Common/Settings/TextFieldSettingsEvents.cs +++ b/src/Orchard.Web/Core/Common/Settings/TextFieldSettingsEvents.cs @@ -33,6 +33,7 @@ namespace Orchard.Core.Common.Settings { builder.WithSetting("TextFieldSettings.Flavor", model.Settings.Flavor); builder.WithSetting("TextFieldSettings.Hint", model.Settings.Hint); builder.WithSetting("TextFieldSettings.Required", model.Settings.Required.ToString(CultureInfo.InvariantCulture)); + builder.WithSetting("TextFieldSettings.DefaultValue", model.Settings.DefaultValue); yield return DefinitionTemplate(model); } diff --git a/src/Orchard.Web/Core/Common/Views/DefinitionTemplates/TextFieldDefaultValueEditor.cshtml b/src/Orchard.Web/Core/Common/Views/DefinitionTemplates/TextFieldDefaultValueEditor.cshtml new file mode 100644 index 000000000..bbd84d350 --- /dev/null +++ b/src/Orchard.Web/Core/Common/Views/DefinitionTemplates/TextFieldDefaultValueEditor.cshtml @@ -0,0 +1,8 @@ +@model Orchard.Core.Common.ViewModels.TextFieldSettingsEventsViewModel + +@* This is a token-less default value editor that can be overridden from features that can depend on Orchard.Tokens. *@ + + +@Html.TextBoxFor(m => m.Settings.DefaultValue, new { @class = "text large" }) +@T("Default value for the field. If there is no value given for the actual field, this will be filled in. (optional)") +@Html.ValidationMessageFor(m => m.Settings.DefaultValue) \ No newline at end of file diff --git a/src/Orchard.Web/Core/Common/Views/DefinitionTemplates/TextFieldSettingsEventsViewModel.cshtml b/src/Orchard.Web/Core/Common/Views/DefinitionTemplates/TextFieldSettingsEventsViewModel.cshtml index ac37910c3..c339727a9 100644 --- a/src/Orchard.Web/Core/Common/Views/DefinitionTemplates/TextFieldSettingsEventsViewModel.cshtml +++ b/src/Orchard.Web/Core/Common/Views/DefinitionTemplates/TextFieldSettingsEventsViewModel.cshtml @@ -18,4 +18,7 @@ @Html.TextAreaFor(m => m.Settings.Hint, new { @class = "text medium", rows = "5" }) @T("The help text is written under the field when authors are editing the content item.") @Html.ValidationMessageFor(m => m.Settings.Hint) + +
+ @Display.DefinitionTemplate(TemplateName: "TextFieldDefaultValueEditor", Model: Model)
\ No newline at end of file diff --git a/src/Orchard.Web/Core/Common/Views/EditorTemplates/Fields.Common.Text.Edit.cshtml b/src/Orchard.Web/Core/Common/Views/EditorTemplates/Fields.Common.Text.Edit.cshtml index 165e7bc8c..de76c21bb 100644 --- a/src/Orchard.Web/Core/Common/Views/EditorTemplates/Fields.Common.Text.Edit.cshtml +++ b/src/Orchard.Web/Core/Common/Views/EditorTemplates/Fields.Common.Text.Edit.cshtml @@ -12,4 +12,7 @@ @if (HasText(Model.Settings.Hint)) { @Model.Settings.Hint } - + @if (!String.IsNullOrWhiteSpace(Model.Settings.DefaultValue)) { + @T("If the field is left empty then the default value will be used.") + } + \ No newline at end of file diff --git a/src/Orchard.Web/Core/Orchard.Core.csproj b/src/Orchard.Web/Core/Orchard.Core.csproj index d529085ee..36cbc19b0 100644 --- a/src/Orchard.Web/Core/Orchard.Core.csproj +++ b/src/Orchard.Web/Core/Orchard.Core.csproj @@ -578,6 +578,9 @@ + + + 10.0 $(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion) diff --git a/src/Orchard.Web/Core/Shapes/CoreShapes.cs b/src/Orchard.Web/Core/Shapes/CoreShapes.cs index 5fd5858eb..ab8ae8873 100644 --- a/src/Orchard.Web/Core/Shapes/CoreShapes.cs +++ b/src/Orchard.Web/Core/Shapes/CoreShapes.cs @@ -799,6 +799,11 @@ namespace Orchard.Core.Shapes { RenderInternal(Html, Output, "EditorTemplates/" + TemplateName, Model, Prefix); } + [Shape] + public void DefinitionTemplate(HtmlHelper Html, TextWriter Output, string TemplateName, object Model, string Prefix) { + RenderInternal(Html, Output, "DefinitionTemplates/" + TemplateName, Model, Prefix); + } + static void RenderInternal(HtmlHelper Html, TextWriter Output, string TemplateName, object Model, string Prefix) { var adjustedViewData = new ViewDataDictionary(Html.ViewDataContainer.ViewData) { Model = DetermineModel(Html, Model), diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Drivers/DateTimeFieldDriver.cs b/src/Orchard.Web/Modules/Orchard.Fields/Drivers/DateTimeFieldDriver.cs index 236822ddc..290f1a1e7 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Drivers/DateTimeFieldDriver.cs +++ b/src/Orchard.Web/Modules/Orchard.Fields/Drivers/DateTimeFieldDriver.cs @@ -1,16 +1,15 @@ -using System; -using System.Globalization; -using System.Xml; -using Orchard.ContentManagement; +using Orchard.ContentManagement; using Orchard.ContentManagement.Drivers; +using Orchard.ContentManagement.Handlers; +using Orchard.Core.Common.ViewModels; using Orchard.Fields.Fields; using Orchard.Fields.Settings; using Orchard.Fields.ViewModels; -using Orchard.ContentManagement.Handlers; using Orchard.Localization; -using Orchard.Localization.Services; -using Orchard.Core.Common.ViewModels; using Orchard.Localization.Models; +using Orchard.Localization.Services; +using System; +using System.Xml; namespace Orchard.Fields.Drivers { public class DateTimeFieldDriver : ContentFieldDriver { @@ -97,6 +96,7 @@ namespace Orchard.Fields.Drivers { Name = field.DisplayName, Hint = settings.Hint, IsRequired = settings.Required, + HasDefaultValue = settings.DefaultValue.HasValue, Editor = new DateTimeEditor() { Date = showDate ? DateLocalizationServices.ConvertToLocalizedDateString(value, options) : null, Time = showTime ? DateLocalizationServices.ConvertToLocalizedTimeString(value, options) : null, @@ -150,7 +150,7 @@ namespace Orchard.Fields.Drivers { field.DateTime = utcDateTime.Value; } } else { - field.DateTime = DateTime.MinValue; + field.DateTime = settings.DefaultValue.HasValue ? settings.DefaultValue.Value : DateTime.MinValue; } } catch { diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Drivers/EnumerationFieldDriver.cs b/src/Orchard.Web/Modules/Orchard.Fields/Drivers/EnumerationFieldDriver.cs index b7017ede5..044844d5d 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Drivers/EnumerationFieldDriver.cs +++ b/src/Orchard.Web/Modules/Orchard.Fields/Drivers/EnumerationFieldDriver.cs @@ -1,18 +1,22 @@ using Orchard.ContentManagement; using Orchard.ContentManagement.Drivers; using Orchard.ContentManagement.Handlers; -using Orchard.Fields.Settings; using Orchard.Fields.Fields; +using Orchard.Fields.Settings; using Orchard.Localization; +using Orchard.Tokens; using System; +using System.Collections.Generic; namespace Orchard.Fields.Drivers { public class EnumerationFieldDriver : ContentFieldDriver { public IOrchardServices Services { get; set; } private const string TemplateName = "Fields/Enumeration.Edit"; + private readonly ITokenizer _tokenizer; - public EnumerationFieldDriver(IOrchardServices services) { + public EnumerationFieldDriver(IOrchardServices services, ITokenizer tokenizer) { Services = services; + _tokenizer = tokenizer; T = NullLocalizer.Instance; } @@ -33,7 +37,16 @@ namespace Orchard.Fields.Drivers { protected override DriverResult Editor(ContentPart part, EnumerationField field, dynamic shapeHelper) { return ContentShape("Fields_Enumeration_Edit", GetDifferentiator(field, part), - () => shapeHelper.EditorTemplate(TemplateName: TemplateName, Model: field, Prefix: GetPrefix(field, part))); + () => { + if (field.Value == null) { + var settings = field.PartFieldDefinition.Settings.GetModel(); + if (!String.IsNullOrEmpty(settings.DefaultValue)) { + field.Value = _tokenizer.Replace(settings.DefaultValue, new Dictionary { { "Content", part.ContentItem } }); + } + } + + return shapeHelper.EditorTemplate(TemplateName: TemplateName, Model: field, Prefix: GetPrefix(field, part)); + }); } protected override DriverResult Editor(ContentPart part, EnumerationField field, IUpdateModel updater, dynamic shapeHelper) { diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Drivers/InputFieldDriver.cs b/src/Orchard.Web/Modules/Orchard.Fields/Drivers/InputFieldDriver.cs index d795641c5..31e0d1b14 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Drivers/InputFieldDriver.cs +++ b/src/Orchard.Web/Modules/Orchard.Fields/Drivers/InputFieldDriver.cs @@ -1,19 +1,22 @@ -using System; -using Orchard.ContentManagement; +using Orchard.ContentManagement; using Orchard.ContentManagement.Drivers; using Orchard.ContentManagement.Handlers; using Orchard.Fields.Fields; using Orchard.Fields.Settings; using Orchard.Localization; -using Orchard.Utility.Extensions; +using Orchard.Tokens; +using System; +using System.Collections.Generic; namespace Orchard.Fields.Drivers { public class InputFieldDriver : ContentFieldDriver { public IOrchardServices Services { get; set; } private const string TemplateName = "Fields/Input.Edit"; + private readonly ITokenizer _tokenizer; - public InputFieldDriver(IOrchardServices services) { + public InputFieldDriver(IOrchardServices services, ITokenizer tokenizer) { Services = services; + _tokenizer = tokenizer; T = NullLocalizer.Instance; } @@ -43,6 +46,10 @@ namespace Orchard.Fields.Drivers { if (updater.TryUpdateModel(field, GetPrefix(field, part), null, null)) { var settings = field.PartFieldDefinition.Settings.GetModel(); + if (field.Value == null && !String.IsNullOrEmpty(settings.DefaultValue)) { + field.Value = _tokenizer.Replace(settings.DefaultValue, new Dictionary { { "Content", part.ContentItem } }); + } + if (settings.Required && string.IsNullOrWhiteSpace(field.Value)) { updater.AddModelError(GetPrefix(field, part), T("The field {0} is mandatory.", T(field.DisplayName))); } diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Drivers/LinkFieldDriver.cs b/src/Orchard.Web/Modules/Orchard.Fields/Drivers/LinkFieldDriver.cs index cc1ff7a8b..aad8ad965 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Drivers/LinkFieldDriver.cs +++ b/src/Orchard.Web/Modules/Orchard.Fields/Drivers/LinkFieldDriver.cs @@ -1,18 +1,22 @@ -using System; -using Orchard.ContentManagement; +using Orchard.ContentManagement; using Orchard.ContentManagement.Drivers; using Orchard.ContentManagement.Handlers; using Orchard.Fields.Fields; using Orchard.Fields.Settings; using Orchard.Localization; +using Orchard.Tokens; +using System; +using System.Collections.Generic; namespace Orchard.Fields.Drivers { public class LinkFieldDriver : ContentFieldDriver { public IOrchardServices Services { get; set; } private const string TemplateName = "Fields/Link.Edit"; + private readonly ITokenizer _tokenizer; - public LinkFieldDriver(IOrchardServices services) { + public LinkFieldDriver(IOrchardServices services, ITokenizer tokenizer) { Services = services; + _tokenizer = tokenizer; T = NullLocalizer.Instance; } @@ -41,6 +45,15 @@ namespace Orchard.Fields.Drivers { protected override DriverResult Editor(ContentPart part, LinkField field, IUpdateModel updater, dynamic shapeHelper) { if (updater.TryUpdateModel(field, GetPrefix(field, part), null, null)) { var settings = field.PartFieldDefinition.Settings.GetModel(); + + if (String.IsNullOrEmpty(field.Value) && !String.IsNullOrEmpty(settings.DefaultValue)) { + field.Value = _tokenizer.Replace(settings.DefaultValue, new Dictionary { { "Content", part.ContentItem } }); + } + + if(!String.IsNullOrEmpty(settings.TextDefaultValue) && String.IsNullOrWhiteSpace(field.Text)) { + field.Text = _tokenizer.Replace(settings.TextDefaultValue, new Dictionary { { "Content", part.ContentItem } }); + } + if (settings.Required && string.IsNullOrWhiteSpace(field.Value)) { updater.AddModelError(GetPrefix(field, part), T("Url is required for {0}", field.DisplayName)); } diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Drivers/NumericFieldDriver.cs b/src/Orchard.Web/Modules/Orchard.Fields/Drivers/NumericFieldDriver.cs index 532ba2fa0..1fe633346 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Drivers/NumericFieldDriver.cs +++ b/src/Orchard.Web/Modules/Orchard.Fields/Drivers/NumericFieldDriver.cs @@ -1,21 +1,25 @@ -using System; -using System.Globalization; -using Orchard.ContentManagement; +using Orchard.ContentManagement; using Orchard.ContentManagement.Drivers; using Orchard.ContentManagement.Handlers; using Orchard.Fields.Fields; using Orchard.Fields.Settings; -using Orchard.Localization; using Orchard.Fields.ViewModels; +using Orchard.Localization; +using Orchard.Tokens; +using System; +using System.Collections.Generic; +using System.Globalization; namespace Orchard.Fields.Drivers { public class NumericFieldDriver : ContentFieldDriver { public IOrchardServices Services { get; set; } private const string TemplateName = "Fields/Numeric.Edit"; private readonly Lazy _cultureInfo; + private readonly ITokenizer _tokenizer; - public NumericFieldDriver(IOrchardServices services) { + public NumericFieldDriver(IOrchardServices services, ITokenizer tokenizer) { Services = services; + _tokenizer = tokenizer; T = NullLocalizer.Instance; _cultureInfo = new Lazy(() => CultureInfo.GetCultureInfo(Services.WorkContext.CurrentCulture)); @@ -40,7 +44,6 @@ namespace Orchard.Fields.Drivers { } protected override DriverResult Editor(ContentPart part, NumericField field, dynamic shapeHelper) { - return ContentShape("Fields_Numeric_Edit", GetDifferentiator(field, part), () => { var model = new NumericFieldViewModel { @@ -66,7 +69,16 @@ namespace Orchard.Fields.Drivers { } if (!settings.Required && String.IsNullOrWhiteSpace(viewModel.Value)) { - field.Value = null; + if (settings.DefaultValue != null) { + if (Decimal.TryParse(_tokenizer.Replace(settings.DefaultValue, new Dictionary { { "Content", part.ContentItem } }), NumberStyles.Any, _cultureInfo.Value, out value) + && Math.Round(value, settings.Scale) == value + && !String.IsNullOrEmpty(settings.DefaultValue)) { + field.Value = value; + } + } + else { + field.Value = null; + } } else if (Decimal.TryParse(viewModel.Value, NumberStyles.Any, _cultureInfo.Value, out value)) { field.Value = value; diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Drivers/TextFieldDriver.cs b/src/Orchard.Web/Modules/Orchard.Fields/Drivers/TextFieldDriver.cs new file mode 100644 index 000000000..9863aa6d1 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Fields/Drivers/TextFieldDriver.cs @@ -0,0 +1,29 @@ +using Orchard.ContentManagement; +using Orchard.ContentManagement.Drivers; +using Orchard.Core.Common.Fields; +using Orchard.Core.Common.Settings; +using Orchard.Tokens; +using System; +using System.Collections.Generic; + +namespace Orchard.Fields.Drivers { + // The original driver of the TextField is in Orchard.Core, where tokenization can not be used. + // This driver was added so the default value of the TextField can be tokenized. + public class TextFieldDriver : ContentFieldDriver { + private readonly ITokenizer _tokenizer; + + public TextFieldDriver(ITokenizer tokenizer) { + _tokenizer = tokenizer; + } + + protected override DriverResult Editor(ContentPart part, TextField field, IUpdateModel updater, dynamic shapeHelper) { + var settings = field.PartFieldDefinition.Settings.GetModel(); + + if (String.IsNullOrEmpty(field.Value) && !String.IsNullOrEmpty(settings.DefaultValue)) { + field.Value = _tokenizer.Replace(settings.DefaultValue, new Dictionary { { "Content", part.ContentItem } }); + } + + return null; + } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Module.txt b/src/Orchard.Web/Modules/Orchard.Fields/Module.txt index d75f98af4..c17e7f310 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Module.txt +++ b/src/Orchard.Web/Modules/Orchard.Fields/Module.txt @@ -9,4 +9,4 @@ Features: Orchard.Fields: Description: Contains the following fields: Input, Boolean, DateTime, Numeric, Link, Enumeration Category: Fields - Dependencies: Common, Orchard.Resources + Dependencies: Common, Orchard.Resources, Orchard.Tokens diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Orchard.Fields.csproj b/src/Orchard.Web/Modules/Orchard.Fields/Orchard.Fields.csproj index b2dd20a9b..c5f45cf24 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Orchard.Fields.csproj +++ b/src/Orchard.Web/Modules/Orchard.Fields/Orchard.Fields.csproj @@ -76,6 +76,7 @@ + @@ -90,6 +91,10 @@ Orchard.Core false + + {6f759635-13d7-4e94-bcc9-80445d63f117} + Orchard.Tokens + @@ -149,6 +154,9 @@ + + + 10.0 $(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion) diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Settings/DateTimeFieldEditorEvents.cs b/src/Orchard.Web/Modules/Orchard.Fields/Settings/DateTimeFieldEditorEvents.cs index 01dbc55be..30c53d60f 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Settings/DateTimeFieldEditorEvents.cs +++ b/src/Orchard.Web/Modules/Orchard.Fields/Settings/DateTimeFieldEditorEvents.cs @@ -1,17 +1,31 @@ -using System.Collections.Generic; -using System.Globalization; -using Orchard.ContentManagement; +using Orchard.ContentManagement; using Orchard.ContentManagement.MetaData; using Orchard.ContentManagement.MetaData.Builders; using Orchard.ContentManagement.MetaData.Models; using Orchard.ContentManagement.ViewModels; +using Orchard.Core.Common.ViewModels; +using Orchard.Localization.Services; +using System; +using System.Collections.Generic; +using System.Globalization; namespace Orchard.Fields.Settings { public class DateTimeFieldEditorEvents : ContentDefinitionEditorEventsBase { + private readonly IDateLocalizationServices _dateLocalizationServices; + + public DateTimeFieldEditorEvents(IDateLocalizationServices dateLocalizationServices) { + _dateLocalizationServices = dateLocalizationServices; + } public override IEnumerable PartFieldEditor(ContentPartFieldDefinition definition) { if (definition.FieldDefinition.Name == "DateTimeField") { var model = definition.Settings.GetModel(); + model.Editor = new DateTimeEditor() { + ShowDate = true, + ShowTime = true, + Date = _dateLocalizationServices.ConvertToLocalizedDateString(model.DefaultValue), + Time = _dateLocalizationServices.ConvertToLocalizedTimeString(model.DefaultValue), + }; yield return DefinitionTemplate(model); } } @@ -26,6 +40,8 @@ namespace Orchard.Fields.Settings { builder.WithSetting("DateTimeFieldSettings.Display", model.Display.ToString()); builder.WithSetting("DateTimeFieldSettings.Hint", model.Hint); builder.WithSetting("DateTimeFieldSettings.Required", model.Required.ToString(CultureInfo.InvariantCulture)); + model.DefaultValue = model.Editor == null ? model.DefaultValue : _dateLocalizationServices.ConvertFromLocalizedString(model.Editor.Date, model.Editor.Time); + builder.WithSetting("DateTimeFieldSettings.DefaultValue", model.DefaultValue.HasValue ? model.DefaultValue.Value.ToString(CultureInfo.InvariantCulture) : String.Empty); yield return DefinitionTemplate(model); } diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Settings/DateTimeFieldSettings.cs b/src/Orchard.Web/Modules/Orchard.Fields/Settings/DateTimeFieldSettings.cs index 70fcf9c3a..97859bdd3 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Settings/DateTimeFieldSettings.cs +++ b/src/Orchard.Web/Modules/Orchard.Fields/Settings/DateTimeFieldSettings.cs @@ -1,4 +1,7 @@ -namespace Orchard.Fields.Settings { +using Orchard.Core.Common.ViewModels; +using System; + +namespace Orchard.Fields.Settings { public enum DateTimeFieldDisplays { DateAndTime, @@ -10,5 +13,7 @@ public DateTimeFieldDisplays Display { get; set; } public string Hint { get; set; } public bool Required { get; set; } + public DateTime? DefaultValue { get; set; } + public DateTimeEditor Editor { get; set; } } } diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Settings/EnumerationFieldEditorEvents.cs b/src/Orchard.Web/Modules/Orchard.Fields/Settings/EnumerationFieldEditorEvents.cs index 71fc4d27b..4a50d43ef 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Settings/EnumerationFieldEditorEvents.cs +++ b/src/Orchard.Web/Modules/Orchard.Fields/Settings/EnumerationFieldEditorEvents.cs @@ -1,10 +1,10 @@ -using System.Collections.Generic; -using System.Globalization; -using Orchard.ContentManagement; +using Orchard.ContentManagement; using Orchard.ContentManagement.MetaData; using Orchard.ContentManagement.MetaData.Builders; using Orchard.ContentManagement.MetaData.Models; using Orchard.ContentManagement.ViewModels; +using System.Collections.Generic; +using System.Globalization; namespace Orchard.Fields.Settings { public class EnumerationFieldListModeEvents : ContentDefinitionEditorEventsBase { @@ -27,6 +27,7 @@ namespace Orchard.Fields.Settings { builder.WithSetting("EnumerationFieldSettings.Required", model.Required.ToString(CultureInfo.InvariantCulture)); builder.WithSetting("EnumerationFieldSettings.Options", model.Options); builder.WithSetting("EnumerationFieldSettings.ListMode", model.ListMode.ToString()); + builder.WithSetting("EnumerationFieldSettings.DefaultValue", model.DefaultValue); } yield return DefinitionTemplate(model); diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Settings/EnumerationFieldSettings.cs b/src/Orchard.Web/Modules/Orchard.Fields/Settings/EnumerationFieldSettings.cs index bf8eef1a3..d23b85a9b 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Settings/EnumerationFieldSettings.cs +++ b/src/Orchard.Web/Modules/Orchard.Fields/Settings/EnumerationFieldSettings.cs @@ -12,6 +12,7 @@ public bool Required { get; set; } public string Options { get; set; } public ListMode ListMode { get; set; } + public string DefaultValue { get; set; } public EnumerationFieldSettings() { ListMode = ListMode.Dropdown; diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Settings/InputFieldEditorEvents.cs b/src/Orchard.Web/Modules/Orchard.Fields/Settings/InputFieldEditorEvents.cs index 03751730d..dd8104a3c 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Settings/InputFieldEditorEvents.cs +++ b/src/Orchard.Web/Modules/Orchard.Fields/Settings/InputFieldEditorEvents.cs @@ -1,9 +1,10 @@ -using System.Collections.Generic; -using Orchard.ContentManagement; +using Orchard.ContentManagement; using Orchard.ContentManagement.MetaData; using Orchard.ContentManagement.MetaData.Builders; using Orchard.ContentManagement.MetaData.Models; using Orchard.ContentManagement.ViewModels; +using System.Collections.Generic; +using System.Globalization; namespace Orchard.Fields.Settings { public class InputFieldListModeEvents : ContentDefinitionEditorEventsBase { @@ -32,6 +33,7 @@ namespace Orchard.Fields.Settings { builder.WithSetting("InputFieldSettings.Pattern", model.Pattern); builder.WithSetting("InputFieldSettings.EditorCssClass", model.EditorCssClass); builder.WithSetting("InputFieldSettings.MaxLength", model.MaxLength.ToString()); + builder.WithSetting("InputFieldSettings.DefaultValue", model.DefaultValue); } yield return DefinitionTemplate(model); diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Settings/InputFieldSettings.cs b/src/Orchard.Web/Modules/Orchard.Fields/Settings/InputFieldSettings.cs index e2553d561..c39ce4bb9 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Settings/InputFieldSettings.cs +++ b/src/Orchard.Web/Modules/Orchard.Fields/Settings/InputFieldSettings.cs @@ -18,6 +18,7 @@ public string Pattern { get; set; } public string EditorCssClass { get; set; } public int MaxLength { get; set; } + public string DefaultValue { get; set; } public InputFieldSettings() { Type = InputType.Text; diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Settings/LinkFieldEditorEvents.cs b/src/Orchard.Web/Modules/Orchard.Fields/Settings/LinkFieldEditorEvents.cs index c5ce44a19..356aba645 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Settings/LinkFieldEditorEvents.cs +++ b/src/Orchard.Web/Modules/Orchard.Fields/Settings/LinkFieldEditorEvents.cs @@ -1,10 +1,10 @@ -using System.Collections.Generic; -using System.Globalization; -using Orchard.ContentManagement; +using Orchard.ContentManagement; using Orchard.ContentManagement.MetaData; using Orchard.ContentManagement.MetaData.Builders; using Orchard.ContentManagement.MetaData.Models; using Orchard.ContentManagement.ViewModels; +using System.Collections.Generic; +using System.Globalization; namespace Orchard.Fields.Settings { public class LinkFieldListModeEvents : ContentDefinitionEditorEventsBase { @@ -28,7 +28,9 @@ namespace Orchard.Fields.Settings { builder.WithSetting("LinkFieldSettings.TargetMode", model.TargetMode.ToString()); builder.WithSetting("LinkFieldSettings.LinkTextMode", model.LinkTextMode.ToString()); builder.WithSetting("LinkFieldSettings.StaticText", model.StaticText); - + builder.WithSetting("LinkFieldSettings.DefaultValue", model.DefaultValue); + builder.WithSetting("LinkFieldSettings.TextDefaultValue", model.TextDefaultValue); + yield return DefinitionTemplate(model); } } diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Settings/LinkFieldSettings.cs b/src/Orchard.Web/Modules/Orchard.Fields/Settings/LinkFieldSettings.cs index be69ebcdc..62439a971 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Settings/LinkFieldSettings.cs +++ b/src/Orchard.Web/Modules/Orchard.Fields/Settings/LinkFieldSettings.cs @@ -5,6 +5,8 @@ public TargetMode TargetMode { get; set; } public LinkTextMode LinkTextMode { get; set; } public string StaticText { get; set; } + public string DefaultValue { get; set; } + public string TextDefaultValue { get; set; } public LinkFieldSettings() { TargetMode = TargetMode.None; diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Settings/NumericFieldEditorEvents.cs b/src/Orchard.Web/Modules/Orchard.Fields/Settings/NumericFieldEditorEvents.cs index 2ba02e475..ff037da5c 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Settings/NumericFieldEditorEvents.cs +++ b/src/Orchard.Web/Modules/Orchard.Fields/Settings/NumericFieldEditorEvents.cs @@ -1,10 +1,10 @@ -using System.Collections.Generic; -using System.Globalization; -using Orchard.ContentManagement; +using Orchard.ContentManagement; using Orchard.ContentManagement.MetaData; using Orchard.ContentManagement.MetaData.Builders; using Orchard.ContentManagement.MetaData.Models; using Orchard.ContentManagement.ViewModels; +using System.Collections.Generic; +using System.Globalization; namespace Orchard.Fields.Settings { public class NumericFieldListModeEvents : ContentDefinitionEditorEventsBase { @@ -28,6 +28,7 @@ namespace Orchard.Fields.Settings { builder.WithSetting("NumericFieldSettings.Scale", model.Scale.ToString(CultureInfo.InvariantCulture)); builder.WithSetting("NumericFieldSettings.Minimum", model.Minimum.HasValue ? model.Minimum.Value.ToString(CultureInfo.InvariantCulture) : string.Empty); builder.WithSetting("NumericFieldSettings.Maximum", model.Maximum.HasValue ? model.Maximum.Value.ToString(CultureInfo.InvariantCulture) : string.Empty); + builder.WithSetting("NumericFieldSettings.DefaultValue", model.DefaultValue); } yield return DefinitionTemplate(model); diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Settings/NumericFieldSettings.cs b/src/Orchard.Web/Modules/Orchard.Fields/Settings/NumericFieldSettings.cs index bbf59d5e3..5abca801b 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Settings/NumericFieldSettings.cs +++ b/src/Orchard.Web/Modules/Orchard.Fields/Settings/NumericFieldSettings.cs @@ -5,6 +5,7 @@ public int Scale { get; set; } public decimal? Minimum { get; set; } public decimal? Maximum { get; set; } + public string DefaultValue { get; set; } public NumericFieldSettings() { Scale = 0; diff --git a/src/Orchard.Web/Modules/Orchard.Fields/ViewModels/DateTimeFieldViewModel.cs b/src/Orchard.Web/Modules/Orchard.Fields/ViewModels/DateTimeFieldViewModel.cs index d140dcbd0..5fea628c6 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/ViewModels/DateTimeFieldViewModel.cs +++ b/src/Orchard.Web/Modules/Orchard.Fields/ViewModels/DateTimeFieldViewModel.cs @@ -6,5 +6,6 @@ namespace Orchard.Fields.ViewModels { public string Hint { get; set; } public bool IsRequired { get; set; } public DateTimeEditor Editor { get; set; } + public bool HasDefaultValue { get; set; } } } \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/DateTimeFieldSettings.cshtml b/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/DateTimeFieldSettings.cshtml index 95195e59c..b6b72d301 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/DateTimeFieldSettings.cshtml +++ b/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/DateTimeFieldSettings.cshtml @@ -27,3 +27,12 @@ @Html.ValidationMessageFor(m => m.Hint)
+ +
+
+ + @Html.EditorFor(m => m.Editor) + @T("Pick a default date for the field. (optional)") + @Html.ValidationMessageFor(m => m.Editor) +
+
diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/EnumerationFieldSettings.cshtml b/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/EnumerationFieldSettings.cshtml index 2d846278d..ffd253bff 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/EnumerationFieldSettings.cshtml +++ b/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/EnumerationFieldSettings.cshtml @@ -28,3 +28,11 @@ @T("The help text is written under the field when users are selecting an option.") @Html.ValidationMessageFor(m => m.Hint) +
+
+ + @Html.TextBoxFor(m => m.DefaultValue, new { @class = "text large tokenized ui-autocomplete-input" }) + @T("Enter a default option for the field. You can use tokens in this field. If there is no equivalent choice among Options, it will not be used. (optional)") + @Html.ValidationMessageFor(m => m.DefaultValue) +
+
\ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/InputFieldSettings.cshtml b/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/InputFieldSettings.cshtml index f9bedae93..d3746ffed 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/InputFieldSettings.cshtml +++ b/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/InputFieldSettings.cshtml @@ -77,3 +77,11 @@ @Html.ValidationMessageFor(m => m.Hint) +
+
+ + @Html.TextBoxFor(m => m.DefaultValue, new { @class = "text large tokenized ui-autocomplete-input" }) + @T("A valid url as a default value, i.e. http://orchardproject.net, /content/file.pdf ... You can use tokens in this field. (optional)") + @Html.ValidationMessageFor(m => m.DefaultValue) +
+
\ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/LinkFieldSettings.cshtml b/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/LinkFieldSettings.cshtml index a17fbe442..9dad8f7b7 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/LinkFieldSettings.cshtml +++ b/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/LinkFieldSettings.cshtml @@ -44,3 +44,19 @@ @Html.ValidationMessageFor(m => m.Hint) +
+
+ + @Html.TextBoxFor(m => m.DefaultValue, new { @class = "text large tokenized ui-autocomplete-input" }) + @T("A valid url as a default value, i.e. http://orchardproject.net, /content/file.pdf ... You can use tokens in this field. (optional)") + @Html.ValidationMessageFor(m => m.DefaultValue) +
+
+
+
+ + @Html.TextBoxFor(m => m.TextDefaultValue, new { @class = "text large tokenized ui-autocomplete-input" }) + @T("If the Link text is set to Optional or Required, a default value can be set for it. You can use tokens in this field. (optional)") + @Html.ValidationMessageFor(m => m.TextDefaultValue) +
+
\ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/NumericFieldSettings.cshtml b/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/NumericFieldSettings.cshtml index ae7753967..09cedb61a 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/NumericFieldSettings.cshtml +++ b/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/NumericFieldSettings.cshtml @@ -39,3 +39,11 @@ @Html.ValidationMessageFor(m => m.Hint) +
+
+ + @Html.TextBoxFor(m => m.DefaultValue, new { @class = "text large tokenized ui-autocomplete-input" }) + @T("The default value for the field. It must be a number, and if not it will not shown. Make sure to set the Scale property if the value is not an integer. You can use tokens in this field. (optional)") + @Html.ValidationMessageFor(m => m.DefaultValue) +
+
\ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/TextFieldDefaultValueEditor.cshtml b/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/TextFieldDefaultValueEditor.cshtml new file mode 100644 index 000000000..a35bea691 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Fields/Views/DefinitionTemplates/TextFieldDefaultValueEditor.cshtml @@ -0,0 +1,7 @@ +@model Orchard.Core.Common.ViewModels.TextFieldSettingsEventsViewModel +@* This override is here so that the token helper can be used on the default value's textbox, which can not be used in Orchard.Core. *@ + + +@Html.TextBoxFor(m => m.Settings.DefaultValue, new { @class = "text large tokenized ui-autocomplete-input" }) +@T("Default value for the field. You can use tokens in this field. If there is no value given for the actual field, this will be filled in. (optional)") +@Html.ValidationMessageFor(m => m.Settings.DefaultValue) \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Views/EditorTemplates/Fields/DateTime.Edit.cshtml b/src/Orchard.Web/Modules/Orchard.Fields/Views/EditorTemplates/Fields/DateTime.Edit.cshtml index 999e87d9c..5c2d90e4b 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Views/EditorTemplates/Fields/DateTime.Edit.cshtml +++ b/src/Orchard.Web/Modules/Orchard.Fields/Views/EditorTemplates/Fields/DateTime.Edit.cshtml @@ -6,4 +6,7 @@ @if (HasText(Model.Hint)) { @Model.Hint } + @if (Model.HasDefaultValue) { + @T("If the field is left empty then the default value will be used if one is configured.") + } diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Views/EditorTemplates/Fields/Input.Edit.cshtml b/src/Orchard.Web/Modules/Orchard.Fields/Views/EditorTemplates/Fields/Input.Edit.cshtml index 7b253c7ec..874372f87 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Views/EditorTemplates/Fields/Input.Edit.cshtml +++ b/src/Orchard.Web/Modules/Orchard.Fields/Views/EditorTemplates/Fields/Input.Edit.cshtml @@ -11,4 +11,7 @@ @if (HasText(settings.Hint)) { @settings.Hint } + @if (!String.IsNullOrWhiteSpace(settings.DefaultValue)) { + @T("If the field is left empty then the default value will be used.") + } diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Views/EditorTemplates/Fields/Link.Edit.cshtml b/src/Orchard.Web/Modules/Orchard.Fields/Views/EditorTemplates/Fields/Link.Edit.cshtml index ecd470a31..f1c487f09 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Views/EditorTemplates/Fields/Link.Edit.cshtml +++ b/src/Orchard.Web/Modules/Orchard.Fields/Views/EditorTemplates/Fields/Link.Edit.cshtml @@ -27,13 +27,21 @@ @Html.TextBoxFor(m => m.Value, new { @class = "text large" }) @T("A valid url, i.e. http://orchardproject.net, /content/file.pdf, ...") + @if (!String.IsNullOrWhiteSpace(settings.DefaultValue)) { + @T("If the field is left empty then the default value will be used.") + } @if (settings.LinkTextMode == LinkTextMode.Optional || settings.LinkTextMode == LinkTextMode.Required) {
- @Html.TextBoxFor(m => m.Text, new {@class = "text medium"}) - @T("The text of the link. If left empty, the url will be used instead.") + @Html.TextBoxFor(m => m.Text, new { @class = "text medium" }) + @if (!String.IsNullOrWhiteSpace(settings.TextDefaultValue)) { + @T("If the field is left empty then the default value will be used.") + } + else { + @T("The text of the link. If left empty, the url will be used instead.") + }
} diff --git a/src/Orchard.Web/Modules/Orchard.Fields/Views/EditorTemplates/Fields/Numeric.Edit.cshtml b/src/Orchard.Web/Modules/Orchard.Fields/Views/EditorTemplates/Fields/Numeric.Edit.cshtml index 4f127b4da..baae80d67 100644 --- a/src/Orchard.Web/Modules/Orchard.Fields/Views/EditorTemplates/Fields/Numeric.Edit.cshtml +++ b/src/Orchard.Web/Modules/Orchard.Fields/Views/EditorTemplates/Fields/Numeric.Edit.cshtml @@ -11,4 +11,7 @@ @if (HasText(Model.Settings.Hint)) { @Model.Settings.Hint } + @if (!String.IsNullOrWhiteSpace(Model.Settings.DefaultValue)) { + @T("If the field is left empty then the default value will be used.") + } diff --git a/src/Orchard.Web/Modules/Orchard.MediaLibrary/Extensions/MetaDataExtensions.cs b/src/Orchard.Web/Modules/Orchard.MediaLibrary/Extensions/MediaMetaDataExtensions.cs similarity index 98% rename from src/Orchard.Web/Modules/Orchard.MediaLibrary/Extensions/MetaDataExtensions.cs rename to src/Orchard.Web/Modules/Orchard.MediaLibrary/Extensions/MediaMetaDataExtensions.cs index 154150808..322d2f672 100644 --- a/src/Orchard.Web/Modules/Orchard.MediaLibrary/Extensions/MetaDataExtensions.cs +++ b/src/Orchard.Web/Modules/Orchard.MediaLibrary/Extensions/MediaMetaDataExtensions.cs @@ -5,7 +5,7 @@ using System.Web; using Orchard.ContentManagement.MetaData.Builders; namespace Orchard.ContentManagement.MetaData { - public static class MetaDataExtensions { + public static class MediaMetaDataExtensions { /// /// This extension method can be used for easy image part creation. Adds all necessary parts and settings to the part. /// diff --git a/src/Orchard.Web/Modules/Orchard.MediaLibrary/Orchard.MediaLibrary.csproj b/src/Orchard.Web/Modules/Orchard.MediaLibrary/Orchard.MediaLibrary.csproj index dac14d392..b6e833093 100644 --- a/src/Orchard.Web/Modules/Orchard.MediaLibrary/Orchard.MediaLibrary.csproj +++ b/src/Orchard.Web/Modules/Orchard.MediaLibrary/Orchard.MediaLibrary.csproj @@ -101,7 +101,7 @@ - + diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Extensions/MetaDataExtensions.cs b/src/Orchard.Web/Modules/Orchard.Widgets/Extensions/WidgetsMetaDataExtensions.cs similarity index 96% rename from src/Orchard.Web/Modules/Orchard.Widgets/Extensions/MetaDataExtensions.cs rename to src/Orchard.Web/Modules/Orchard.Widgets/Extensions/WidgetsMetaDataExtensions.cs index 720ace53a..e043ec465 100644 --- a/src/Orchard.Web/Modules/Orchard.Widgets/Extensions/MetaDataExtensions.cs +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Extensions/WidgetsMetaDataExtensions.cs @@ -5,7 +5,7 @@ using System.Web; using Orchard.ContentManagement.MetaData.Builders; namespace Orchard.ContentManagement.MetaData { - public static class MetaDataExtensions { + public static class WidgetsMetaDataExtensions { /// /// This extension method can be used for easy widget creation. Adds all necessary parts and settings to the part. /// diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Orchard.Widgets.csproj b/src/Orchard.Web/Modules/Orchard.Widgets/Orchard.Widgets.csproj index 8770c9dca..7b728ff1f 100644 --- a/src/Orchard.Web/Modules/Orchard.Widgets/Orchard.Widgets.csproj +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Orchard.Widgets.csproj @@ -72,7 +72,7 @@ - + From 9715ee88df1ec9f381f235ff475d479922a29257 Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Sun, 20 Dec 2015 16:28:36 +0100 Subject: [PATCH 26/30] Removed unnecessary Html model map. The Html model mapping was originally needed to support inline editing of Html elements, but that capability has been removed. --- .../LayoutEditor/Directives/Html.js | 41 ----------- .../Assets/JavaScript/Models/Html.js | 70 ------------------- .../Orchard.Layouts/Orchard.Layouts.csproj | 5 -- .../Services/DefaultModelMaps.cs | 28 -------- .../Views/LayoutEditor.Template.Html.cshtml | 11 --- 5 files changed, 155 deletions(-) delete mode 100644 src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Directives/Html.js delete mode 100644 src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Html.js delete mode 100644 src/Orchard.Web/Modules/Orchard.Layouts/Views/LayoutEditor.Template.Html.cshtml diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Directives/Html.js b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Directives/Html.js deleted file mode 100644 index 94890f1d6..000000000 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Directives/Html.js +++ /dev/null @@ -1,41 +0,0 @@ -angular - .module("LayoutEditor") - .directive("orcLayoutHtml", ["$sce", "scopeConfigurator", "environment", - function ($sce, scopeConfigurator, environment) { - return { - restrict: "E", - scope: { element: "=" }, - controller: ["$scope", "$element", - function ($scope, $element) { - scopeConfigurator.configureForElement($scope, $element); - $scope.edit = function () { - $scope.$root.editElement($scope.element).then(function (args) { - $scope.$apply(function () { - if (args.cancel) - return; - - $scope.element.data = args.element.data; - $scope.element.setHtml(args.element.html); - }); - }); - }; - $scope.updateContent = function (e) { - $scope.element.setHtml(e.target.innerHTML); - }; - - // Overwrite the setHtml function so that we can use the $sce service to trust the html (and not have the html binding strip certain tags). - $scope.element.setHtml = function (html) { - $scope.element.html = html; - $scope.element.htmlUnsafe = $sce.trustAsHtml(html); - }; - - $scope.element.setHtml($scope.element.html); - } - ], - templateUrl: environment.templateUrl("Html"), - replace: true, - link: function (scope, element) { - } - }; - } - ]); \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Html.js b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Html.js deleted file mode 100644 index fd62a1b3e..000000000 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Html.js +++ /dev/null @@ -1,70 +0,0 @@ -var LayoutEditor; -(function ($, LayoutEditor) { - - LayoutEditor.Html = function (data, htmlId, htmlClass, htmlStyle, isTemplated, contentType, contentTypeLabel, contentTypeClass, html, hasEditor, rule) { - LayoutEditor.Element.call(this, "Html", data, htmlId, htmlClass, htmlStyle, isTemplated, rule); - - this.contentType = contentType; - this.contentTypeLabel = contentTypeLabel; - this.contentTypeClass = contentTypeClass; - this.html = html; - this.hasEditor = hasEditor; - this.isContainable = true; - - this.getInnerText = function () { - return $($.parseHTML("
" + this.html + "
")).text(); - }; - - // This function will be overwritten by the Content directive. - this.setHtml = function (html) { - this.html = html; - this.htmlUnsafe = html; - } - - this.toObject = function () { - return { - "type": "Html" - }; - }; - - this.toObject = function () { - var result = this.elementToObject(); - result.contentType = this.contentType; - result.contentTypeLabel = this.contentTypeLabel; - result.contentTypeClass = this.contentTypeClass; - result.html = this.html; - result.hasEditor = hasEditor; - return result; - }; - - var getEditorObject = this.getEditorObject; - this.getEditorObject = function () { - var dto = getEditorObject(); - return $.extend(dto, { - Content: this.html - }); - } - - this.setHtml(html); - }; - - LayoutEditor.Html.from = function (value) { - var result = new LayoutEditor.Html( - value.data, - value.htmlId, - value.htmlClass, - value.htmlStyle, - value.isTemplated, - value.contentType, - value.contentTypeLabel, - value.contentTypeClass, - value.html, - value.hasEditor, - value.rule); - - return result; - }; - - LayoutEditor.registerFactory("Html", function(value) { return LayoutEditor.Html.from(value); }); - -})(jQuery, LayoutEditor || (LayoutEditor = {})); \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Orchard.Layouts.csproj b/src/Orchard.Web/Modules/Orchard.Layouts/Orchard.Layouts.csproj index 07dc77758..f2b68b6b3 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Orchard.Layouts.csproj +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Orchard.Layouts.csproj @@ -94,7 +94,6 @@ - @@ -114,7 +113,6 @@ - @@ -512,9 +510,6 @@ - - - diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Services/DefaultModelMaps.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Services/DefaultModelMaps.cs index d463892ee..1eb51b9f9 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Services/DefaultModelMaps.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Services/DefaultModelMaps.cs @@ -134,34 +134,6 @@ namespace Orchard.Layouts.Services { } } - public class HtmlModelMap : ContentModelMap { - public HtmlModelMap(IShapeDisplay shapeDisplay, IElementDisplay elementDisplay) - : base(shapeDisplay, elementDisplay) { - } - - public override int Priority { - get { return 1; } - } - - public override string LayoutElementType { - get { return "Html"; } - } - - public override bool CanMap(Element element) { - return element is Html; - } - - public override Element ToElement(IElementManager elementManager, DescribeElementsContext describeContext, JToken node) { - var html = (string)node["html"]; - var element = (Html)base.ToElement(elementManager, describeContext, node); - - // To support inline editing, we need to update the element's content. - element.Content = html; - - return element; - } - } - public class RecycleBinModelMap : ILayoutModelMap { public int Priority { get { return 0; } } public string LayoutElementType { get { return "RecycleBin"; } } diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Views/LayoutEditor.Template.Html.cshtml b/src/Orchard.Web/Modules/Orchard.Layouts/Views/LayoutEditor.Template.Html.cshtml deleted file mode 100644 index 3c229860a..000000000 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Views/LayoutEditor.Template.Html.cshtml +++ /dev/null @@ -1,11 +0,0 @@ -
-
    -
  • {{::element.contentTypeLabel}}
    • -
    • - @Display(New.LayoutEditor_Template_Properties(ElementTypeName: "{{element.contentTypeLabel.toLowerCase()}}")) -
    • -
    • -
    • -
-
-
\ No newline at end of file From 68c94f453491b677fdeae7e4bb8a0edc8abe5d08 Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Sun, 20 Dec 2015 16:33:34 +0100 Subject: [PATCH 27/30] Fixed a potential issue with new Container elements. Making the ContentModelMap the default mapper for all elements fixes a potential issue when a new Container element is introduced but no model map implementation exists for that container. Letting the ContentModelMap handle the mapping by default would yield best results rather than doing no mapping at all. --- .../Modules/Orchard.Layouts/Services/DefaultModelMaps.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Services/DefaultModelMaps.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Services/DefaultModelMaps.cs index 1eb51b9f9..197e76c8b 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Services/DefaultModelMaps.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Services/DefaultModelMaps.cs @@ -100,7 +100,7 @@ namespace Orchard.Layouts.Services { public virtual string LayoutElementType { get { return "Content"; } } public virtual bool CanMap(Element element) { - return !(element is Container); + return true; } public virtual Element ToElement(IElementManager elementManager, DescribeElementsContext describeContext, JToken node) { From 8eef43f20da70c86925e1fa064688126cdac9752 Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Sun, 20 Dec 2015 16:37:57 +0100 Subject: [PATCH 28/30] Fixed media library picker field script. This fixes an issue where the code selecting the 'Save' button would match any button with the 'button.save' class. The issue became apparent when working with Image element on a layout. The Element Editor Dialog also has a 'Save' button with the 'button save' class, en became hidden when no image was selected. --- .../Orchard.MediaLibrary/Scripts/media-library-picker.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Orchard.Web/Modules/Orchard.MediaLibrary/Scripts/media-library-picker.js b/src/Orchard.Web/Modules/Orchard.MediaLibrary/Scripts/media-library-picker.js index 1c5c88c9f..bc680f92a 100644 --- a/src/Orchard.Web/Modules/Orchard.MediaLibrary/Scripts/media-library-picker.js +++ b/src/Orchard.Web/Modules/Orchard.MediaLibrary/Scripts/media-library-picker.js @@ -14,7 +14,7 @@ var promptOnNavigate = element.data("prompt-on-navigate"); var showSaveWarning = element.data("show-save-warning"); var addButton = element.find(".button.add"); - var saveButton = $('.button.save'); + var saveButton = element.find('.button.save'); var removeAllButton = element.find(".button.remove"); var template = '
  • {thumbnail}

    {title}

    ' + removeText + '' + pipe + '' + editText + '
    • '; From d1c0f980108691b3bd447f2c8209fad5d0647048 Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Mon, 21 Dec 2015 19:48:59 +0100 Subject: [PATCH 29/30] Updated Layouts to simplify custom container elements. These changes simplifies the requirements for implementing custom container elements by minimizing the amount of code necessary to tie things together. --- .../LayoutEditor/Directives/Content.js | 20 ++-- .../Services/ScopeConfigurator.js | 13 +++ .../Assets/JavaScript/Models/Container.js | 12 +++ .../Assets/JavaScript/Models/Element.js | 12 +++ .../Orchard.Layouts/Scripts/LayoutEditor.js | 76 +++++---------- .../Scripts/LayoutEditor.min.js | 2 +- .../Modules/Orchard.Layouts/Scripts/Models.js | 96 +++++-------------- .../Orchard.Layouts/Scripts/Models.min.js | 2 +- .../Services/DefaultModelMaps.cs | 7 +- .../LayoutEditor.Template.Children.cshtml | 2 +- .../LayoutEditor.Template.Content.cshtml | 2 +- 11 files changed, 108 insertions(+), 136 deletions(-) diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Directives/Content.js b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Directives/Content.js index ce96c7f1e..69292804a 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Directives/Content.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Directives/Content.js @@ -8,17 +8,19 @@ controller: ["$scope", "$element", function ($scope, $element) { scopeConfigurator.configureForElement($scope, $element); - $scope.edit = function () { - $scope.$root.editElement($scope.element).then(function (args) { - $scope.$apply(function () { - if (args.cancel) - return; + if ($scope.element.hasEditor) { + $scope.edit = function () { + $scope.$root.editElement($scope.element).then(function (args) { + $scope.$apply(function () { + if (args.cancel) + return; - $scope.element.data = args.element.data; - $scope.element.setHtml(args.element.html); + $scope.element.data = args.element.data; + $scope.element.setHtml(args.element.html); + }); }); - }); - }; + }; + } // Overwrite the setHtml function so that we can use the $sce service to trust the html (and not have the html binding strip certain tags). $scope.element.setHtml = function (html) { diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Services/ScopeConfigurator.js b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Services/ScopeConfigurator.js index a2ce3a6ba..3f3710d2c 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Services/ScopeConfigurator.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Services/ScopeConfigurator.js @@ -150,6 +150,19 @@ $scope.delete = function (element) { element.delete(); } + + if ($scope.element.hasEditor) { + $scope.edit = function () { + $scope.$root.editElement($scope.element).then(function (args) { + $scope.$apply(function () { + if (args.cancel) + return; + + $scope.element.data = args.element.data; + }); + }); + }; + } }, configureForContainer: function ($scope, $element) { diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Container.js b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Container.js index 1825ba5f0..ffb0566cc 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Container.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Container.js @@ -6,6 +6,7 @@ this.allowedChildTypes = allowedChildTypes; this.children = children; this.isContainer = true; + this.containerTemplateStyles = {}; var self = this; @@ -139,6 +140,17 @@ else if (!!this.parent) this.parent.pasteChild(child); } + + this.getContainerTemplateStyles = function () { + var styles = this.containerTemplateStyles || {}; + var css = ""; + + for (var property in styles) { + css += property + ":" + styles[property] + ";"; + } + + return css; + } }; })(LayoutEditor || (LayoutEditor = {})); \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Element.js b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Element.js index 6a983cf25..94e2533a5 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Element.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Element.js @@ -13,6 +13,7 @@ this.isTemplated = isTemplated; this.rule = rule; + this.templateStyles = {}; this.editor = null; this.parent = null; this.setIsFocusedEventHandlers = []; @@ -191,6 +192,17 @@ if (!!this.parent) this.parent.paste(clipboardData); }; + + this.getTemplateStyles = function () { + var styles = this.templateStyles || {}; + var css = ""; + + for (var property in styles) { + css += property + ":" + styles[property] + ";"; + } + + return css; + } }; })(LayoutEditor || (LayoutEditor = {})); \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutEditor.js b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutEditor.js index e99092f91..b5c6420a9 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutEditor.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutEditor.js @@ -202,6 +202,19 @@ angular $scope.delete = function (element) { element.delete(); } + + if ($scope.element.hasEditor) { + $scope.edit = function () { + $scope.$root.editElement($scope.element).then(function (args) { + $scope.$apply(function () { + if (args.cancel) + return; + + $scope.element.data = args.element.data; + }); + }); + }; + } }, configureForContainer: function ($scope, $element) { @@ -622,17 +635,19 @@ angular controller: ["$scope", "$element", function ($scope, $element) { scopeConfigurator.configureForElement($scope, $element); - $scope.edit = function () { - $scope.$root.editElement($scope.element).then(function (args) { - $scope.$apply(function () { - if (args.cancel) - return; + if ($scope.element.hasEditor) { + $scope.edit = function () { + $scope.$root.editElement($scope.element).then(function (args) { + $scope.$apply(function () { + if (args.cancel) + return; - $scope.element.data = args.element.data; - $scope.element.setHtml(args.element.html); + $scope.element.data = args.element.data; + $scope.element.setHtml(args.element.html); + }); }); - }); - }; + }; + } // Overwrite the setHtml function so that we can use the $sce service to trust the html (and not have the html binding strip certain tags). $scope.element.setHtml = function (html) { @@ -648,47 +663,6 @@ angular }; } ]); -angular - .module("LayoutEditor") - .directive("orcLayoutHtml", ["$sce", "scopeConfigurator", "environment", - function ($sce, scopeConfigurator, environment) { - return { - restrict: "E", - scope: { element: "=" }, - controller: ["$scope", "$element", - function ($scope, $element) { - scopeConfigurator.configureForElement($scope, $element); - $scope.edit = function () { - $scope.$root.editElement($scope.element).then(function (args) { - $scope.$apply(function () { - if (args.cancel) - return; - - $scope.element.data = args.element.data; - $scope.element.setHtml(args.element.html); - }); - }); - }; - $scope.updateContent = function (e) { - $scope.element.setHtml(e.target.innerHTML); - }; - - // Overwrite the setHtml function so that we can use the $sce service to trust the html (and not have the html binding strip certain tags). - $scope.element.setHtml = function (html) { - $scope.element.html = html; - $scope.element.htmlUnsafe = $sce.trustAsHtml(html); - }; - - $scope.element.setHtml($scope.element.html); - } - ], - templateUrl: environment.templateUrl("Html"), - replace: true, - link: function (scope, element) { - } - }; - } - ]); angular .module("LayoutEditor") .directive("orcLayoutGrid", ["$compile", "scopeConfigurator", "environment", @@ -999,4 +973,4 @@ angular }; } ]); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["LayoutEditor.js","Module.js","Clipboard.js","ScopeConfigurator.js","Editor.js","Canvas.js","Child.js","Column.js","Content.js","Html.js","Grid.js","Row.js","Popup.js","Toolbox.js","ToolboxGroup.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA,ACLA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACjUA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACzIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC9MA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"LayoutEditor.js","sourcesContent":[null,"angular.module(\"LayoutEditor\", [\"ngSanitize\", \"ngResource\", \"ui.sortable\"]);","var LayoutEditor;\r\n(function(LayoutEditor) {\r\n\r\n    var Clipboard = function () {\r\n        var self = this;\r\n        this._clipboardData = {};\r\n        this._isDisabled = false;\r\n        this._wasInvoked = false;\r\n\r\n        this.setData = function(contentType, data) {\r\n            self._clipboardData[contentType] = data;\r\n            self._wasInvoked = true;\r\n        };\r\n        this.getData = function (contentType) {\r\n            return self._clipboardData[contentType];\r\n            self._wasInvoked = true;\r\n        };\r\n        this.disable = function() {\r\n            self._isDisabled = true;\r\n            self._wasInvoked = false;\r\n            self._clipboardData = {};\r\n        };\r\n        this.isDisabled = function () {\r\n            return self._isDisabled;\r\n        }\r\n        this.wasInvoked = function () {\r\n            return self._wasInvoked;\r\n        }\r\n    }\r\n\r\n    LayoutEditor.Clipboard = new Clipboard();\r\n\r\n    angular\r\n        .module(\"LayoutEditor\")\r\n        .factory(\"clipboard\", [\r\n            function() {\r\n                return {\r\n                    setData: LayoutEditor.Clipboard.setData,\r\n                    getData: LayoutEditor.Clipboard.getData,\r\n                    disable: LayoutEditor.Clipboard.disable,\r\n                    isDisabled: LayoutEditor.Clipboard.isDisabled,\r\n                    wasInvoked: LayoutEditor.Clipboard.wasInvoked\r\n                };\r\n            }\r\n        ]);\r\n})(LayoutEditor || (LayoutEditor = {}));","angular\r\n    .module(\"LayoutEditor\")\r\n    .factory(\"scopeConfigurator\", [\"$timeout\", \"clipboard\",\r\n        function ($timeout, clipboard) {\r\n            return {\r\n\r\n                configureForElement: function ($scope, $element) {\r\n                \r\n                    $element.find(\".layout-panel\").click(function (e) {\r\n                        e.stopPropagation();\r\n                    });\r\n\r\n                    $element.parent().keydown(function (e) {\r\n                        var handled = false;\r\n                        var resetFocus = false;\r\n                        var element = $scope.element;\r\n                    \r\n                        if (element.editor.isDragging)\r\n                            return;\r\n\r\n                        // If native clipboard support exists, the pseudo-clipboard will have been disabled.\r\n                        if (!clipboard.isDisabled()) {\r\n                            var focusedElement = element.editor.focusedElement;\r\n                            if (!!focusedElement) {\r\n                                // Pseudo clipboard handling for browsers not allowing real clipboard operations.\r\n                                if (e.ctrlKey) {\r\n                                    switch (e.which) {\r\n                                    case 67: // C\r\n                                        focusedElement.copy(clipboard);\r\n                                        break;\r\n                                    case 88: // X\r\n                                        focusedElement.cut(clipboard);\r\n                                        break;\r\n                                    case 86: // V\r\n                                        focusedElement.paste(clipboard);\r\n                                        break;\r\n                                    }\r\n                                }\r\n                            }\r\n                        }\r\n\r\n                        if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 46) { // Del\r\n                            $scope.delete(element);\r\n                            handled = true;\r\n                        } else if (!e.ctrlKey && !e.shiftKey && !e.altKey && (e.which == 32 || e.which == 27)) { // Space or Esc\r\n                            $element.find(\".layout-panel-action-properties\").first().click();\r\n                            handled = true;\r\n                        }\r\n\r\n                        if (element.type == \"Content\") { // This is a content element.\r\n                            if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 13) { // Enter\r\n                                $element.find(\".layout-panel-action-edit\").first().click();\r\n                                handled = true;\r\n                            }\r\n                        }\r\n\r\n                        if (!!element.children) { // This is a container.\r\n                            if (!e.ctrlKey && !e.shiftKey && e.altKey && e.which == 40) { // Alt+Down\r\n                                if (element.children.length > 0)\r\n                                    element.children[0].setIsFocused();\r\n                                handled = true;\r\n                            }\r\n\r\n                            if (element.type == \"Column\") { // This is a column.\r\n                                var connectAdjacent = !e.ctrlKey;\r\n                                if (e.which == 37) { // Left\r\n                                    if (e.altKey)\r\n                                        element.expandLeft(connectAdjacent);\r\n                                    if (e.shiftKey)\r\n                                        element.contractRight(connectAdjacent);\r\n                                    handled = true;\r\n                                } else if (e.which == 39) { // Right\r\n                                    if (e.altKey)\r\n                                        element.contractLeft(connectAdjacent);\r\n                                    if (e.shiftKey)\r\n                                        element.expandRight(connectAdjacent);\r\n                                    handled = true;\r\n                                }\r\n                            }\r\n                        }\r\n\r\n                        if (!!element.parent) { // This is a child.\r\n                            if (e.altKey && e.which == 38) { // Alt+Up\r\n                                element.parent.setIsFocused();\r\n                                handled = true;\r\n                            }\r\n\r\n                            if (element.parent.type == \"Row\") { // Parent is a horizontal container.\r\n                                if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 37) { // Left\r\n                                    element.parent.moveFocusPrevChild(element);\r\n                                    handled = true;\r\n                                }\r\n                                else if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 39) { // Right\r\n                                    element.parent.moveFocusNextChild(element);\r\n                                    handled = true;\r\n                                }\r\n                                else if (e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 37) { // Ctrl+Left\r\n                                    element.moveUp();\r\n                                    resetFocus = true;\r\n                                    handled = true;\r\n                                }\r\n                                else if (e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 39) { // Ctrl+Right\r\n                                    element.moveDown();\r\n                                    handled = true;\r\n                                }\r\n                            }\r\n                            else { // Parent is a vertical container.\r\n                                if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 38) { // Up\r\n                                    element.parent.moveFocusPrevChild(element);\r\n                                    handled = true;\r\n                                }\r\n                                else if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 40) { // Down\r\n                                    element.parent.moveFocusNextChild(element);\r\n                                    handled = true;\r\n                                }\r\n                                else if (e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 38) { // Ctrl+Up\r\n                                    element.moveUp();\r\n                                    resetFocus = true;\r\n                                    handled = true;\r\n                                }\r\n                                else if (e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 40) { // Ctrl+Down\r\n                                    element.moveDown();\r\n                                    handled = true;\r\n                                }\r\n                            }\r\n                        }\r\n\r\n                        if (handled) {\r\n                            e.preventDefault();\r\n                        }\r\n\r\n                        e.stopPropagation();\r\n\r\n                        $scope.$apply(); // Event is not triggered by Angular directive but raw event handler on element.\r\n\r\n                        // HACK: Workaround because of how Angular treats the DOM when elements are shifted around - input focus is sometimes lost.\r\n                        if (resetFocus) {\r\n                            window.setTimeout(function () {\r\n                                $scope.$apply(function () {\r\n                                    element.editor.focusedElement.setIsFocused();\r\n                                });\r\n                            }, 100);\r\n                        }\r\n                    });\r\n\r\n                    $scope.element.setIsFocusedEventHandlers.push(function () {\r\n                        $element.parent().focus();\r\n                    });\r\n\r\n                    $scope.delete = function (element) {\r\n                        element.delete();\r\n                    }\r\n                },\r\n\r\n                configureForContainer: function ($scope, $element) {\r\n                    var element = $scope.element;\r\n\r\n                    //$scope.isReceiving = false; // True when container is receiving an external element via drag/drop.\r\n                    $scope.getShowChildrenPlaceholder = function () {\r\n                        return $scope.element.children.length === 0 && !$scope.element.getIsDropTarget();\r\n                    };\r\n\r\n                    $scope.sortableOptions = {\r\n                        cursor: \"move\",\r\n                        delay: 150,\r\n                        disabled: element.getIsSealed(),\r\n                        distance: 5,\r\n                        //handle: element.children.length < 2 ? \".imaginary-class\" : false, // For some reason doesn't get re-evaluated after adding more children.\r\n                        start: function (e, ui) {\r\n                            $scope.$apply(function () {\r\n                                element.setIsDropTarget(true);\r\n                                element.editor.isDragging = true;\r\n                            });\r\n                            // Make the drop target placeholder as high as the item being dragged.\r\n                            ui.placeholder.height(ui.item.height() - 4);\r\n                            ui.placeholder.css(\"min-height\", 0);\r\n                        },\r\n                        stop: function (e, ui) {\r\n                            $scope.$apply(function () {\r\n                                element.editor.isDragging = false;\r\n                                element.setIsDropTarget(false);\r\n                            });\r\n                        },\r\n                        over: function (e, ui) {\r\n                            if (!!ui.sender && !!ui.sender[0].isToolbox) {\r\n                                if (!!ui.sender[0].dropTargetTimeout) {\r\n                                    $timeout.cancel(ui.sender[0].dropTargetTimeout);\r\n                                    ui.sender[0].dropTargetTimeout = null;\r\n                                }\r\n                                $timeout(function () {\r\n                                    if (element.type == \"Row\") {\r\n                                        // If there was a previous drop target and it was a row, roll back any pending column adds to it.\r\n                                        var previousDropTarget = element.editor.dropTargetElement;\r\n                                        if (!!previousDropTarget && previousDropTarget.type == \"Row\")\r\n                                            previousDropTarget.rollbackAddColumn();\r\n                                    }\r\n                                    element.setIsDropTarget(false);\r\n                                });\r\n                                ui.sender[0].dropTargetTimeout = $timeout(function () {\r\n                                    if (element.type == \"Row\") {\r\n                                        var receivedColumn = ui.item.sortable.model;\r\n                                        var receivedColumnWidth = Math.floor(12 / (element.children.length + 1));\r\n                                        receivedColumn.width = receivedColumnWidth;\r\n                                        receivedColumn.offset = 0;\r\n                                        element.beginAddColumn(receivedColumnWidth);\r\n                                        // Make the drop target placeholder the correct width and as high as the highest existing column in the row.\r\n                                        var maxHeight = _.max(_($element.find(\"> .layout-children > .layout-column:not(.ui-sortable-placeholder)\")).map(function (e) {\r\n                                            return $(e).height();\r\n                                        }));\r\n                                        for (i = 1; i <= 12; i++)\r\n                                            ui.placeholder.removeClass(\"col-xs-\" + i);\r\n                                        ui.placeholder.addClass(\"col-xs-\" + receivedColumn.width);\r\n                                        if (maxHeight > 0) {\r\n                                            ui.placeholder.height(maxHeight);\r\n                                            ui.placeholder.css(\"min-height\", 0);\r\n                                        }\r\n                                        else {\r\n                                            ui.placeholder.height(0);\r\n                                            ui.placeholder.css(\"min-height\", \"\");\r\n                                        }\r\n                                    }\r\n                                    element.setIsDropTarget(true);\r\n                                }, 150);\r\n                            }\r\n                        },\r\n                        receive: function (e, ui) {\r\n                            if (!!ui.sender && !!ui.sender[0].isToolbox) {\r\n                                $scope.$apply(function () {\r\n                                    var receivedElement = ui.item.sortable.model;\r\n                                    if (!!receivedElement) {\r\n                                        if (element.type == \"Row\")\r\n                                            element.commitAddColumn();\r\n                                        // Should ideally call LayoutEditor.Container.addChild() instead, but since this handler\r\n                                        // is run *before* the ui-sortable directive's handler, if we try to add the child to the\r\n                                        // array that handler will get an exception when trying to do the same.\r\n                                        // Because of this, we need to invoke \"setParent\" so that specific container types can perform element speficic initialization.\r\n                                        receivedElement.setEditor(element.editor);\r\n                                        receivedElement.setParent(element);\r\n\r\n                                        if (!!receivedElement.hasEditor) {\r\n                                            $scope.$root.editElement(receivedElement).then(function (args) {\r\n                                                if (!args.cancel) {\r\n                                                    receivedElement.data = args.element.data;\r\n                                                    receivedElement.applyElementEditorModel(args.elementEditorModel);\r\n\r\n                                                    if (!!receivedElement.setHtml)\r\n                                                        receivedElement.setHtml(args.element.html);\r\n                                                }\r\n                                                $timeout(function () {\r\n                                                    if (!!args.cancel)\r\n                                                        receivedElement.delete();\r\n                                                    else\r\n                                                        receivedElement.setIsFocused();\r\n                                                    //$scope.isReceiving = false;\r\n                                                    element.setIsDropTarget(false);\r\n\r\n                                                });\r\n                                                return;\r\n                                            });\r\n                                        }\r\n                                    }\r\n                                    $timeout(function () {\r\n                                        //$scope.isReceiving = false;\r\n                                        element.setIsDropTarget(false);\r\n                                        if (!!receivedElement)\r\n                                            receivedElement.setIsFocused();\r\n                                    });\r\n                                });\r\n                            }\r\n                        }\r\n                    };\r\n\r\n                    $scope.click = function (child, e) {\r\n                        if (!child.editor.isDragging)\r\n                            child.setIsFocused();\r\n                        e.stopPropagation();\r\n                    };\r\n\r\n                    $scope.getClasses = function (child) {\r\n                        var result = [\"layout-element\"];\r\n\r\n                        if (!!child.children) {\r\n                            result.push(\"layout-container\");\r\n                            if (child.getIsSealed())\r\n                                result.push(\"layout-container-sealed\");\r\n                        }\r\n\r\n                        result.push(\"layout-\" + child.type.toLowerCase());\r\n\r\n                        if (!!child.dropTargetClass)\r\n                            result.push(child.dropTargetClass);\r\n\r\n                        // TODO: Move these to either the Column directive or the Column model class.\r\n                        if (child.type == \"Row\") {\r\n                            result.push(\"row\");\r\n                            if (!child.canAddColumn())\r\n                                result.push(\"layout-row-full\");\r\n                        }\r\n                        if (child.type == \"Column\") {\r\n                            result.push(\"col-xs-\" + child.width);\r\n                            result.push(\"col-xs-offset-\" + child.offset);\r\n                        }\r\n                        if (child.type == \"Content\")\r\n                            result.push(\"layout-content-\" + child.contentTypeClass);\r\n\r\n                        if (child.getIsActive())\r\n                            result.push(\"layout-element-active\");\r\n                        if (child.getIsFocused())\r\n                            result.push(\"layout-element-focused\");\r\n                        if (child.getIsSelected())\r\n                            result.push(\"layout-element-selected\");\r\n                        if (child.getIsDropTarget())\r\n                            result.push(\"layout-element-droptarget\");\r\n                        if (child.isTemplated)\r\n                            result.push(\"layout-element-templated\");\r\n\r\n                        return result;\r\n                    };\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutEditor\", [\"environment\",\r\n        function (environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: {},\r\n                controller: [\"$scope\", \"$element\", \"$attrs\", \"$compile\", \"clipboard\",\r\n                    function ($scope, $element, $attrs, $compile, clipboard) {\r\n                        if (!!$attrs.model)\r\n                            $scope.element = eval($attrs.model);\r\n                        else\r\n                            throw new Error(\"The 'model' attribute must evaluate to a LayoutEditor.Editor object.\");\r\n\r\n                        $scope.click = function (canvas, e) {\r\n                            if (!canvas.editor.isDragging)\r\n                                canvas.setIsFocused();\r\n                            e.stopPropagation();\r\n                        };\r\n\r\n                        $scope.getClasses = function (canvas) {\r\n                            var result = [\"layout-element\", \"layout-container\", \"layout-canvas\"];\r\n\r\n                            if (canvas.getIsActive())\r\n                                result.push(\"layout-element-active\");\r\n                            if (canvas.getIsFocused())\r\n                                result.push(\"layout-element-focused\");\r\n                            if (canvas.getIsSelected())\r\n                                result.push(\"layout-element-selected\");\r\n                            if (canvas.getIsDropTarget())\r\n                                result.push(\"layout-element-droptarget\");\r\n                            if (canvas.isTemplated)\r\n                                result.push(\"layout-element-templated\");\r\n\r\n                            return result;\r\n                        };\r\n\r\n                        // An unfortunate side-effect of the next hack on line 54 is that the created elements aren't added to the DOM yet, so we can't use it to get to the parent \".layout-desiger\" element.\r\n                        // Work around: access that element directly (which efectively turns multiple layout editors on a single page impossible). \r\n                        // //var layoutDesignerHost = $element.closest(\".layout-designer\").data(\"layout-designer-host\");\r\n                        var layoutDesignerHost = $(\".layout-designer\").data(\"layout-designer-host\");\r\n\r\n                        $scope.$root.layoutDesignerHost = layoutDesignerHost;\r\n\r\n                        layoutDesignerHost.element.on(\"replacecanvas\", function (e, args) {\r\n                            var editor = $scope.element;\r\n                            var canvasData = {\r\n                                data: args.canvas.data,\r\n                                htmlId: args.canvas.htmlId,\r\n                                htmlClass: args.canvas.htmlClass,\r\n                                htmlStyle: args.canvas.htmlStyle,\r\n                                isTemplated: args.canvas.isTemplated,\r\n                                children: args.canvas.children\r\n                            };\r\n\r\n                            // HACK: Instead of simply updating the $scope.element with a new instance, we need to replace the entire orc-layout-editor markup\r\n                            // in order for angular to rebind starting with the Canvas element. Otherwise, for some reason, it will rebind starting with the first child of Canvas.\r\n                            // You can see this happening when setting a breakpoint in ScopeConfigurator where containers are initialized with drag & drop: on page load, the first element\r\n                            // is a Canvas (good), but after having selected another template, the first element is (typically) a Grid (bad).\r\n                            // Simply recompiling the orc-layout-editor directive will cause the entire thing to be generated, which works just fine as well (even though not is nice as simply leveraging model binding).\r\n                            layoutDesignerHost.editor = window.layoutEditor = new LayoutEditor.Editor(editor.config, canvasData);\r\n                            var template = \"<orc-layout-editor\" + \" model='window.layoutEditor' />\";\r\n                            var html = $compile(template)($scope);\r\n                            $(\".layout-editor-holder\").html(html);\r\n                        });\r\n\r\n                        $scope.$root.editElement = function (element) {\r\n                            var host = $scope.$root.layoutDesignerHost;\r\n                            return host.editElement(element);\r\n                        };\r\n\r\n                        $scope.$root.addElement = function (contentType) {\r\n                            var host = $scope.$root.layoutDesignerHost;\r\n                            return host.addElement(contentType);\r\n                        };\r\n\r\n                        $(document).on(\"cut copy paste\", function (e) {\r\n                            // If the pseudo clipboard was already invoked (which happens on the first clipboard\r\n                            // operation after page load even if native clipboard support exists) then sit this\r\n                            // one operation out, but make sure whatever is on the pseudo clipboard gets migrated\r\n                            // to the native clipboard for subsequent operations.\r\n                            if (clipboard.wasInvoked()) {\r\n                                e.originalEvent.clipboardData.setData(\"text/plain\", clipboard.getData(\"text/plain\"));\r\n                                e.originalEvent.clipboardData.setData(\"text/json\", clipboard.getData(\"text/json\"));\r\n                                e.preventDefault();\r\n                            }\r\n                            else {\r\n                                var focusedElement = $scope.element.focusedElement;\r\n                                if (!!focusedElement) {\r\n                                    $scope.$apply(function () {\r\n                                        switch (e.type) {\r\n                                            case \"copy\":\r\n                                                focusedElement.copy(e.originalEvent.clipboardData);\r\n                                                break;\r\n                                            case \"cut\":\r\n                                                focusedElement.cut(e.originalEvent.clipboardData);\r\n                                                break;\r\n                                            case \"paste\":\r\n                                                focusedElement.paste(e.originalEvent.clipboardData);\r\n                                                break;\r\n                                        }\r\n                                    });\r\n\r\n                                    // HACK: Workaround because of how Angular treats the DOM when elements are shifted around - input focus is sometimes lost.\r\n                                    window.setTimeout(function () {\r\n                                        $scope.$apply(function () {\r\n                                            if (!!$scope.element.focusedElement)\r\n                                                $scope.element.focusedElement.setIsFocused();\r\n                                        });\r\n                                    }, 100);\r\n\r\n                                    e.preventDefault();\r\n                                }\r\n                            }\r\n\r\n                            // Native clipboard support obviously exists, so disable the peudo clipboard from now on.\r\n                            clipboard.disable();\r\n                        });\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Editor\"),\r\n                replace: true,\r\n                link: function (scope, element) {\r\n                    // No clicks should propagate from the TinyMCE toolbars.\r\n                    element.find(\".layout-toolbar-container\").click(function (e) {\r\n                        e.stopPropagation();\r\n                    });\r\n                    // Unfocus and unselect everything on click outside of canvas.\r\n                    $(window).click(function (e) {\r\n                        scope.$apply(function () {\r\n                            scope.element.activeElement = null;\r\n                            scope.element.focusedElement = null;\r\n                        });\r\n                    });\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutCanvas\", [\"scopeConfigurator\", \"environment\",\r\n        function (scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\", \"$attrs\",\r\n                    function ($scope, $element, $attrs) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        scopeConfigurator.configureForContainer($scope, $element);\r\n                        $scope.sortableOptions[\"axis\"] = \"y\";\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Canvas\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutChild\", [\"$compile\",\r\n        function ($compile) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                link: function (scope, element) {\r\n                    var template = \"<orc-layout-\" + scope.element.type.toLowerCase() + \" element='element' />\";\r\n                    var html = $compile(template)(scope);\r\n                    $(element).replaceWith(html);\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutColumn\", [\"$compile\", \"scopeConfigurator\", \"environment\",\r\n        function ($compile, scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        scopeConfigurator.configureForContainer($scope, $element);\r\n                        $scope.sortableOptions[\"axis\"] = \"y\";\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Column\"),\r\n                replace: true,\r\n                link: function (scope, element, attrs) {\r\n                    element.find(\".layout-column-resize-bar\").draggable({\r\n                        axis: \"x\",\r\n                        helper: \"clone\",\r\n                        revert: true,\r\n                        start: function (e, ui) {\r\n                            scope.$apply(function () {\r\n                                scope.element.editor.isResizing = true;\r\n                            });\r\n                        },\r\n                        drag: function (e, ui) {\r\n                            var columnElement = element.parent();\r\n                            var columnSize = columnElement.width() / scope.element.width;\r\n                            var connectAdjacent = !e.ctrlKey;\r\n                            if ($(e.target).hasClass(\"layout-column-resize-bar-left\")) {\r\n                                var delta = ui.offset.left - columnElement.offset().left;\r\n                                if (delta < -columnSize && scope.element.canExpandLeft(connectAdjacent)) {\r\n                                    scope.$apply(function () {\r\n                                        scope.element.expandLeft(connectAdjacent);\r\n                                    });\r\n                                }\r\n                                else if (delta > columnSize && scope.element.canContractLeft(connectAdjacent)) {\r\n                                    scope.$apply(function () {\r\n                                        scope.element.contractLeft(connectAdjacent);\r\n                                    });\r\n                                }\r\n                            }\r\n                            else if ($(e.target).hasClass(\"layout-column-resize-bar-right\")) {\r\n                                var delta = ui.offset.left - columnElement.width() - columnElement.offset().left;\r\n                                if (delta > columnSize && scope.element.canExpandRight(connectAdjacent)) {\r\n                                    scope.$apply(function () {\r\n                                        scope.element.expandRight(connectAdjacent);\r\n                                    });\r\n                                }\r\n                                else if (delta < -columnSize && scope.element.canContractRight(connectAdjacent)) {\r\n                                    scope.$apply(function () {\r\n                                        scope.element.contractRight(connectAdjacent);\r\n                                    });\r\n                                }\r\n                            }\r\n\r\n                        },\r\n                        stop: function (e, ui) {\r\n                            scope.$apply(function () {\r\n                              scope.element.editor.isResizing = false;\r\n                            });\r\n                        }\r\n                    });\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutContent\", [\"$sce\", \"scopeConfigurator\", \"environment\",\r\n        function ($sce, scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        $scope.edit = function () {\r\n                            $scope.$root.editElement($scope.element).then(function (args) {\r\n                                $scope.$apply(function () {\r\n                                    if (args.cancel)\r\n                                        return;\r\n\r\n                                    $scope.element.data = args.element.data;\r\n                                    $scope.element.setHtml(args.element.html);\r\n                                });\r\n                            });\r\n                        };\r\n\r\n                        // Overwrite the setHtml function so that we can use the $sce service to trust the html (and not have the html binding strip certain tags).\r\n                        $scope.element.setHtml = function (html) {\r\n                            $scope.element.html = html;\r\n                            $scope.element.htmlUnsafe = $sce.trustAsHtml(html);\r\n                        };\r\n\r\n                        $scope.element.setHtml($scope.element.html);\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Content\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutHtml\", [\"$sce\", \"scopeConfigurator\", \"environment\",\r\n        function ($sce, scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        $scope.edit = function () {\r\n                            $scope.$root.editElement($scope.element).then(function (args) {\r\n                                $scope.$apply(function () {\r\n                                    if (args.cancel)\r\n                                        return;\r\n\r\n                                    $scope.element.data = args.element.data;\r\n                                    $scope.element.setHtml(args.element.html);\r\n                                });\r\n                            });\r\n                        };\r\n                        $scope.updateContent = function (e) {\r\n                            $scope.element.setHtml(e.target.innerHTML);\r\n                        };\r\n\r\n                        // Overwrite the setHtml function so that we can use the $sce service to trust the html (and not have the html binding strip certain tags).\r\n                        $scope.element.setHtml = function (html) {\r\n                            $scope.element.html = html;\r\n                            $scope.element.htmlUnsafe = $sce.trustAsHtml(html);\r\n                        };\r\n\r\n                        $scope.element.setHtml($scope.element.html);\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Html\"),\r\n                replace: true,\r\n                link: function (scope, element) {\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutGrid\", [\"$compile\", \"scopeConfigurator\", \"environment\",\r\n        function ($compile, scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        scopeConfigurator.configureForContainer($scope, $element);\r\n                        $scope.sortableOptions[\"axis\"] = \"y\";\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Grid\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutRow\", [\"$compile\", \"scopeConfigurator\", \"environment\",\r\n        function ($compile, scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        scopeConfigurator.configureForContainer($scope, $element);\r\n                        $scope.sortableOptions[\"axis\"] = \"x\";\r\n                        $scope.sortableOptions[\"ui-floating\"] = true;\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Row\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutPopup\", [\r\n        function () {\r\n            return {\r\n                restrict: \"A\",\r\n                link: function (scope, element, attrs) {\r\n                    var popup = $(element);\r\n                    var trigger = popup.closest(\".layout-popup-trigger\");\r\n                    var parentElement = popup.closest(\".layout-element\");\r\n                    trigger.click(function () {\r\n                        popup.toggle();\r\n                        if (popup.is(\":visible\")) {\r\n                            popup.position({\r\n                                my: attrs.orcLayoutPopupMy || \"left top\",\r\n                                at: attrs.orcLayoutPopupAt || \"left bottom+4px\",\r\n                                of: trigger\r\n                            });\r\n                            popup.find(\"input\").first().focus();\r\n                        }\r\n                    });\r\n                    popup.click(function (e) {\r\n                        e.stopPropagation();\r\n                    });\r\n                    parentElement.click(function (e) {\r\n                        popup.hide();\r\n                    });\r\n                    popup.keydown(function (e) {\r\n                        if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 27) // Esc\r\n                            popup.hide();\r\n                        e.stopPropagation();\r\n                    });\r\n                    popup.on(\"cut copy paste\", function (e) {\r\n                        // Allow clipboard operations in popup without invoking clipboard event handlers on parent element.\r\n                        e.stopPropagation();\r\n                    });\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutToolbox\", [\"$compile\", \"environment\",\r\n        function ($compile, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n\r\n                        $scope.resetElements = function () {\r\n\r\n                            $scope.gridElements = [\r\n                                LayoutEditor.Grid.from({\r\n                                    toolboxIcon: \"\\uf00a\",\r\n                                    toolboxLabel: \"Grid\",\r\n                                    toolboxDescription: \"Empty grid.\",\r\n                                    children: []\r\n                                })\r\n                            ];\r\n\r\n                            $scope.rowElements = [\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (1 column)\",\r\n                                    toolboxDescription: \"Row with 1 column.\",\r\n                                    children: LayoutEditor.Column.times(1)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (2 columns)\",\r\n                                    toolboxDescription: \"Row with 2 columns.\",\r\n                                    children: LayoutEditor.Column.times(2)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (3 columns)\",\r\n                                    toolboxDescription: \"Row with 3 columns.\",\r\n                                    children: LayoutEditor.Column.times(3)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (4 columns)\",\r\n                                    toolboxDescription: \"Row with 4 columns.\",\r\n                                    children: LayoutEditor.Column.times(4)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (6 columns)\",\r\n                                    toolboxDescription: \"Row with 6 columns.\",\r\n                                    children: LayoutEditor.Column.times(6)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (12 columns)\",\r\n                                    toolboxDescription: \"Row with 12 columns.\",\r\n                                    children: LayoutEditor.Column.times(12)\r\n                                }), LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (empty)\",\r\n                                    toolboxDescription: \"Empty row.\",\r\n                                    children: []\r\n                                })\r\n                            ];\r\n\r\n                            $scope.columnElements = [\r\n                                LayoutEditor.Column.from({\r\n                                    toolboxIcon: \"\\uf0db\",\r\n                                    toolboxLabel: \"Column\",\r\n                                    toolboxDescription: \"Empty column.\",\r\n                                    width: 1,\r\n                                    offset: 0,\r\n                                    children: []\r\n                                })\r\n                            ];\r\n\r\n                            $scope.canvasElements = [\r\n                                LayoutEditor.Canvas.from({\r\n                                    toolboxIcon: \"\\uf044\",\r\n                                    toolboxLabel: \"Canvas\",\r\n                                    toolboxDescription: \"Empty canvas.\",\r\n                                    children: []\r\n                                })\r\n                            ];\r\n\r\n                            $scope.contentElementCategories = _($scope.element.config.categories).map(function (category) {\r\n                                return {\r\n                                    name: category.name,\r\n                                    elements: _(category.contentTypes).map(function (contentType) {\r\n                                        var type = contentType.type;\r\n                                        var factory = LayoutEditor.factories[type] || LayoutEditor.factories[\"Content\"];\r\n                                        var item = {\r\n                                            isTemplated: false,\r\n                                            contentType: contentType.id,\r\n                                            contentTypeLabel: contentType.label,\r\n                                            contentTypeClass: contentType.typeClass,\r\n                                            data: null,\r\n                                            hasEditor: contentType.hasEditor,\r\n                                            html: contentType.html\r\n                                        };\r\n                                        var element = factory(item);\r\n                                        element.toolboxIcon = contentType.icon || \"\\uf1c9\";\r\n                                        element.toolboxLabel = contentType.label;\r\n                                        element.toolboxDescription = contentType.description;\r\n                                        return element;\r\n                                    })\r\n                                };\r\n                            });\r\n\r\n                        };\r\n\r\n                        $scope.resetElements();\r\n\r\n                        $scope.getSortableOptions = function (type) {\r\n                            var editorId = $element.closest(\".layout-editor\").attr(\"id\");\r\n                            var parentClasses;\r\n                            var placeholderClasses;\r\n                            var floating = false;\r\n\r\n                            switch (type) {\r\n                                case \"Grid\":\r\n                                    parentClasses = [\".layout-canvas\", \".layout-column\", \".layout-common-holder\"];\r\n                                    placeholderClasses = \"layout-element layout-container layout-grid ui-sortable-placeholder\";\r\n                                    break;\r\n                                case \"Row\":\r\n                                    parentClasses = [\".layout-grid\"];\r\n                                    placeholderClasses = \"layout-element layout-container layout-row row ui-sortable-placeholder\";\r\n                                    break;\r\n                                case \"Column\":\r\n                                    parentClasses = [\".layout-row:not(.layout-row-full)\"];\r\n                                    placeholderClasses = \"layout-element layout-container layout-column ui-sortable-placeholder\";\r\n                                    floating = true; // To ensure a smooth horizontal-list reordering. https://github.com/angular-ui/ui-sortable#floating\r\n                                    break;\r\n                                case \"Content\":\r\n                                    parentClasses = [\".layout-canvas\", \".layout-column\", \".layout-common-holder\"];\r\n                                    placeholderClasses = \"layout-element layout-content ui-sortable-placeholder\";\r\n                                    break;\r\n                                case \"Canvas\":\r\n                                    parentClasses = [\".layout-canvas\", \".layout-column\", \".layout-common-holder\"];\r\n                                    placeholderClasses = \"layout-element layout-container layout-grid ui-sortable-placeholder\";\r\n                                    break;\r\n                            }\r\n\r\n                            return {\r\n                                cursor: \"move\",\r\n                                connectWith: _(parentClasses).map(function (e) { return \"#\" + editorId + \" \" + e + \":not(.layout-container-sealed) > .layout-element-wrapper > .layout-children\"; }).join(\", \"),\r\n                                placeholder: placeholderClasses,\r\n                                \"ui-floating\": floating,\r\n                                create: function (e, ui) {\r\n                                    e.target.isToolbox = true; // Will indicate to connected sortables that dropped items were sent from toolbox.\r\n                                },\r\n                                start: function (e, ui) {\r\n                                    $scope.$apply(function () {\r\n                                        $scope.element.isDragging = true;\r\n                                    });\r\n                                },\r\n                                stop: function (e, ui) {\r\n                                    $scope.$apply(function () {\r\n                                        $scope.element.isDragging = false;\r\n                                        $scope.resetElements();\r\n                                    });\r\n                                },\r\n                                over: function (e, ui) {\r\n                                    $scope.$apply(function () {\r\n                                        $scope.element.canvas.setIsDropTarget(false);\r\n                                    });\r\n                                },\r\n                            }\r\n                        };\r\n\r\n                        var layoutIsCollapsedCookieName = \"layoutToolboxCategory_Layout_IsCollapsed\";\r\n                        $scope.layoutIsCollapsed = $.cookie(layoutIsCollapsedCookieName) === \"true\";\r\n\r\n                        $scope.toggleLayoutIsCollapsed = function (e) {\r\n                            $scope.layoutIsCollapsed = !$scope.layoutIsCollapsed;\r\n                            $.cookie(layoutIsCollapsedCookieName, $scope.layoutIsCollapsed, { expires: 365 }); // Remember collapsed state for a year.\r\n                            e.preventDefault();\r\n                            e.stopPropagation();\r\n                        };\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Toolbox\"),\r\n                replace: true,\r\n                link: function (scope, element) {\r\n                    var toolbox = element.find(\".layout-toolbox\");\r\n                    $(window).on(\"resize scroll\", function (e) {\r\n                        var canvas = element.parent().find(\".layout-canvas\");\r\n                        // If the canvas is taller than the toolbox, make the toolbox sticky-positioned within the editor\r\n                        // to help the user avoid excessive vertical scrolling.\r\n                        var canvasIsTaller = !!canvas && canvas.height() > toolbox.height();\r\n                        var windowPos = $(window).scrollTop();\r\n                        if (canvasIsTaller && windowPos > element.offset().top + element.height() - toolbox.height()) {\r\n                            toolbox.addClass(\"sticky-bottom\");\r\n                            toolbox.removeClass(\"sticky-top\");\r\n                        }\r\n                        else if (canvasIsTaller && windowPos > element.offset().top) {\r\n                            toolbox.addClass(\"sticky-top\");\r\n                            toolbox.removeClass(\"sticky-bottom\");\r\n                        }\r\n                        else {\r\n                            toolbox.removeClass(\"sticky-top\");\r\n                            toolbox.removeClass(\"sticky-bottom\");\r\n                        }\r\n                    });\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutToolboxGroup\", [\"$compile\", \"environment\",\r\n        function ($compile, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { category: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        var isCollapsedCookieName = \"layoutToolboxCategory_\" + $scope.category.name + \"_IsCollapsed\";\r\n                        $scope.isCollapsed = $.cookie(isCollapsedCookieName) === \"true\";\r\n                        $scope.toggleIsCollapsed = function (e) {\r\n                            $scope.isCollapsed = !$scope.isCollapsed;\r\n                            $.cookie(isCollapsedCookieName, $scope.isCollapsed, { expires: 365 }); // Remember collapsed state for a year.\r\n                            e.preventDefault();\r\n                            e.stopPropagation();\r\n                        };\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"ToolboxGroup\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);"],"sourceRoot":"/source/"} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["LayoutEditor.js","Module.js","Clipboard.js","ScopeConfigurator.js","Editor.js","Canvas.js","Child.js","Column.js","Content.js","Grid.js","Row.js","Popup.js","Toolbox.js","ToolboxGroup.js"],"names":[],"mappings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zIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACrCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC9MA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"LayoutEditor.js","sourcesContent":[null,"angular.module(\"LayoutEditor\", [\"ngSanitize\", \"ngResource\", \"ui.sortable\"]);","var LayoutEditor;\r\n(function(LayoutEditor) {\r\n\r\n    var Clipboard = function () {\r\n        var self = this;\r\n        this._clipboardData = {};\r\n        this._isDisabled = false;\r\n        this._wasInvoked = false;\r\n\r\n        this.setData = function(contentType, data) {\r\n            self._clipboardData[contentType] = data;\r\n            self._wasInvoked = true;\r\n        };\r\n        this.getData = function (contentType) {\r\n            return self._clipboardData[contentType];\r\n            self._wasInvoked = true;\r\n        };\r\n        this.disable = function() {\r\n            self._isDisabled = true;\r\n            self._wasInvoked = false;\r\n            self._clipboardData = {};\r\n        };\r\n        this.isDisabled = function () {\r\n            return self._isDisabled;\r\n        }\r\n        this.wasInvoked = function () {\r\n            return self._wasInvoked;\r\n        }\r\n    }\r\n\r\n    LayoutEditor.Clipboard = new Clipboard();\r\n\r\n    angular\r\n        .module(\"LayoutEditor\")\r\n        .factory(\"clipboard\", [\r\n            function() {\r\n                return {\r\n                    setData: LayoutEditor.Clipboard.setData,\r\n                    getData: LayoutEditor.Clipboard.getData,\r\n                    disable: LayoutEditor.Clipboard.disable,\r\n                    isDisabled: LayoutEditor.Clipboard.isDisabled,\r\n                    wasInvoked: LayoutEditor.Clipboard.wasInvoked\r\n                };\r\n            }\r\n        ]);\r\n})(LayoutEditor || (LayoutEditor = {}));","angular\r\n    .module(\"LayoutEditor\")\r\n    .factory(\"scopeConfigurator\", [\"$timeout\", \"clipboard\",\r\n        function ($timeout, clipboard) {\r\n            return {\r\n\r\n                configureForElement: function ($scope, $element) {\r\n                \r\n                    $element.find(\".layout-panel\").click(function (e) {\r\n                        e.stopPropagation();\r\n                    });\r\n\r\n                    $element.parent().keydown(function (e) {\r\n                        var handled = false;\r\n                        var resetFocus = false;\r\n                        var element = $scope.element;\r\n                    \r\n                        if (element.editor.isDragging)\r\n                            return;\r\n\r\n                        // If native clipboard support exists, the pseudo-clipboard will have been disabled.\r\n                        if (!clipboard.isDisabled()) {\r\n                            var focusedElement = element.editor.focusedElement;\r\n                            if (!!focusedElement) {\r\n                                // Pseudo clipboard handling for browsers not allowing real clipboard operations.\r\n                                if (e.ctrlKey) {\r\n                                    switch (e.which) {\r\n                                    case 67: // C\r\n                                        focusedElement.copy(clipboard);\r\n                                        break;\r\n                                    case 88: // X\r\n                                        focusedElement.cut(clipboard);\r\n                                        break;\r\n                                    case 86: // V\r\n                                        focusedElement.paste(clipboard);\r\n                                        break;\r\n                                    }\r\n                                }\r\n                            }\r\n                        }\r\n\r\n                        if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 46) { // Del\r\n                            $scope.delete(element);\r\n                            handled = true;\r\n                        } else if (!e.ctrlKey && !e.shiftKey && !e.altKey && (e.which == 32 || e.which == 27)) { // Space or Esc\r\n                            $element.find(\".layout-panel-action-properties\").first().click();\r\n                            handled = true;\r\n                        }\r\n\r\n                        if (element.type == \"Content\") { // This is a content element.\r\n                            if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 13) { // Enter\r\n                                $element.find(\".layout-panel-action-edit\").first().click();\r\n                                handled = true;\r\n                            }\r\n                        }\r\n\r\n                        if (!!element.children) { // This is a container.\r\n                            if (!e.ctrlKey && !e.shiftKey && e.altKey && e.which == 40) { // Alt+Down\r\n                                if (element.children.length > 0)\r\n                                    element.children[0].setIsFocused();\r\n                                handled = true;\r\n                            }\r\n\r\n                            if (element.type == \"Column\") { // This is a column.\r\n                                var connectAdjacent = !e.ctrlKey;\r\n                                if (e.which == 37) { // Left\r\n                                    if (e.altKey)\r\n                                        element.expandLeft(connectAdjacent);\r\n                                    if (e.shiftKey)\r\n                                        element.contractRight(connectAdjacent);\r\n                                    handled = true;\r\n                                } else if (e.which == 39) { // Right\r\n                                    if (e.altKey)\r\n                                        element.contractLeft(connectAdjacent);\r\n                                    if (e.shiftKey)\r\n                                        element.expandRight(connectAdjacent);\r\n                                    handled = true;\r\n                                }\r\n                            }\r\n                        }\r\n\r\n                        if (!!element.parent) { // This is a child.\r\n                            if (e.altKey && e.which == 38) { // Alt+Up\r\n                                element.parent.setIsFocused();\r\n                                handled = true;\r\n                            }\r\n\r\n                            if (element.parent.type == \"Row\") { // Parent is a horizontal container.\r\n                                if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 37) { // Left\r\n                                    element.parent.moveFocusPrevChild(element);\r\n                                    handled = true;\r\n                                }\r\n                                else if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 39) { // Right\r\n                                    element.parent.moveFocusNextChild(element);\r\n                                    handled = true;\r\n                                }\r\n                                else if (e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 37) { // Ctrl+Left\r\n                                    element.moveUp();\r\n                                    resetFocus = true;\r\n                                    handled = true;\r\n                                }\r\n                                else if (e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 39) { // Ctrl+Right\r\n                                    element.moveDown();\r\n                                    handled = true;\r\n                                }\r\n                            }\r\n                            else { // Parent is a vertical container.\r\n                                if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 38) { // Up\r\n                                    element.parent.moveFocusPrevChild(element);\r\n                                    handled = true;\r\n                                }\r\n                                else if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 40) { // Down\r\n                                    element.parent.moveFocusNextChild(element);\r\n                                    handled = true;\r\n                                }\r\n                                else if (e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 38) { // Ctrl+Up\r\n                                    element.moveUp();\r\n                                    resetFocus = true;\r\n                                    handled = true;\r\n                                }\r\n                                else if (e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 40) { // Ctrl+Down\r\n                                    element.moveDown();\r\n                                    handled = true;\r\n                                }\r\n                            }\r\n                        }\r\n\r\n                        if (handled) {\r\n                            e.preventDefault();\r\n                        }\r\n\r\n                        e.stopPropagation();\r\n\r\n                        $scope.$apply(); // Event is not triggered by Angular directive but raw event handler on element.\r\n\r\n                        // HACK: Workaround because of how Angular treats the DOM when elements are shifted around - input focus is sometimes lost.\r\n                        if (resetFocus) {\r\n                            window.setTimeout(function () {\r\n                                $scope.$apply(function () {\r\n                                    element.editor.focusedElement.setIsFocused();\r\n                                });\r\n                            }, 100);\r\n                        }\r\n                    });\r\n\r\n                    $scope.element.setIsFocusedEventHandlers.push(function () {\r\n                        $element.parent().focus();\r\n                    });\r\n\r\n                    $scope.delete = function (element) {\r\n                        element.delete();\r\n                    }\r\n\r\n                    if ($scope.element.hasEditor) {\r\n                        $scope.edit = function () {\r\n                            $scope.$root.editElement($scope.element).then(function (args) {\r\n                                $scope.$apply(function () {\r\n                                    if (args.cancel)\r\n                                        return;\r\n\r\n                                    $scope.element.data = args.element.data;\r\n                                });\r\n                            });\r\n                        };\r\n                    }\r\n                },\r\n\r\n                configureForContainer: function ($scope, $element) {\r\n                    var element = $scope.element;\r\n\r\n                    //$scope.isReceiving = false; // True when container is receiving an external element via drag/drop.\r\n                    $scope.getShowChildrenPlaceholder = function () {\r\n                        return $scope.element.children.length === 0 && !$scope.element.getIsDropTarget();\r\n                    };\r\n\r\n                    $scope.sortableOptions = {\r\n                        cursor: \"move\",\r\n                        delay: 150,\r\n                        disabled: element.getIsSealed(),\r\n                        distance: 5,\r\n                        //handle: element.children.length < 2 ? \".imaginary-class\" : false, // For some reason doesn't get re-evaluated after adding more children.\r\n                        start: function (e, ui) {\r\n                            $scope.$apply(function () {\r\n                                element.setIsDropTarget(true);\r\n                                element.editor.isDragging = true;\r\n                            });\r\n                            // Make the drop target placeholder as high as the item being dragged.\r\n                            ui.placeholder.height(ui.item.height() - 4);\r\n                            ui.placeholder.css(\"min-height\", 0);\r\n                        },\r\n                        stop: function (e, ui) {\r\n                            $scope.$apply(function () {\r\n                                element.editor.isDragging = false;\r\n                                element.setIsDropTarget(false);\r\n                            });\r\n                        },\r\n                        over: function (e, ui) {\r\n                            if (!!ui.sender && !!ui.sender[0].isToolbox) {\r\n                                if (!!ui.sender[0].dropTargetTimeout) {\r\n                                    $timeout.cancel(ui.sender[0].dropTargetTimeout);\r\n                                    ui.sender[0].dropTargetTimeout = null;\r\n                                }\r\n                                $timeout(function () {\r\n                                    if (element.type == \"Row\") {\r\n                                        // If there was a previous drop target and it was a row, roll back any pending column adds to it.\r\n                                        var previousDropTarget = element.editor.dropTargetElement;\r\n                                        if (!!previousDropTarget && previousDropTarget.type == \"Row\")\r\n                                            previousDropTarget.rollbackAddColumn();\r\n                                    }\r\n                                    element.setIsDropTarget(false);\r\n                                });\r\n                                ui.sender[0].dropTargetTimeout = $timeout(function () {\r\n                                    if (element.type == \"Row\") {\r\n                                        var receivedColumn = ui.item.sortable.model;\r\n                                        var receivedColumnWidth = Math.floor(12 / (element.children.length + 1));\r\n                                        receivedColumn.width = receivedColumnWidth;\r\n                                        receivedColumn.offset = 0;\r\n                                        element.beginAddColumn(receivedColumnWidth);\r\n                                        // Make the drop target placeholder the correct width and as high as the highest existing column in the row.\r\n                                        var maxHeight = _.max(_($element.find(\"> .layout-children > .layout-column:not(.ui-sortable-placeholder)\")).map(function (e) {\r\n                                            return $(e).height();\r\n                                        }));\r\n                                        for (i = 1; i <= 12; i++)\r\n                                            ui.placeholder.removeClass(\"col-xs-\" + i);\r\n                                        ui.placeholder.addClass(\"col-xs-\" + receivedColumn.width);\r\n                                        if (maxHeight > 0) {\r\n                                            ui.placeholder.height(maxHeight);\r\n                                            ui.placeholder.css(\"min-height\", 0);\r\n                                        }\r\n                                        else {\r\n                                            ui.placeholder.height(0);\r\n                                            ui.placeholder.css(\"min-height\", \"\");\r\n                                        }\r\n                                    }\r\n                                    element.setIsDropTarget(true);\r\n                                }, 150);\r\n                            }\r\n                        },\r\n                        receive: function (e, ui) {\r\n                            if (!!ui.sender && !!ui.sender[0].isToolbox) {\r\n                                $scope.$apply(function () {\r\n                                    var receivedElement = ui.item.sortable.model;\r\n                                    if (!!receivedElement) {\r\n                                        if (element.type == \"Row\")\r\n                                            element.commitAddColumn();\r\n                                        // Should ideally call LayoutEditor.Container.addChild() instead, but since this handler\r\n                                        // is run *before* the ui-sortable directive's handler, if we try to add the child to the\r\n                                        // array that handler will get an exception when trying to do the same.\r\n                                        // Because of this, we need to invoke \"setParent\" so that specific container types can perform element speficic initialization.\r\n                                        receivedElement.setEditor(element.editor);\r\n                                        receivedElement.setParent(element);\r\n\r\n                                        if (!!receivedElement.hasEditor) {\r\n                                            $scope.$root.editElement(receivedElement).then(function (args) {\r\n                                                if (!args.cancel) {\r\n                                                    receivedElement.data = args.element.data;\r\n                                                    receivedElement.applyElementEditorModel(args.elementEditorModel);\r\n\r\n                                                    if (!!receivedElement.setHtml)\r\n                                                        receivedElement.setHtml(args.element.html);\r\n                                                }\r\n                                                $timeout(function () {\r\n                                                    if (!!args.cancel)\r\n                                                        receivedElement.delete();\r\n                                                    else\r\n                                                        receivedElement.setIsFocused();\r\n                                                    //$scope.isReceiving = false;\r\n                                                    element.setIsDropTarget(false);\r\n\r\n                                                });\r\n                                                return;\r\n                                            });\r\n                                        }\r\n                                    }\r\n                                    $timeout(function () {\r\n                                        //$scope.isReceiving = false;\r\n                                        element.setIsDropTarget(false);\r\n                                        if (!!receivedElement)\r\n                                            receivedElement.setIsFocused();\r\n                                    });\r\n                                });\r\n                            }\r\n                        }\r\n                    };\r\n\r\n                    $scope.click = function (child, e) {\r\n                        if (!child.editor.isDragging)\r\n                            child.setIsFocused();\r\n                        e.stopPropagation();\r\n                    };\r\n\r\n                    $scope.getClasses = function (child) {\r\n                        var result = [\"layout-element\"];\r\n\r\n                        if (!!child.children) {\r\n                            result.push(\"layout-container\");\r\n                            if (child.getIsSealed())\r\n                                result.push(\"layout-container-sealed\");\r\n                        }\r\n\r\n                        result.push(\"layout-\" + child.type.toLowerCase());\r\n\r\n                        if (!!child.dropTargetClass)\r\n                            result.push(child.dropTargetClass);\r\n\r\n                        // TODO: Move these to either the Column directive or the Column model class.\r\n                        if (child.type == \"Row\") {\r\n                            result.push(\"row\");\r\n                            if (!child.canAddColumn())\r\n                                result.push(\"layout-row-full\");\r\n                        }\r\n                        if (child.type == \"Column\") {\r\n                            result.push(\"col-xs-\" + child.width);\r\n                            result.push(\"col-xs-offset-\" + child.offset);\r\n                        }\r\n                        if (child.type == \"Content\")\r\n                            result.push(\"layout-content-\" + child.contentTypeClass);\r\n\r\n                        if (child.getIsActive())\r\n                            result.push(\"layout-element-active\");\r\n                        if (child.getIsFocused())\r\n                            result.push(\"layout-element-focused\");\r\n                        if (child.getIsSelected())\r\n                            result.push(\"layout-element-selected\");\r\n                        if (child.getIsDropTarget())\r\n                            result.push(\"layout-element-droptarget\");\r\n                        if (child.isTemplated)\r\n                            result.push(\"layout-element-templated\");\r\n\r\n                        return result;\r\n                    };\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutEditor\", [\"environment\",\r\n        function (environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: {},\r\n                controller: [\"$scope\", \"$element\", \"$attrs\", \"$compile\", \"clipboard\",\r\n                    function ($scope, $element, $attrs, $compile, clipboard) {\r\n                        if (!!$attrs.model)\r\n                            $scope.element = eval($attrs.model);\r\n                        else\r\n                            throw new Error(\"The 'model' attribute must evaluate to a LayoutEditor.Editor object.\");\r\n\r\n                        $scope.click = function (canvas, e) {\r\n                            if (!canvas.editor.isDragging)\r\n                                canvas.setIsFocused();\r\n                            e.stopPropagation();\r\n                        };\r\n\r\n                        $scope.getClasses = function (canvas) {\r\n                            var result = [\"layout-element\", \"layout-container\", \"layout-canvas\"];\r\n\r\n                            if (canvas.getIsActive())\r\n                                result.push(\"layout-element-active\");\r\n                            if (canvas.getIsFocused())\r\n                                result.push(\"layout-element-focused\");\r\n                            if (canvas.getIsSelected())\r\n                                result.push(\"layout-element-selected\");\r\n                            if (canvas.getIsDropTarget())\r\n                                result.push(\"layout-element-droptarget\");\r\n                            if (canvas.isTemplated)\r\n                                result.push(\"layout-element-templated\");\r\n\r\n                            return result;\r\n                        };\r\n\r\n                        // An unfortunate side-effect of the next hack on line 54 is that the created elements aren't added to the DOM yet, so we can't use it to get to the parent \".layout-desiger\" element.\r\n                        // Work around: access that element directly (which efectively turns multiple layout editors on a single page impossible). \r\n                        // //var layoutDesignerHost = $element.closest(\".layout-designer\").data(\"layout-designer-host\");\r\n                        var layoutDesignerHost = $(\".layout-designer\").data(\"layout-designer-host\");\r\n\r\n                        $scope.$root.layoutDesignerHost = layoutDesignerHost;\r\n\r\n                        layoutDesignerHost.element.on(\"replacecanvas\", function (e, args) {\r\n                            var editor = $scope.element;\r\n                            var canvasData = {\r\n                                data: args.canvas.data,\r\n                                htmlId: args.canvas.htmlId,\r\n                                htmlClass: args.canvas.htmlClass,\r\n                                htmlStyle: args.canvas.htmlStyle,\r\n                                isTemplated: args.canvas.isTemplated,\r\n                                children: args.canvas.children\r\n                            };\r\n\r\n                            // HACK: Instead of simply updating the $scope.element with a new instance, we need to replace the entire orc-layout-editor markup\r\n                            // in order for angular to rebind starting with the Canvas element. Otherwise, for some reason, it will rebind starting with the first child of Canvas.\r\n                            // You can see this happening when setting a breakpoint in ScopeConfigurator where containers are initialized with drag & drop: on page load, the first element\r\n                            // is a Canvas (good), but after having selected another template, the first element is (typically) a Grid (bad).\r\n                            // Simply recompiling the orc-layout-editor directive will cause the entire thing to be generated, which works just fine as well (even though not is nice as simply leveraging model binding).\r\n                            layoutDesignerHost.editor = window.layoutEditor = new LayoutEditor.Editor(editor.config, canvasData);\r\n                            var template = \"<orc-layout-editor\" + \" model='window.layoutEditor' />\";\r\n                            var html = $compile(template)($scope);\r\n                            $(\".layout-editor-holder\").html(html);\r\n                        });\r\n\r\n                        $scope.$root.editElement = function (element) {\r\n                            var host = $scope.$root.layoutDesignerHost;\r\n                            return host.editElement(element);\r\n                        };\r\n\r\n                        $scope.$root.addElement = function (contentType) {\r\n                            var host = $scope.$root.layoutDesignerHost;\r\n                            return host.addElement(contentType);\r\n                        };\r\n\r\n                        $(document).on(\"cut copy paste\", function (e) {\r\n                            // If the pseudo clipboard was already invoked (which happens on the first clipboard\r\n                            // operation after page load even if native clipboard support exists) then sit this\r\n                            // one operation out, but make sure whatever is on the pseudo clipboard gets migrated\r\n                            // to the native clipboard for subsequent operations.\r\n                            if (clipboard.wasInvoked()) {\r\n                                e.originalEvent.clipboardData.setData(\"text/plain\", clipboard.getData(\"text/plain\"));\r\n                                e.originalEvent.clipboardData.setData(\"text/json\", clipboard.getData(\"text/json\"));\r\n                                e.preventDefault();\r\n                            }\r\n                            else {\r\n                                var focusedElement = $scope.element.focusedElement;\r\n                                if (!!focusedElement) {\r\n                                    $scope.$apply(function () {\r\n                                        switch (e.type) {\r\n                                            case \"copy\":\r\n                                                focusedElement.copy(e.originalEvent.clipboardData);\r\n                                                break;\r\n                                            case \"cut\":\r\n                                                focusedElement.cut(e.originalEvent.clipboardData);\r\n                                                break;\r\n                                            case \"paste\":\r\n                                                focusedElement.paste(e.originalEvent.clipboardData);\r\n                                                break;\r\n                                        }\r\n                                    });\r\n\r\n                                    // HACK: Workaround because of how Angular treats the DOM when elements are shifted around - input focus is sometimes lost.\r\n                                    window.setTimeout(function () {\r\n                                        $scope.$apply(function () {\r\n                                            if (!!$scope.element.focusedElement)\r\n                                                $scope.element.focusedElement.setIsFocused();\r\n                                        });\r\n                                    }, 100);\r\n\r\n                                    e.preventDefault();\r\n                                }\r\n                            }\r\n\r\n                            // Native clipboard support obviously exists, so disable the peudo clipboard from now on.\r\n                            clipboard.disable();\r\n                        });\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Editor\"),\r\n                replace: true,\r\n                link: function (scope, element) {\r\n                    // No clicks should propagate from the TinyMCE toolbars.\r\n                    element.find(\".layout-toolbar-container\").click(function (e) {\r\n                        e.stopPropagation();\r\n                    });\r\n                    // Unfocus and unselect everything on click outside of canvas.\r\n                    $(window).click(function (e) {\r\n                        scope.$apply(function () {\r\n                            scope.element.activeElement = null;\r\n                            scope.element.focusedElement = null;\r\n                        });\r\n                    });\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutCanvas\", [\"scopeConfigurator\", \"environment\",\r\n        function (scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\", \"$attrs\",\r\n                    function ($scope, $element, $attrs) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        scopeConfigurator.configureForContainer($scope, $element);\r\n                        $scope.sortableOptions[\"axis\"] = \"y\";\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Canvas\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutChild\", [\"$compile\",\r\n        function ($compile) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                link: function (scope, element) {\r\n                    var template = \"<orc-layout-\" + scope.element.type.toLowerCase() + \" element='element' />\";\r\n                    var html = $compile(template)(scope);\r\n                    $(element).replaceWith(html);\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutColumn\", [\"$compile\", \"scopeConfigurator\", \"environment\",\r\n        function ($compile, scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        scopeConfigurator.configureForContainer($scope, $element);\r\n                        $scope.sortableOptions[\"axis\"] = \"y\";\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Column\"),\r\n                replace: true,\r\n                link: function (scope, element, attrs) {\r\n                    element.find(\".layout-column-resize-bar\").draggable({\r\n                        axis: \"x\",\r\n                        helper: \"clone\",\r\n                        revert: true,\r\n                        start: function (e, ui) {\r\n                            scope.$apply(function () {\r\n                                scope.element.editor.isResizing = true;\r\n                            });\r\n                        },\r\n                        drag: function (e, ui) {\r\n                            var columnElement = element.parent();\r\n                            var columnSize = columnElement.width() / scope.element.width;\r\n                            var connectAdjacent = !e.ctrlKey;\r\n                            if ($(e.target).hasClass(\"layout-column-resize-bar-left\")) {\r\n                                var delta = ui.offset.left - columnElement.offset().left;\r\n                                if (delta < -columnSize && scope.element.canExpandLeft(connectAdjacent)) {\r\n                                    scope.$apply(function () {\r\n                                        scope.element.expandLeft(connectAdjacent);\r\n                                    });\r\n                                }\r\n                                else if (delta > columnSize && scope.element.canContractLeft(connectAdjacent)) {\r\n                                    scope.$apply(function () {\r\n                                        scope.element.contractLeft(connectAdjacent);\r\n                                    });\r\n                                }\r\n                            }\r\n                            else if ($(e.target).hasClass(\"layout-column-resize-bar-right\")) {\r\n                                var delta = ui.offset.left - columnElement.width() - columnElement.offset().left;\r\n                                if (delta > columnSize && scope.element.canExpandRight(connectAdjacent)) {\r\n                                    scope.$apply(function () {\r\n                                        scope.element.expandRight(connectAdjacent);\r\n                                    });\r\n                                }\r\n                                else if (delta < -columnSize && scope.element.canContractRight(connectAdjacent)) {\r\n                                    scope.$apply(function () {\r\n                                        scope.element.contractRight(connectAdjacent);\r\n                                    });\r\n                                }\r\n                            }\r\n\r\n                        },\r\n                        stop: function (e, ui) {\r\n                            scope.$apply(function () {\r\n                              scope.element.editor.isResizing = false;\r\n                            });\r\n                        }\r\n                    });\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutContent\", [\"$sce\", \"scopeConfigurator\", \"environment\",\r\n        function ($sce, scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        if ($scope.element.hasEditor) {\r\n                            $scope.edit = function () {\r\n                                $scope.$root.editElement($scope.element).then(function (args) {\r\n                                    $scope.$apply(function () {\r\n                                        if (args.cancel)\r\n                                            return;\r\n\r\n                                        $scope.element.data = args.element.data;\r\n                                        $scope.element.setHtml(args.element.html);\r\n                                    });\r\n                                });\r\n                            };\r\n                        }\r\n\r\n                        // Overwrite the setHtml function so that we can use the $sce service to trust the html (and not have the html binding strip certain tags).\r\n                        $scope.element.setHtml = function (html) {\r\n                            $scope.element.html = html;\r\n                            $scope.element.htmlUnsafe = $sce.trustAsHtml(html);\r\n                        };\r\n\r\n                        $scope.element.setHtml($scope.element.html);\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Content\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutGrid\", [\"$compile\", \"scopeConfigurator\", \"environment\",\r\n        function ($compile, scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        scopeConfigurator.configureForContainer($scope, $element);\r\n                        $scope.sortableOptions[\"axis\"] = \"y\";\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Grid\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutRow\", [\"$compile\", \"scopeConfigurator\", \"environment\",\r\n        function ($compile, scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        scopeConfigurator.configureForContainer($scope, $element);\r\n                        $scope.sortableOptions[\"axis\"] = \"x\";\r\n                        $scope.sortableOptions[\"ui-floating\"] = true;\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Row\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutPopup\", [\r\n        function () {\r\n            return {\r\n                restrict: \"A\",\r\n                link: function (scope, element, attrs) {\r\n                    var popup = $(element);\r\n                    var trigger = popup.closest(\".layout-popup-trigger\");\r\n                    var parentElement = popup.closest(\".layout-element\");\r\n                    trigger.click(function () {\r\n                        popup.toggle();\r\n                        if (popup.is(\":visible\")) {\r\n                            popup.position({\r\n                                my: attrs.orcLayoutPopupMy || \"left top\",\r\n                                at: attrs.orcLayoutPopupAt || \"left bottom+4px\",\r\n                                of: trigger\r\n                            });\r\n                            popup.find(\"input\").first().focus();\r\n                        }\r\n                    });\r\n                    popup.click(function (e) {\r\n                        e.stopPropagation();\r\n                    });\r\n                    parentElement.click(function (e) {\r\n                        popup.hide();\r\n                    });\r\n                    popup.keydown(function (e) {\r\n                        if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 27) // Esc\r\n                            popup.hide();\r\n                        e.stopPropagation();\r\n                    });\r\n                    popup.on(\"cut copy paste\", function (e) {\r\n                        // Allow clipboard operations in popup without invoking clipboard event handlers on parent element.\r\n                        e.stopPropagation();\r\n                    });\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutToolbox\", [\"$compile\", \"environment\",\r\n        function ($compile, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n\r\n                        $scope.resetElements = function () {\r\n\r\n                            $scope.gridElements = [\r\n                                LayoutEditor.Grid.from({\r\n                                    toolboxIcon: \"\\uf00a\",\r\n                                    toolboxLabel: \"Grid\",\r\n                                    toolboxDescription: \"Empty grid.\",\r\n                                    children: []\r\n                                })\r\n                            ];\r\n\r\n                            $scope.rowElements = [\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (1 column)\",\r\n                                    toolboxDescription: \"Row with 1 column.\",\r\n                                    children: LayoutEditor.Column.times(1)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (2 columns)\",\r\n                                    toolboxDescription: \"Row with 2 columns.\",\r\n                                    children: LayoutEditor.Column.times(2)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (3 columns)\",\r\n                                    toolboxDescription: \"Row with 3 columns.\",\r\n                                    children: LayoutEditor.Column.times(3)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (4 columns)\",\r\n                                    toolboxDescription: \"Row with 4 columns.\",\r\n                                    children: LayoutEditor.Column.times(4)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (6 columns)\",\r\n                                    toolboxDescription: \"Row with 6 columns.\",\r\n                                    children: LayoutEditor.Column.times(6)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (12 columns)\",\r\n                                    toolboxDescription: \"Row with 12 columns.\",\r\n                                    children: LayoutEditor.Column.times(12)\r\n                                }), LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (empty)\",\r\n                                    toolboxDescription: \"Empty row.\",\r\n                                    children: []\r\n                                })\r\n                            ];\r\n\r\n                            $scope.columnElements = [\r\n                                LayoutEditor.Column.from({\r\n                                    toolboxIcon: \"\\uf0db\",\r\n                                    toolboxLabel: \"Column\",\r\n                                    toolboxDescription: \"Empty column.\",\r\n                                    width: 1,\r\n                                    offset: 0,\r\n                                    children: []\r\n                                })\r\n                            ];\r\n\r\n                            $scope.canvasElements = [\r\n                                LayoutEditor.Canvas.from({\r\n                                    toolboxIcon: \"\\uf044\",\r\n                                    toolboxLabel: \"Canvas\",\r\n                                    toolboxDescription: \"Empty canvas.\",\r\n                                    children: []\r\n                                })\r\n                            ];\r\n\r\n                            $scope.contentElementCategories = _($scope.element.config.categories).map(function (category) {\r\n                                return {\r\n                                    name: category.name,\r\n                                    elements: _(category.contentTypes).map(function (contentType) {\r\n                                        var type = contentType.type;\r\n                                        var factory = LayoutEditor.factories[type] || LayoutEditor.factories[\"Content\"];\r\n                                        var item = {\r\n                                            isTemplated: false,\r\n                                            contentType: contentType.id,\r\n                                            contentTypeLabel: contentType.label,\r\n                                            contentTypeClass: contentType.typeClass,\r\n                                            data: null,\r\n                                            hasEditor: contentType.hasEditor,\r\n                                            html: contentType.html\r\n                                        };\r\n                                        var element = factory(item);\r\n                                        element.toolboxIcon = contentType.icon || \"\\uf1c9\";\r\n                                        element.toolboxLabel = contentType.label;\r\n                                        element.toolboxDescription = contentType.description;\r\n                                        return element;\r\n                                    })\r\n                                };\r\n                            });\r\n\r\n                        };\r\n\r\n                        $scope.resetElements();\r\n\r\n                        $scope.getSortableOptions = function (type) {\r\n                            var editorId = $element.closest(\".layout-editor\").attr(\"id\");\r\n                            var parentClasses;\r\n                            var placeholderClasses;\r\n                            var floating = false;\r\n\r\n                            switch (type) {\r\n                                case \"Grid\":\r\n                                    parentClasses = [\".layout-canvas\", \".layout-column\", \".layout-common-holder\"];\r\n                                    placeholderClasses = \"layout-element layout-container layout-grid ui-sortable-placeholder\";\r\n                                    break;\r\n                                case \"Row\":\r\n                                    parentClasses = [\".layout-grid\"];\r\n                                    placeholderClasses = \"layout-element layout-container layout-row row ui-sortable-placeholder\";\r\n                                    break;\r\n                                case \"Column\":\r\n                                    parentClasses = [\".layout-row:not(.layout-row-full)\"];\r\n                                    placeholderClasses = \"layout-element layout-container layout-column ui-sortable-placeholder\";\r\n                                    floating = true; // To ensure a smooth horizontal-list reordering. https://github.com/angular-ui/ui-sortable#floating\r\n                                    break;\r\n                                case \"Content\":\r\n                                    parentClasses = [\".layout-canvas\", \".layout-column\", \".layout-common-holder\"];\r\n                                    placeholderClasses = \"layout-element layout-content ui-sortable-placeholder\";\r\n                                    break;\r\n                                case \"Canvas\":\r\n                                    parentClasses = [\".layout-canvas\", \".layout-column\", \".layout-common-holder\"];\r\n                                    placeholderClasses = \"layout-element layout-container layout-grid ui-sortable-placeholder\";\r\n                                    break;\r\n                            }\r\n\r\n                            return {\r\n                                cursor: \"move\",\r\n                                connectWith: _(parentClasses).map(function (e) { return \"#\" + editorId + \" \" + e + \":not(.layout-container-sealed) > .layout-element-wrapper > .layout-children\"; }).join(\", \"),\r\n                                placeholder: placeholderClasses,\r\n                                \"ui-floating\": floating,\r\n                                create: function (e, ui) {\r\n                                    e.target.isToolbox = true; // Will indicate to connected sortables that dropped items were sent from toolbox.\r\n                                },\r\n                                start: function (e, ui) {\r\n                                    $scope.$apply(function () {\r\n                                        $scope.element.isDragging = true;\r\n                                    });\r\n                                },\r\n                                stop: function (e, ui) {\r\n                                    $scope.$apply(function () {\r\n                                        $scope.element.isDragging = false;\r\n                                        $scope.resetElements();\r\n                                    });\r\n                                },\r\n                                over: function (e, ui) {\r\n                                    $scope.$apply(function () {\r\n                                        $scope.element.canvas.setIsDropTarget(false);\r\n                                    });\r\n                                },\r\n                            }\r\n                        };\r\n\r\n                        var layoutIsCollapsedCookieName = \"layoutToolboxCategory_Layout_IsCollapsed\";\r\n                        $scope.layoutIsCollapsed = $.cookie(layoutIsCollapsedCookieName) === \"true\";\r\n\r\n                        $scope.toggleLayoutIsCollapsed = function (e) {\r\n                            $scope.layoutIsCollapsed = !$scope.layoutIsCollapsed;\r\n                            $.cookie(layoutIsCollapsedCookieName, $scope.layoutIsCollapsed, { expires: 365 }); // Remember collapsed state for a year.\r\n                            e.preventDefault();\r\n                            e.stopPropagation();\r\n                        };\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Toolbox\"),\r\n                replace: true,\r\n                link: function (scope, element) {\r\n                    var toolbox = element.find(\".layout-toolbox\");\r\n                    $(window).on(\"resize scroll\", function (e) {\r\n                        var canvas = element.parent().find(\".layout-canvas\");\r\n                        // If the canvas is taller than the toolbox, make the toolbox sticky-positioned within the editor\r\n                        // to help the user avoid excessive vertical scrolling.\r\n                        var canvasIsTaller = !!canvas && canvas.height() > toolbox.height();\r\n                        var windowPos = $(window).scrollTop();\r\n                        if (canvasIsTaller && windowPos > element.offset().top + element.height() - toolbox.height()) {\r\n                            toolbox.addClass(\"sticky-bottom\");\r\n                            toolbox.removeClass(\"sticky-top\");\r\n                        }\r\n                        else if (canvasIsTaller && windowPos > element.offset().top) {\r\n                            toolbox.addClass(\"sticky-top\");\r\n                            toolbox.removeClass(\"sticky-bottom\");\r\n                        }\r\n                        else {\r\n                            toolbox.removeClass(\"sticky-top\");\r\n                            toolbox.removeClass(\"sticky-bottom\");\r\n                        }\r\n                    });\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutToolboxGroup\", [\"$compile\", \"environment\",\r\n        function ($compile, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { category: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        var isCollapsedCookieName = \"layoutToolboxCategory_\" + $scope.category.name + \"_IsCollapsed\";\r\n                        $scope.isCollapsed = $.cookie(isCollapsedCookieName) === \"true\";\r\n                        $scope.toggleIsCollapsed = function (e) {\r\n                            $scope.isCollapsed = !$scope.isCollapsed;\r\n                            $.cookie(isCollapsedCookieName, $scope.isCollapsed, { expires: 365 }); // Remember collapsed state for a year.\r\n                            e.preventDefault();\r\n                            e.stopPropagation();\r\n                        };\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"ToolboxGroup\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);"],"sourceRoot":"/source/"} diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutEditor.min.js b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutEditor.min.js index b31866784..51fa7093c 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutEditor.min.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutEditor.min.js @@ -1 +1 @@ -angular.module("LayoutEditor",["ngSanitize","ngResource","ui.sortable"]);var LayoutEditor;!function(e){var t=function(){var e=this;this._clipboardData={},this._isDisabled=!1,this._wasInvoked=!1,this.setData=function(t,o){e._clipboardData[t]=o,e._wasInvoked=!0},this.getData=function(t){return e._clipboardData[t]},this.disable=function(){e._isDisabled=!0,e._wasInvoked=!1,e._clipboardData={}},this.isDisabled=function(){return e._isDisabled},this.wasInvoked=function(){return e._wasInvoked}};e.Clipboard=new t,angular.module("LayoutEditor").factory("clipboard",[function(){return{setData:e.Clipboard.setData,getData:e.Clipboard.getData,disable:e.Clipboard.disable,isDisabled:e.Clipboard.isDisabled,wasInvoked:e.Clipboard.wasInvoked}}])}(LayoutEditor||(LayoutEditor={})),angular.module("LayoutEditor").factory("scopeConfigurator",["$timeout","clipboard",function(e,t){return{configureForElement:function(e,o){o.find(".layout-panel").click(function(e){e.stopPropagation()}),o.parent().keydown(function(n){var l=!1,a=!1,r=e.element;if(!r.editor.isDragging){if(!t.isDisabled()){var i=r.editor.focusedElement;if(i&&n.ctrlKey)switch(n.which){case 67:i.copy(t);break;case 88:i.cut(t);break;case 86:i.paste(t)}}if(n.ctrlKey||n.shiftKey||n.altKey||46!=n.which?n.ctrlKey||n.shiftKey||n.altKey||32!=n.which&&27!=n.which||(o.find(".layout-panel-action-properties").first().click(),l=!0):(e["delete"](r),l=!0),"Content"==r.type&&(n.ctrlKey||n.shiftKey||n.altKey||13!=n.which||(o.find(".layout-panel-action-edit").first().click(),l=!0)),r.children&&(n.ctrlKey||n.shiftKey||!n.altKey||40!=n.which||(r.children.length>0&&r.children[0].setIsFocused(),l=!0),"Column"==r.type)){var c=!n.ctrlKey;37==n.which?(n.altKey&&r.expandLeft(c),n.shiftKey&&r.contractRight(c),l=!0):39==n.which&&(n.altKey&&r.contractLeft(c),n.shiftKey&&r.expandRight(c),l=!0)}r.parent&&(n.altKey&&38==n.which&&(r.parent.setIsFocused(),l=!0),"Row"==r.parent.type?n.ctrlKey||n.shiftKey||n.altKey||37!=n.which?n.ctrlKey||n.shiftKey||n.altKey||39!=n.which?!n.ctrlKey||n.shiftKey||n.altKey||37!=n.which?!n.ctrlKey||n.shiftKey||n.altKey||39!=n.which||(r.moveDown(),l=!0):(r.moveUp(),a=!0,l=!0):(r.parent.moveFocusNextChild(r),l=!0):(r.parent.moveFocusPrevChild(r),l=!0):n.ctrlKey||n.shiftKey||n.altKey||38!=n.which?n.ctrlKey||n.shiftKey||n.altKey||40!=n.which?!n.ctrlKey||n.shiftKey||n.altKey||38!=n.which?!n.ctrlKey||n.shiftKey||n.altKey||40!=n.which||(r.moveDown(),l=!0):(r.moveUp(),a=!0,l=!0):(r.parent.moveFocusNextChild(r),l=!0):(r.parent.moveFocusPrevChild(r),l=!0)),l&&n.preventDefault(),n.stopPropagation(),e.$apply(),a&&window.setTimeout(function(){e.$apply(function(){r.editor.focusedElement.setIsFocused()})},100)}}),e.element.setIsFocusedEventHandlers.push(function(){o.parent().focus()}),e["delete"]=function(e){e["delete"]()}},configureForContainer:function(t,o){var n=t.element;t.getShowChildrenPlaceholder=function(){return 0===t.element.children.length&&!t.element.getIsDropTarget()},t.sortableOptions={cursor:"move",delay:150,disabled:n.getIsSealed(),distance:5,start:function(e,o){t.$apply(function(){n.setIsDropTarget(!0),n.editor.isDragging=!0}),o.placeholder.height(o.item.height()-4),o.placeholder.css("min-height",0)},stop:function(e,o){t.$apply(function(){n.editor.isDragging=!1,n.setIsDropTarget(!1)})},over:function(t,l){l.sender&&l.sender[0].isToolbox&&(l.sender[0].dropTargetTimeout&&(e.cancel(l.sender[0].dropTargetTimeout),l.sender[0].dropTargetTimeout=null),e(function(){if("Row"==n.type){var e=n.editor.dropTargetElement;e&&"Row"==e.type&&e.rollbackAddColumn()}n.setIsDropTarget(!1)}),l.sender[0].dropTargetTimeout=e(function(){if("Row"==n.type){var e=l.item.sortable.model,t=Math.floor(12/(n.children.length+1));e.width=t,e.offset=0,n.beginAddColumn(t);var a=_.max(_(o.find("> .layout-children > .layout-column:not(.ui-sortable-placeholder)")).map(function(e){return $(e).height()}));for(i=1;i<=12;i++)l.placeholder.removeClass("col-xs-"+i);l.placeholder.addClass("col-xs-"+e.width),a>0?(l.placeholder.height(a),l.placeholder.css("min-height",0)):(l.placeholder.height(0),l.placeholder.css("min-height",""))}n.setIsDropTarget(!0)},150))},receive:function(o,l){l.sender&&l.sender[0].isToolbox&&t.$apply(function(){var o=l.item.sortable.model;o&&("Row"==n.type&&n.commitAddColumn(),o.setEditor(n.editor),o.setParent(n),o.hasEditor&&t.$root.editElement(o).then(function(t){t.cancel||(o.data=t.element.data,o.applyElementEditorModel(t.elementEditorModel),o.setHtml&&o.setHtml(t.element.html)),e(function(){t.cancel?o["delete"]():o.setIsFocused(),n.setIsDropTarget(!1)})})),e(function(){n.setIsDropTarget(!1),o&&o.setIsFocused()})})}},t.click=function(e,t){e.editor.isDragging||e.setIsFocused(),t.stopPropagation()},t.getClasses=function(e){var t=["layout-element"];return e.children&&(t.push("layout-container"),e.getIsSealed()&&t.push("layout-container-sealed")),t.push("layout-"+e.type.toLowerCase()),e.dropTargetClass&&t.push(e.dropTargetClass),"Row"==e.type&&(t.push("row"),e.canAddColumn()||t.push("layout-row-full")),"Column"==e.type&&(t.push("col-xs-"+e.width),t.push("col-xs-offset-"+e.offset)),"Content"==e.type&&t.push("layout-content-"+e.contentTypeClass),e.getIsActive()&&t.push("layout-element-active"),e.getIsFocused()&&t.push("layout-element-focused"),e.getIsSelected()&&t.push("layout-element-selected"),e.getIsDropTarget()&&t.push("layout-element-droptarget"),e.isTemplated&&t.push("layout-element-templated"),t}}}}]),angular.module("LayoutEditor").directive("orcLayoutEditor",["environment",function(environment){return{restrict:"E",scope:{},controller:["$scope","$element","$attrs","$compile","clipboard",function($scope,$element,$attrs,$compile,clipboard){if(!$attrs.model)throw new Error("The 'model' attribute must evaluate to a LayoutEditor.Editor object.");$scope.element=eval($attrs.model),$scope.click=function(e,t){e.editor.isDragging||e.setIsFocused(),t.stopPropagation()},$scope.getClasses=function(e){var t=["layout-element","layout-container","layout-canvas"];return e.getIsActive()&&t.push("layout-element-active"),e.getIsFocused()&&t.push("layout-element-focused"),e.getIsSelected()&&t.push("layout-element-selected"),e.getIsDropTarget()&&t.push("layout-element-droptarget"),e.isTemplated&&t.push("layout-element-templated"),t};var layoutDesignerHost=$(".layout-designer").data("layout-designer-host");$scope.$root.layoutDesignerHost=layoutDesignerHost,layoutDesignerHost.element.on("replacecanvas",function(e,t){var o=$scope.element,n={data:t.canvas.data,htmlId:t.canvas.htmlId,htmlClass:t.canvas.htmlClass,htmlStyle:t.canvas.htmlStyle,isTemplated:t.canvas.isTemplated,children:t.canvas.children};layoutDesignerHost.editor=window.layoutEditor=new LayoutEditor.Editor(o.config,n);var l="",a=$compile(l)($scope);$(".layout-editor-holder").html(a)}),$scope.$root.editElement=function(e){var t=$scope.$root.layoutDesignerHost;return t.editElement(e)},$scope.$root.addElement=function(e){var t=$scope.$root.layoutDesignerHost;return t.addElement(e)},$(document).on("cut copy paste",function(e){if(clipboard.wasInvoked())e.originalEvent.clipboardData.setData("text/plain",clipboard.getData("text/plain")),e.originalEvent.clipboardData.setData("text/json",clipboard.getData("text/json")),e.preventDefault();else{var t=$scope.element.focusedElement;t&&($scope.$apply(function(){switch(e.type){case"copy":t.copy(e.originalEvent.clipboardData);break;case"cut":t.cut(e.originalEvent.clipboardData);break;case"paste":t.paste(e.originalEvent.clipboardData)}}),window.setTimeout(function(){$scope.$apply(function(){$scope.element.focusedElement&&$scope.element.focusedElement.setIsFocused()})},100),e.preventDefault())}clipboard.disable()})}],templateUrl:environment.templateUrl("Editor"),replace:!0,link:function(e,t){t.find(".layout-toolbar-container").click(function(e){e.stopPropagation()}),$(window).click(function(t){e.$apply(function(){e.element.activeElement=null,e.element.focusedElement=null})})}}}]),angular.module("LayoutEditor").directive("orcLayoutCanvas",["scopeConfigurator","environment",function(e,t){return{restrict:"E",scope:{element:"="},controller:["$scope","$element","$attrs",function(t,o,n){e.configureForElement(t,o),e.configureForContainer(t,o),t.sortableOptions.axis="y"}],templateUrl:t.templateUrl("Canvas"),replace:!0}}]),angular.module("LayoutEditor").directive("orcLayoutChild",["$compile",function(e){return{restrict:"E",scope:{element:"="},link:function(t,o){var n="",l=e(n)(t);$(o).replaceWith(l)}}}]),angular.module("LayoutEditor").directive("orcLayoutColumn",["$compile","scopeConfigurator","environment",function(e,t,o){return{restrict:"E",scope:{element:"="},controller:["$scope","$element",function(e,o){t.configureForElement(e,o),t.configureForContainer(e,o),e.sortableOptions.axis="y"}],templateUrl:o.templateUrl("Column"),replace:!0,link:function(e,t,o){t.find(".layout-column-resize-bar").draggable({axis:"x",helper:"clone",revert:!0,start:function(t,o){e.$apply(function(){e.element.editor.isResizing=!0})},drag:function(o,n){var l=t.parent(),a=l.width()/e.element.width,r=!o.ctrlKey;if($(o.target).hasClass("layout-column-resize-bar-left")){var i=n.offset.left-l.offset().left;-a>i&&e.element.canExpandLeft(r)?e.$apply(function(){e.element.expandLeft(r)}):i>a&&e.element.canContractLeft(r)&&e.$apply(function(){e.element.contractLeft(r)})}else if($(o.target).hasClass("layout-column-resize-bar-right")){var i=n.offset.left-l.width()-l.offset().left;i>a&&e.element.canExpandRight(r)?e.$apply(function(){e.element.expandRight(r)}):-a>i&&e.element.canContractRight(r)&&e.$apply(function(){e.element.contractRight(r)})}},stop:function(t,o){e.$apply(function(){e.element.editor.isResizing=!1})}})}}}]),angular.module("LayoutEditor").directive("orcLayoutContent",["$sce","scopeConfigurator","environment",function(e,t,o){return{restrict:"E",scope:{element:"="},controller:["$scope","$element",function(o,n){t.configureForElement(o,n),o.edit=function(){o.$root.editElement(o.element).then(function(e){o.$apply(function(){e.cancel||(o.element.data=e.element.data,o.element.setHtml(e.element.html))})})},o.element.setHtml=function(t){o.element.html=t,o.element.htmlUnsafe=e.trustAsHtml(t)},o.element.setHtml(o.element.html)}],templateUrl:o.templateUrl("Content"),replace:!0}}]),angular.module("LayoutEditor").directive("orcLayoutHtml",["$sce","scopeConfigurator","environment",function(e,t,o){return{restrict:"E",scope:{element:"="},controller:["$scope","$element",function(o,n){t.configureForElement(o,n),o.edit=function(){o.$root.editElement(o.element).then(function(e){o.$apply(function(){e.cancel||(o.element.data=e.element.data,o.element.setHtml(e.element.html))})})},o.updateContent=function(e){o.element.setHtml(e.target.innerHTML)},o.element.setHtml=function(t){o.element.html=t,o.element.htmlUnsafe=e.trustAsHtml(t)},o.element.setHtml(o.element.html)}],templateUrl:o.templateUrl("Html"),replace:!0,link:function(e,t){}}}]),angular.module("LayoutEditor").directive("orcLayoutGrid",["$compile","scopeConfigurator","environment",function(e,t,o){return{restrict:"E",scope:{element:"="},controller:["$scope","$element",function(e,o){t.configureForElement(e,o),t.configureForContainer(e,o),e.sortableOptions.axis="y"}],templateUrl:o.templateUrl("Grid"),replace:!0}}]),angular.module("LayoutEditor").directive("orcLayoutRow",["$compile","scopeConfigurator","environment",function(e,t,o){return{restrict:"E",scope:{element:"="},controller:["$scope","$element",function(e,o){t.configureForElement(e,o),t.configureForContainer(e,o),e.sortableOptions.axis="x",e.sortableOptions["ui-floating"]=!0}],templateUrl:o.templateUrl("Row"),replace:!0}}]),angular.module("LayoutEditor").directive("orcLayoutPopup",[function(){return{restrict:"A",link:function(e,t,o){var n=$(t),l=n.closest(".layout-popup-trigger"),a=n.closest(".layout-element");l.click(function(){n.toggle(),n.is(":visible")&&(n.position({my:o.orcLayoutPopupMy||"left top",at:o.orcLayoutPopupAt||"left bottom+4px",of:l}),n.find("input").first().focus())}),n.click(function(e){e.stopPropagation()}),a.click(function(e){n.hide()}),n.keydown(function(e){e.ctrlKey||e.shiftKey||e.altKey||27!=e.which||n.hide(),e.stopPropagation()}),n.on("cut copy paste",function(e){e.stopPropagation()})}}}]),angular.module("LayoutEditor").directive("orcLayoutToolbox",["$compile","environment",function(e,t){return{restrict:"E",controller:["$scope","$element",function(e,t){e.resetElements=function(){e.gridElements=[LayoutEditor.Grid.from({toolboxIcon:"",toolboxLabel:"Grid",toolboxDescription:"Empty grid.",children:[]})],e.rowElements=[LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (1 column)",toolboxDescription:"Row with 1 column.",children:LayoutEditor.Column.times(1)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (2 columns)",toolboxDescription:"Row with 2 columns.",children:LayoutEditor.Column.times(2)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (3 columns)",toolboxDescription:"Row with 3 columns.",children:LayoutEditor.Column.times(3)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (4 columns)",toolboxDescription:"Row with 4 columns.",children:LayoutEditor.Column.times(4)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (6 columns)",toolboxDescription:"Row with 6 columns.",children:LayoutEditor.Column.times(6)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (12 columns)",toolboxDescription:"Row with 12 columns.",children:LayoutEditor.Column.times(12)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (empty)",toolboxDescription:"Empty row.",children:[]})],e.columnElements=[LayoutEditor.Column.from({toolboxIcon:"",toolboxLabel:"Column",toolboxDescription:"Empty column.",width:1,offset:0,children:[]})],e.canvasElements=[LayoutEditor.Canvas.from({toolboxIcon:"",toolboxLabel:"Canvas",toolboxDescription:"Empty canvas.",children:[]})],e.contentElementCategories=_(e.element.config.categories).map(function(e){return{name:e.name,elements:_(e.contentTypes).map(function(e){var t=e.type,o=LayoutEditor.factories[t]||LayoutEditor.factories.Content,n={isTemplated:!1,contentType:e.id,contentTypeLabel:e.label,contentTypeClass:e.typeClass,data:null,hasEditor:e.hasEditor,html:e.html},l=o(n);return l.toolboxIcon=e.icon||"",l.toolboxLabel=e.label,l.toolboxDescription=e.description,l})}})},e.resetElements(),e.getSortableOptions=function(o){var n,l,a=t.closest(".layout-editor").attr("id"),r=!1;switch(o){case"Grid":n=[".layout-canvas",".layout-column",".layout-common-holder"],l="layout-element layout-container layout-grid ui-sortable-placeholder";break;case"Row":n=[".layout-grid"],l="layout-element layout-container layout-row row ui-sortable-placeholder";break;case"Column":n=[".layout-row:not(.layout-row-full)"],l="layout-element layout-container layout-column ui-sortable-placeholder",r=!0;break;case"Content":n=[".layout-canvas",".layout-column",".layout-common-holder"],l="layout-element layout-content ui-sortable-placeholder";break;case"Canvas":n=[".layout-canvas",".layout-column",".layout-common-holder"],l="layout-element layout-container layout-grid ui-sortable-placeholder"}return{cursor:"move",connectWith:_(n).map(function(e){return"#"+a+" "+e+":not(.layout-container-sealed) > .layout-element-wrapper > .layout-children"}).join(", "),placeholder:l,"ui-floating":r,create:function(e,t){e.target.isToolbox=!0},start:function(t,o){e.$apply(function(){e.element.isDragging=!0})},stop:function(t,o){e.$apply(function(){e.element.isDragging=!1,e.resetElements()})},over:function(t,o){e.$apply(function(){e.element.canvas.setIsDropTarget(!1)})}}};var o="layoutToolboxCategory_Layout_IsCollapsed";e.layoutIsCollapsed="true"===$.cookie(o),e.toggleLayoutIsCollapsed=function(t){e.layoutIsCollapsed=!e.layoutIsCollapsed,$.cookie(o,e.layoutIsCollapsed,{expires:365}),t.preventDefault(),t.stopPropagation()}}],templateUrl:t.templateUrl("Toolbox"),replace:!0,link:function(e,t){var o=t.find(".layout-toolbox");$(window).on("resize scroll",function(e){var n=t.parent().find(".layout-canvas"),l=!!n&&n.height()>o.height(),a=$(window).scrollTop();l&&a>t.offset().top+t.height()-o.height()?(o.addClass("sticky-bottom"),o.removeClass("sticky-top")):l&&a>t.offset().top?(o.addClass("sticky-top"),o.removeClass("sticky-bottom")):(o.removeClass("sticky-top"),o.removeClass("sticky-bottom"))})}}}]),angular.module("LayoutEditor").directive("orcLayoutToolboxGroup",["$compile","environment",function(e,t){return{restrict:"E",scope:{category:"="},controller:["$scope","$element",function(e,t){var o="layoutToolboxCategory_"+e.category.name+"_IsCollapsed";e.isCollapsed="true"===$.cookie(o),e.toggleIsCollapsed=function(t){e.isCollapsed=!e.isCollapsed,$.cookie(o,e.isCollapsed,{expires:365}),t.preventDefault(),t.stopPropagation()}}],templateUrl:t.templateUrl("ToolboxGroup"),replace:!0}}]); \ No newline at end of file +angular.module("LayoutEditor",["ngSanitize","ngResource","ui.sortable"]);var LayoutEditor;!function(e){var t=function(){var e=this;this._clipboardData={},this._isDisabled=!1,this._wasInvoked=!1,this.setData=function(t,o){e._clipboardData[t]=o,e._wasInvoked=!0},this.getData=function(t){return e._clipboardData[t]},this.disable=function(){e._isDisabled=!0,e._wasInvoked=!1,e._clipboardData={}},this.isDisabled=function(){return e._isDisabled},this.wasInvoked=function(){return e._wasInvoked}};e.Clipboard=new t,angular.module("LayoutEditor").factory("clipboard",[function(){return{setData:e.Clipboard.setData,getData:e.Clipboard.getData,disable:e.Clipboard.disable,isDisabled:e.Clipboard.isDisabled,wasInvoked:e.Clipboard.wasInvoked}}])}(LayoutEditor||(LayoutEditor={})),angular.module("LayoutEditor").factory("scopeConfigurator",["$timeout","clipboard",function(e,t){return{configureForElement:function(e,o){o.find(".layout-panel").click(function(e){e.stopPropagation()}),o.parent().keydown(function(n){var l=!1,a=!1,i=e.element;if(!i.editor.isDragging){if(!t.isDisabled()){var r=i.editor.focusedElement;if(r&&n.ctrlKey)switch(n.which){case 67:r.copy(t);break;case 88:r.cut(t);break;case 86:r.paste(t)}}if(n.ctrlKey||n.shiftKey||n.altKey||46!=n.which?n.ctrlKey||n.shiftKey||n.altKey||32!=n.which&&27!=n.which||(o.find(".layout-panel-action-properties").first().click(),l=!0):(e["delete"](i),l=!0),"Content"==i.type&&(n.ctrlKey||n.shiftKey||n.altKey||13!=n.which||(o.find(".layout-panel-action-edit").first().click(),l=!0)),i.children&&(n.ctrlKey||n.shiftKey||!n.altKey||40!=n.which||(i.children.length>0&&i.children[0].setIsFocused(),l=!0),"Column"==i.type)){var c=!n.ctrlKey;37==n.which?(n.altKey&&i.expandLeft(c),n.shiftKey&&i.contractRight(c),l=!0):39==n.which&&(n.altKey&&i.contractLeft(c),n.shiftKey&&i.expandRight(c),l=!0)}i.parent&&(n.altKey&&38==n.which&&(i.parent.setIsFocused(),l=!0),"Row"==i.parent.type?n.ctrlKey||n.shiftKey||n.altKey||37!=n.which?n.ctrlKey||n.shiftKey||n.altKey||39!=n.which?!n.ctrlKey||n.shiftKey||n.altKey||37!=n.which?!n.ctrlKey||n.shiftKey||n.altKey||39!=n.which||(i.moveDown(),l=!0):(i.moveUp(),a=!0,l=!0):(i.parent.moveFocusNextChild(i),l=!0):(i.parent.moveFocusPrevChild(i),l=!0):n.ctrlKey||n.shiftKey||n.altKey||38!=n.which?n.ctrlKey||n.shiftKey||n.altKey||40!=n.which?!n.ctrlKey||n.shiftKey||n.altKey||38!=n.which?!n.ctrlKey||n.shiftKey||n.altKey||40!=n.which||(i.moveDown(),l=!0):(i.moveUp(),a=!0,l=!0):(i.parent.moveFocusNextChild(i),l=!0):(i.parent.moveFocusPrevChild(i),l=!0)),l&&n.preventDefault(),n.stopPropagation(),e.$apply(),a&&window.setTimeout(function(){e.$apply(function(){i.editor.focusedElement.setIsFocused()})},100)}}),e.element.setIsFocusedEventHandlers.push(function(){o.parent().focus()}),e["delete"]=function(e){e["delete"]()},e.element.hasEditor&&(e.edit=function(){e.$root.editElement(e.element).then(function(t){e.$apply(function(){t.cancel||(e.element.data=t.element.data)})})})},configureForContainer:function(t,o){var n=t.element;t.getShowChildrenPlaceholder=function(){return 0===t.element.children.length&&!t.element.getIsDropTarget()},t.sortableOptions={cursor:"move",delay:150,disabled:n.getIsSealed(),distance:5,start:function(e,o){t.$apply(function(){n.setIsDropTarget(!0),n.editor.isDragging=!0}),o.placeholder.height(o.item.height()-4),o.placeholder.css("min-height",0)},stop:function(e,o){t.$apply(function(){n.editor.isDragging=!1,n.setIsDropTarget(!1)})},over:function(t,l){l.sender&&l.sender[0].isToolbox&&(l.sender[0].dropTargetTimeout&&(e.cancel(l.sender[0].dropTargetTimeout),l.sender[0].dropTargetTimeout=null),e(function(){if("Row"==n.type){var e=n.editor.dropTargetElement;e&&"Row"==e.type&&e.rollbackAddColumn()}n.setIsDropTarget(!1)}),l.sender[0].dropTargetTimeout=e(function(){if("Row"==n.type){var e=l.item.sortable.model,t=Math.floor(12/(n.children.length+1));e.width=t,e.offset=0,n.beginAddColumn(t);var a=_.max(_(o.find("> .layout-children > .layout-column:not(.ui-sortable-placeholder)")).map(function(e){return $(e).height()}));for(i=1;i<=12;i++)l.placeholder.removeClass("col-xs-"+i);l.placeholder.addClass("col-xs-"+e.width),a>0?(l.placeholder.height(a),l.placeholder.css("min-height",0)):(l.placeholder.height(0),l.placeholder.css("min-height",""))}n.setIsDropTarget(!0)},150))},receive:function(o,l){l.sender&&l.sender[0].isToolbox&&t.$apply(function(){var o=l.item.sortable.model;o&&("Row"==n.type&&n.commitAddColumn(),o.setEditor(n.editor),o.setParent(n),o.hasEditor&&t.$root.editElement(o).then(function(t){t.cancel||(o.data=t.element.data,o.applyElementEditorModel(t.elementEditorModel),o.setHtml&&o.setHtml(t.element.html)),e(function(){t.cancel?o["delete"]():o.setIsFocused(),n.setIsDropTarget(!1)})})),e(function(){n.setIsDropTarget(!1),o&&o.setIsFocused()})})}},t.click=function(e,t){e.editor.isDragging||e.setIsFocused(),t.stopPropagation()},t.getClasses=function(e){var t=["layout-element"];return e.children&&(t.push("layout-container"),e.getIsSealed()&&t.push("layout-container-sealed")),t.push("layout-"+e.type.toLowerCase()),e.dropTargetClass&&t.push(e.dropTargetClass),"Row"==e.type&&(t.push("row"),e.canAddColumn()||t.push("layout-row-full")),"Column"==e.type&&(t.push("col-xs-"+e.width),t.push("col-xs-offset-"+e.offset)),"Content"==e.type&&t.push("layout-content-"+e.contentTypeClass),e.getIsActive()&&t.push("layout-element-active"),e.getIsFocused()&&t.push("layout-element-focused"),e.getIsSelected()&&t.push("layout-element-selected"),e.getIsDropTarget()&&t.push("layout-element-droptarget"),e.isTemplated&&t.push("layout-element-templated"),t}}}}]),angular.module("LayoutEditor").directive("orcLayoutEditor",["environment",function(environment){return{restrict:"E",scope:{},controller:["$scope","$element","$attrs","$compile","clipboard",function($scope,$element,$attrs,$compile,clipboard){if(!$attrs.model)throw new Error("The 'model' attribute must evaluate to a LayoutEditor.Editor object.");$scope.element=eval($attrs.model),$scope.click=function(e,t){e.editor.isDragging||e.setIsFocused(),t.stopPropagation()},$scope.getClasses=function(e){var t=["layout-element","layout-container","layout-canvas"];return e.getIsActive()&&t.push("layout-element-active"),e.getIsFocused()&&t.push("layout-element-focused"),e.getIsSelected()&&t.push("layout-element-selected"),e.getIsDropTarget()&&t.push("layout-element-droptarget"),e.isTemplated&&t.push("layout-element-templated"),t};var layoutDesignerHost=$(".layout-designer").data("layout-designer-host");$scope.$root.layoutDesignerHost=layoutDesignerHost,layoutDesignerHost.element.on("replacecanvas",function(e,t){var o=$scope.element,n={data:t.canvas.data,htmlId:t.canvas.htmlId,htmlClass:t.canvas.htmlClass,htmlStyle:t.canvas.htmlStyle,isTemplated:t.canvas.isTemplated,children:t.canvas.children};layoutDesignerHost.editor=window.layoutEditor=new LayoutEditor.Editor(o.config,n);var l="",a=$compile(l)($scope);$(".layout-editor-holder").html(a)}),$scope.$root.editElement=function(e){var t=$scope.$root.layoutDesignerHost;return t.editElement(e)},$scope.$root.addElement=function(e){var t=$scope.$root.layoutDesignerHost;return t.addElement(e)},$(document).on("cut copy paste",function(e){if(clipboard.wasInvoked())e.originalEvent.clipboardData.setData("text/plain",clipboard.getData("text/plain")),e.originalEvent.clipboardData.setData("text/json",clipboard.getData("text/json")),e.preventDefault();else{var t=$scope.element.focusedElement;t&&($scope.$apply(function(){switch(e.type){case"copy":t.copy(e.originalEvent.clipboardData);break;case"cut":t.cut(e.originalEvent.clipboardData);break;case"paste":t.paste(e.originalEvent.clipboardData)}}),window.setTimeout(function(){$scope.$apply(function(){$scope.element.focusedElement&&$scope.element.focusedElement.setIsFocused()})},100),e.preventDefault())}clipboard.disable()})}],templateUrl:environment.templateUrl("Editor"),replace:!0,link:function(e,t){t.find(".layout-toolbar-container").click(function(e){e.stopPropagation()}),$(window).click(function(t){e.$apply(function(){e.element.activeElement=null,e.element.focusedElement=null})})}}}]),angular.module("LayoutEditor").directive("orcLayoutCanvas",["scopeConfigurator","environment",function(e,t){return{restrict:"E",scope:{element:"="},controller:["$scope","$element","$attrs",function(t,o,n){e.configureForElement(t,o),e.configureForContainer(t,o),t.sortableOptions.axis="y"}],templateUrl:t.templateUrl("Canvas"),replace:!0}}]),angular.module("LayoutEditor").directive("orcLayoutChild",["$compile",function(e){return{restrict:"E",scope:{element:"="},link:function(t,o){var n="",l=e(n)(t);$(o).replaceWith(l)}}}]),angular.module("LayoutEditor").directive("orcLayoutColumn",["$compile","scopeConfigurator","environment",function(e,t,o){return{restrict:"E",scope:{element:"="},controller:["$scope","$element",function(e,o){t.configureForElement(e,o),t.configureForContainer(e,o),e.sortableOptions.axis="y"}],templateUrl:o.templateUrl("Column"),replace:!0,link:function(e,t,o){t.find(".layout-column-resize-bar").draggable({axis:"x",helper:"clone",revert:!0,start:function(t,o){e.$apply(function(){e.element.editor.isResizing=!0})},drag:function(o,n){var l=t.parent(),a=l.width()/e.element.width,i=!o.ctrlKey;if($(o.target).hasClass("layout-column-resize-bar-left")){var r=n.offset.left-l.offset().left;-a>r&&e.element.canExpandLeft(i)?e.$apply(function(){e.element.expandLeft(i)}):r>a&&e.element.canContractLeft(i)&&e.$apply(function(){e.element.contractLeft(i)})}else if($(o.target).hasClass("layout-column-resize-bar-right")){var r=n.offset.left-l.width()-l.offset().left;r>a&&e.element.canExpandRight(i)?e.$apply(function(){e.element.expandRight(i)}):-a>r&&e.element.canContractRight(i)&&e.$apply(function(){e.element.contractRight(i)})}},stop:function(t,o){e.$apply(function(){e.element.editor.isResizing=!1})}})}}}]),angular.module("LayoutEditor").directive("orcLayoutContent",["$sce","scopeConfigurator","environment",function(e,t,o){return{restrict:"E",scope:{element:"="},controller:["$scope","$element",function(o,n){t.configureForElement(o,n),o.element.hasEditor&&(o.edit=function(){o.$root.editElement(o.element).then(function(e){o.$apply(function(){e.cancel||(o.element.data=e.element.data,o.element.setHtml(e.element.html))})})}),o.element.setHtml=function(t){o.element.html=t,o.element.htmlUnsafe=e.trustAsHtml(t)},o.element.setHtml(o.element.html)}],templateUrl:o.templateUrl("Content"),replace:!0}}]),angular.module("LayoutEditor").directive("orcLayoutGrid",["$compile","scopeConfigurator","environment",function(e,t,o){return{restrict:"E",scope:{element:"="},controller:["$scope","$element",function(e,o){t.configureForElement(e,o),t.configureForContainer(e,o),e.sortableOptions.axis="y"}],templateUrl:o.templateUrl("Grid"),replace:!0}}]),angular.module("LayoutEditor").directive("orcLayoutRow",["$compile","scopeConfigurator","environment",function(e,t,o){return{restrict:"E",scope:{element:"="},controller:["$scope","$element",function(e,o){t.configureForElement(e,o),t.configureForContainer(e,o),e.sortableOptions.axis="x",e.sortableOptions["ui-floating"]=!0}],templateUrl:o.templateUrl("Row"),replace:!0}}]),angular.module("LayoutEditor").directive("orcLayoutPopup",[function(){return{restrict:"A",link:function(e,t,o){var n=$(t),l=n.closest(".layout-popup-trigger"),a=n.closest(".layout-element");l.click(function(){n.toggle(),n.is(":visible")&&(n.position({my:o.orcLayoutPopupMy||"left top",at:o.orcLayoutPopupAt||"left bottom+4px",of:l}),n.find("input").first().focus())}),n.click(function(e){e.stopPropagation()}),a.click(function(e){n.hide()}),n.keydown(function(e){e.ctrlKey||e.shiftKey||e.altKey||27!=e.which||n.hide(),e.stopPropagation()}),n.on("cut copy paste",function(e){e.stopPropagation()})}}}]),angular.module("LayoutEditor").directive("orcLayoutToolbox",["$compile","environment",function(e,t){return{restrict:"E",controller:["$scope","$element",function(e,t){e.resetElements=function(){e.gridElements=[LayoutEditor.Grid.from({toolboxIcon:"",toolboxLabel:"Grid",toolboxDescription:"Empty grid.",children:[]})],e.rowElements=[LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (1 column)",toolboxDescription:"Row with 1 column.",children:LayoutEditor.Column.times(1)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (2 columns)",toolboxDescription:"Row with 2 columns.",children:LayoutEditor.Column.times(2)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (3 columns)",toolboxDescription:"Row with 3 columns.",children:LayoutEditor.Column.times(3)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (4 columns)",toolboxDescription:"Row with 4 columns.",children:LayoutEditor.Column.times(4)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (6 columns)",toolboxDescription:"Row with 6 columns.",children:LayoutEditor.Column.times(6)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (12 columns)",toolboxDescription:"Row with 12 columns.",children:LayoutEditor.Column.times(12)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (empty)",toolboxDescription:"Empty row.",children:[]})],e.columnElements=[LayoutEditor.Column.from({toolboxIcon:"",toolboxLabel:"Column",toolboxDescription:"Empty column.",width:1,offset:0,children:[]})],e.canvasElements=[LayoutEditor.Canvas.from({toolboxIcon:"",toolboxLabel:"Canvas",toolboxDescription:"Empty canvas.",children:[]})],e.contentElementCategories=_(e.element.config.categories).map(function(e){return{name:e.name,elements:_(e.contentTypes).map(function(e){var t=e.type,o=LayoutEditor.factories[t]||LayoutEditor.factories.Content,n={isTemplated:!1,contentType:e.id,contentTypeLabel:e.label,contentTypeClass:e.typeClass,data:null,hasEditor:e.hasEditor,html:e.html},l=o(n);return l.toolboxIcon=e.icon||"",l.toolboxLabel=e.label,l.toolboxDescription=e.description,l})}})},e.resetElements(),e.getSortableOptions=function(o){var n,l,a=t.closest(".layout-editor").attr("id"),i=!1;switch(o){case"Grid":n=[".layout-canvas",".layout-column",".layout-common-holder"],l="layout-element layout-container layout-grid ui-sortable-placeholder";break;case"Row":n=[".layout-grid"],l="layout-element layout-container layout-row row ui-sortable-placeholder";break;case"Column":n=[".layout-row:not(.layout-row-full)"],l="layout-element layout-container layout-column ui-sortable-placeholder",i=!0;break;case"Content":n=[".layout-canvas",".layout-column",".layout-common-holder"],l="layout-element layout-content ui-sortable-placeholder";break;case"Canvas":n=[".layout-canvas",".layout-column",".layout-common-holder"],l="layout-element layout-container layout-grid ui-sortable-placeholder"}return{cursor:"move",connectWith:_(n).map(function(e){return"#"+a+" "+e+":not(.layout-container-sealed) > .layout-element-wrapper > .layout-children"}).join(", "),placeholder:l,"ui-floating":i,create:function(e,t){e.target.isToolbox=!0},start:function(t,o){e.$apply(function(){e.element.isDragging=!0})},stop:function(t,o){e.$apply(function(){e.element.isDragging=!1,e.resetElements()})},over:function(t,o){e.$apply(function(){e.element.canvas.setIsDropTarget(!1)})}}};var o="layoutToolboxCategory_Layout_IsCollapsed";e.layoutIsCollapsed="true"===$.cookie(o),e.toggleLayoutIsCollapsed=function(t){e.layoutIsCollapsed=!e.layoutIsCollapsed,$.cookie(o,e.layoutIsCollapsed,{expires:365}),t.preventDefault(),t.stopPropagation()}}],templateUrl:t.templateUrl("Toolbox"),replace:!0,link:function(e,t){var o=t.find(".layout-toolbox");$(window).on("resize scroll",function(e){var n=t.parent().find(".layout-canvas"),l=!!n&&n.height()>o.height(),a=$(window).scrollTop();l&&a>t.offset().top+t.height()-o.height()?(o.addClass("sticky-bottom"),o.removeClass("sticky-top")):l&&a>t.offset().top?(o.addClass("sticky-top"),o.removeClass("sticky-bottom")):(o.removeClass("sticky-top"),o.removeClass("sticky-bottom"))})}}}]),angular.module("LayoutEditor").directive("orcLayoutToolboxGroup",["$compile","environment",function(e,t){return{restrict:"E",scope:{category:"="},controller:["$scope","$element",function(e,t){var o="layoutToolboxCategory_"+e.category.name+"_IsCollapsed";e.isCollapsed="true"===$.cookie(o),e.toggleIsCollapsed=function(t){e.isCollapsed=!e.isCollapsed,$.cookie(o,e.isCollapsed,{expires:365}),t.preventDefault(),t.stopPropagation()}}],templateUrl:t.templateUrl("ToolboxGroup"),replace:!0}}]); \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.js b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.js index 63de38bcd..877eff69d 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.js @@ -122,6 +122,7 @@ var LayoutEditor; this.isTemplated = isTemplated; this.rule = rule; + this.templateStyles = {}; this.editor = null; this.parent = null; this.setIsFocusedEventHandlers = []; @@ -300,6 +301,17 @@ var LayoutEditor; if (!!this.parent) this.parent.paste(clipboardData); }; + + this.getTemplateStyles = function () { + var styles = this.templateStyles || {}; + var css = ""; + + for (var property in styles) { + css += property + ":" + styles[property] + ";"; + } + + return css; + } }; })(LayoutEditor || (LayoutEditor = {})); @@ -311,6 +323,7 @@ var LayoutEditor; this.allowedChildTypes = allowedChildTypes; this.children = children; this.isContainer = true; + this.containerTemplateStyles = {}; var self = this; @@ -444,6 +457,17 @@ var LayoutEditor; else if (!!this.parent) this.parent.pasteChild(child); } + + this.getContainerTemplateStyles = function () { + var styles = this.containerTemplateStyles || {}; + var css = ""; + + for (var property in styles) { + css += property + ":" + styles[property] + ";"; + } + + return css; + } }; })(LayoutEditor || (LayoutEditor = {})); @@ -1014,74 +1038,4 @@ var LayoutEditor; }; })(LayoutEditor || (LayoutEditor = {})); -var LayoutEditor; -(function ($, LayoutEditor) { - - LayoutEditor.Html = function (data, htmlId, htmlClass, htmlStyle, isTemplated, contentType, contentTypeLabel, contentTypeClass, html, hasEditor, rule) { - LayoutEditor.Element.call(this, "Html", data, htmlId, htmlClass, htmlStyle, isTemplated, rule); - - this.contentType = contentType; - this.contentTypeLabel = contentTypeLabel; - this.contentTypeClass = contentTypeClass; - this.html = html; - this.hasEditor = hasEditor; - this.isContainable = true; - - this.getInnerText = function () { - return $($.parseHTML("
    " + this.html + "
    ")).text(); - }; - - // This function will be overwritten by the Content directive. - this.setHtml = function (html) { - this.html = html; - this.htmlUnsafe = html; - } - - this.toObject = function () { - return { - "type": "Html" - }; - }; - - this.toObject = function () { - var result = this.elementToObject(); - result.contentType = this.contentType; - result.contentTypeLabel = this.contentTypeLabel; - result.contentTypeClass = this.contentTypeClass; - result.html = this.html; - result.hasEditor = hasEditor; - return result; - }; - - var getEditorObject = this.getEditorObject; - this.getEditorObject = function () { - var dto = getEditorObject(); - return $.extend(dto, { - Content: this.html - }); - } - - this.setHtml(html); - }; - - LayoutEditor.Html.from = function (value) { - var result = new LayoutEditor.Html( - value.data, - value.htmlId, - value.htmlClass, - value.htmlStyle, - value.isTemplated, - value.contentType, - value.contentTypeLabel, - value.contentTypeClass, - value.html, - value.hasEditor, - value.rule); - - return result; - }; - - LayoutEditor.registerFactory("Html", function(value) { return LayoutEditor.Html.from(value); }); - -})(jQuery, LayoutEditor || (LayoutEditor = {})); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Models.js","Helpers.js","Editor.js","RecycleBin.js","Element.js","Container.js","Canvas.js","Grid.js","Row.js","Column.js","Content.js","Html.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA,ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACnMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC/IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACl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file":"Models.js","sourcesContent":[null,"var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    Array.prototype.move = function (from, to) {\r\n        this.splice(to, 0, this.splice(from, 1)[0]);\r\n    };\r\n\r\n    LayoutEditor.childrenFrom = function(values) {\r\n        return _(values).map(function(value) {\r\n            return LayoutEditor.elementFrom(value);\r\n        });\r\n    };\r\n\r\n    var registerFactory = LayoutEditor.registerFactory = function(type, factory) {\r\n        var factories = LayoutEditor.factories = LayoutEditor.factories || {};\r\n        factories[type] = factory;\r\n    };\r\n\r\n    registerFactory(\"Canvas\", function (value) { return LayoutEditor.Canvas.from(value); });\r\n    registerFactory(\"Grid\", function(value) { return LayoutEditor.Grid.from(value); });\r\n    registerFactory(\"Row\", function(value) { return LayoutEditor.Row.from(value); });\r\n    registerFactory(\"Column\", function(value) { return LayoutEditor.Column.from(value); });\r\n    registerFactory(\"Content\", function(value) { return LayoutEditor.Content.from(value); });\r\n\r\n    LayoutEditor.elementFrom = function (value) {\r\n        var factory = LayoutEditor.factories[value.type];\r\n\r\n        if (!factory)\r\n            throw new Error(\"No element with type \\\"\" + value.type + \"\\\" was found.\");\r\n\r\n        var element = factory(value);\r\n        return element;\r\n    };\r\n\r\n    LayoutEditor.setModel = function (elementSelector, model) {\r\n        $(elementSelector).scope().element = model;\r\n    };\r\n\r\n    LayoutEditor.getModel = function (elementSelector) {\r\n        return $(elementSelector).scope().element;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Editor = function (config, canvasData) {\r\n        this.config = config;\r\n        this.canvas = LayoutEditor.Canvas.from(canvasData);\r\n        this.initialState = JSON.stringify(this.canvas.toObject());\r\n        this.activeElement = null;\r\n        this.focusedElement = null;\r\n        this.dropTargetElement = null;\r\n        this.isDragging = false;\r\n        this.isResizing = false;\r\n        this.recycleBin = new LayoutEditor.RecycleBin();\r\n\r\n        this.resetToolboxElements = function () {\r\n            this.toolboxElements = [\r\n                LayoutEditor.Row.from({\r\n                    children: []\r\n                })\r\n            ];\r\n        };\r\n\r\n        this.isDirty = function() {\r\n            var currentState = JSON.stringify(this.canvas.toObject());\r\n            return this.initialState != currentState;\r\n        };\r\n\r\n        this.resetToolboxElements();\r\n        this.canvas.setEditor(this);\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));\r\n","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.RecycleBin = function () {\r\n        this.elements = [];\r\n\r\n        this.add = function(element) {\r\n            this.elements.push(element);\r\n        };\r\n\r\n        this.toObject = function () {\r\n            var result = {\r\n                type: \"RecycleBin\",\r\n                children: []\r\n            };\r\n\r\n            for (var i = 0; i < this.elements.length; i++) {\r\n                var element = this.elements[i];\r\n                var dto = element.toObject();\r\n                result.children.push(dto);\r\n            }\r\n\r\n            return result;\r\n        };\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));\r\n","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Element = function (type, data, htmlId, htmlClass, htmlStyle, isTemplated, rule) {\r\n        if (!type)\r\n            throw new Error(\"Parameter 'type' is required.\");\r\n\r\n        this.type = type;\r\n        this.data = data;\r\n        this.htmlId = htmlId;\r\n        this.htmlClass = htmlClass;\r\n        this.htmlStyle = htmlStyle;\r\n        this.isTemplated = isTemplated;\r\n        this.rule = rule;\r\n\r\n        this.editor = null;\r\n        this.parent = null;\r\n        this.setIsFocusedEventHandlers = [];\r\n\r\n        this.setEditor = function (editor) {\r\n            this.editor = editor;\r\n            if (!!this.children && _.isArray(this.children)) {\r\n                _(this.children).each(function (child) {\r\n                    child.setEditor(editor);\r\n                });\r\n            }\r\n        };\r\n\r\n        this.setParent = function(parentElement) {\r\n            this.parent = parentElement;\r\n            this.parent.onChildAdded(this);\r\n\r\n            var currentAncestor = parentElement;\r\n            while (!!currentAncestor) {\r\n                currentAncestor.onDescendantAdded(this, parentElement);\r\n                currentAncestor = currentAncestor.parent;\r\n            }\r\n        };\r\n\r\n        this.setIsTemplated = function (value) {\r\n            this.isTemplated = value;\r\n            if (!!this.children && _.isArray(this.children)) {\r\n                _(this.children).each(function (child) {\r\n                    child.setIsTemplated(value);\r\n                });\r\n            }\r\n        };\r\n\r\n        this.applyElementEditorModel = function() { /* Virtual */ };\r\n\r\n        this.getIsActive = function () {\r\n            if (!this.editor)\r\n                return false;\r\n            return this.editor.activeElement === this && !this.getIsFocused();\r\n        };\r\n\r\n        this.setIsActive = function (value) {\r\n            if (!this.editor)\r\n                return;\r\n            if (this.editor.isDragging || this.editor.isResizing)\r\n                return;\r\n\r\n            if (value)\r\n                this.editor.activeElement = this;\r\n            else\r\n                this.editor.activeElement = this.parent;\r\n        };\r\n\r\n        this.getIsFocused = function () {\r\n            if (!this.editor)\r\n                return false;\r\n            return this.editor.focusedElement === this;\r\n        };\r\n\r\n        this.setIsFocused = function () {\r\n            if (!this.editor)\r\n            \treturn;\r\n            if (!this.children && this.isTemplated)\r\n            \treturn;\r\n            if (this.editor.isDragging || this.editor.isResizing)\r\n                return;\r\n\r\n            this.editor.focusedElement = this;\r\n            _(this.setIsFocusedEventHandlers).each(function (item) {\r\n                try {\r\n                    item();\r\n                }\r\n                catch (ex) {\r\n                    // Ignore.\r\n                }\r\n            });\r\n        };\r\n\r\n        this.getIsSelected = function () {\r\n            if (this.getIsFocused())\r\n                return true;\r\n\r\n            if (!!this.children && _.isArray(this.children)) {\r\n                return _(this.children).any(function(child) {\r\n                    return child.getIsSelected();\r\n                });\r\n            }\r\n\r\n            return false;\r\n        };\r\n\r\n        this.getIsDropTarget = function () {\r\n            if (!this.editor)\r\n                return false;\r\n            return this.editor.dropTargetElement === this;\r\n        }\r\n\r\n        this.setIsDropTarget = function (value) {\r\n            if (!this.editor)\r\n                return;\r\n            if (value)\r\n                this.editor.dropTargetElement = this;\r\n            else\r\n                this.editor.dropTargetElement = null;\r\n        };\r\n\r\n        this.canDelete = function () {\r\n            if (this.isTemplated || !this.parent)\r\n                return false;\r\n            return true;\r\n        };\r\n\r\n        this.delete = function () {\r\n            if (!this.canDelete())\r\n                return;\r\n            this.parent.deleteChild(this);\r\n        };\r\n\r\n        this.canMoveUp = function () {\r\n            if (this.isTemplated || !this.parent)\r\n                return false;\r\n            return this.parent.canMoveChildUp(this);\r\n        };\r\n\r\n        this.moveUp = function () {\r\n            if (!this.canMoveUp())\r\n                return;\r\n            this.parent.moveChildUp(this);\r\n        };\r\n\r\n        this.canMoveDown = function () {\r\n            if (this.isTemplated || !this.parent)\r\n                return false;\r\n            return this.parent.canMoveChildDown(this);\r\n        };\r\n\r\n        this.moveDown = function () {\r\n            if (!this.canMoveDown())\r\n                return;\r\n            this.parent.moveChildDown(this);\r\n        };\r\n\r\n        this.elementToObject = function () {\r\n            return {\r\n                type: this.type,\r\n                data: this.data,\r\n                htmlId: this.htmlId,\r\n                htmlClass: this.htmlClass,\r\n                htmlStyle: this.htmlStyle,\r\n                isTemplated: this.isTemplated,\r\n                rule: this.rule\r\n            };\r\n        };\r\n\r\n        this.getEditorObject = function() {\r\n            return {};\r\n        };\r\n\r\n        this.copy = function (clipboardData) {\r\n            var text = this.getInnerText();\r\n            clipboardData.setData(\"text/plain\", text);\r\n\r\n            var data = this.toObject();\r\n            var json = JSON.stringify(data, null, \"\\t\");\r\n            clipboardData.setData(\"text/json\", json);\r\n        };\r\n\r\n        this.cut = function (clipboardData) {\r\n            if (this.canDelete()) {\r\n                this.copy(clipboardData);\r\n                this.delete();\r\n            }\r\n        };\r\n\r\n        this.paste = function (clipboardData) {\r\n            if (!!this.parent)\r\n                this.parent.paste(clipboardData);\r\n        };\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Container = function (allowedChildTypes, children) {\r\n\r\n        this.allowedChildTypes = allowedChildTypes;\r\n        this.children = children;\r\n        this.isContainer = true;\r\n\r\n        var self = this;\r\n\r\n        this.onChildAdded = function (element) { /* Virtual */ };\r\n        this.onDescendantAdded = function (element, parentElement) { /* Virtual */ };\r\n\r\n        this.setChildren = function (children) {\r\n            this.children = children;\r\n            _(this.children).each(function (child) {\r\n                child.setParent(self);\r\n            });\r\n        };\r\n\r\n        this.setChildren(children);\r\n\r\n        this.getIsSealed = function () {\r\n            return _(this.children).any(function (child) {\r\n                return child.isTemplated;\r\n            });\r\n        };\r\n\r\n        var _baseSetIsFocused = this.setIsFocused;\r\n        this.setIsFocused = function () {\r\n            if (this.getIsSealed())\r\n                return;\r\n            _baseSetIsFocused.call(this);\r\n        };\r\n\r\n        this.addChild = function (child) {\r\n            if (!_(this.children).contains(child) && (_(this.allowedChildTypes).contains(child.type) || child.isContainable))\r\n                this.children.push(child);\r\n            child.setEditor(this.editor);\r\n            child.setIsTemplated(false);\r\n            child.setParent(this);\r\n        };\r\n\r\n        this.deleteChild = function (child) {\r\n            var index = _(this.children).indexOf(child);\r\n            if (index >= 0) {\r\n                this.children.splice(index, 1);\r\n                this.editor.recycleBin.add(child);\r\n                if (child.getIsActive())\r\n                    this.editor.activeElement = null;\r\n                if (child.getIsFocused()) {\r\n                    // If the deleted child was focused, try to set new focus to the most appropriate sibling or parent.\r\n                    if (this.children.length > index)\r\n                        this.children[index].setIsFocused();\r\n                    else if (index > 0)\r\n                        this.children[index - 1].setIsFocused();\r\n                    else\r\n                        this.setIsFocused();\r\n                }\r\n            }\r\n        };\r\n\r\n        this.moveFocusPrevChild = function (child) {\r\n            if (this.children.length < 2)\r\n                return;\r\n            var index = _(this.children).indexOf(child);\r\n            if (index > 0)\r\n                this.children[index - 1].setIsFocused();\r\n        };\r\n\r\n        this.moveFocusNextChild = function (child) {\r\n            if (this.children.length < 2)\r\n                return;\r\n            var index = _(this.children).indexOf(child);\r\n            if (index < this.children.length - 1)\r\n                this.children[index + 1].setIsFocused();\r\n        };\r\n\r\n        this.insertChild = function (child, afterChild) {\r\n            if (!_(this.children).contains(child)) {\r\n                var index = Math.max(_(this.children).indexOf(afterChild), 0);\r\n                this.children.splice(index + 1, 0, child);\r\n                child.setEditor(this.editor);\r\n                child.parent = this;\r\n            }\r\n        };\r\n\r\n        this.moveChildUp = function (child) {\r\n            if (!this.canMoveChildUp(child))\r\n                return;\r\n            var index = _(this.children).indexOf(child);\r\n            this.children.move(index, index - 1);\r\n        };\r\n\r\n        this.moveChildDown = function (child) {\r\n            if (!this.canMoveChildDown(child))\r\n                return;\r\n            var index = _(this.children).indexOf(child);\r\n            this.children.move(index, index + 1);\r\n        };\r\n\r\n        this.canMoveChildUp = function (child) {\r\n            var index = _(this.children).indexOf(child);\r\n            return index > 0;\r\n        };\r\n\r\n        this.canMoveChildDown = function (child) {\r\n            var index = _(this.children).indexOf(child);\r\n            return index < this.children.length - 1;\r\n        };\r\n\r\n        this.childrenToObject = function () {\r\n            return _(this.children).map(function (child) {\r\n                return child.toObject();\r\n            });\r\n        };\r\n\r\n        this.getInnerText = function () {\r\n            return _(this.children).reduce(function (memo, child) {\r\n                return memo + \"\\n\" + child.getInnerText();\r\n            }, \"\");\r\n        }\r\n\r\n        this.paste = function (clipboardData) {\r\n            var json = clipboardData.getData(\"text/json\");\r\n            if (!!json) {\r\n                var data = JSON.parse(json);\r\n                var child = LayoutEditor.elementFrom(data);\r\n                this.pasteChild(child);\r\n            }\r\n        };\r\n\r\n        this.pasteChild = function (child) {\r\n            if (_(this.allowedChildTypes).contains(child.type) || child.isContainable) {\r\n                this.addChild(child);\r\n                child.setIsFocused();\r\n            }\r\n            else if (!!this.parent)\r\n                this.parent.pasteChild(child);\r\n        }\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Canvas = function (data, htmlId, htmlClass, htmlStyle, isTemplated, rule, children) {\r\n        LayoutEditor.Element.call(this, \"Canvas\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n        LayoutEditor.Container.call(this, [\"Canvas\", \"Grid\", \"Content\"], children);\r\n\r\n        this.isContainable = true;\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.children = this.childrenToObject();\r\n            return result;\r\n        };\r\n    };\r\n\r\n    LayoutEditor.Canvas.from = function (value) {\r\n        var result = new LayoutEditor.Canvas(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.rule,\r\n            LayoutEditor.childrenFrom(value.children));\r\n\r\n        result.toolboxIcon = value.toolboxIcon;\r\n        result.toolboxLabel = value.toolboxLabel;\r\n        result.toolboxDescription = value.toolboxDescription;\r\n\r\n        return result;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));\r\n","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Grid = function (data, htmlId, htmlClass, htmlStyle, isTemplated, rule, children) {\r\n        LayoutEditor.Element.call(this, \"Grid\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n        LayoutEditor.Container.call(this, [\"Row\"], children);\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.children = this.childrenToObject();\r\n            return result;\r\n        };\r\n    };\r\n\r\n    LayoutEditor.Grid.from = function (value) {\r\n        var result = new LayoutEditor.Grid(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.rule,\r\n            LayoutEditor.childrenFrom(value.children));\r\n        result.toolboxIcon = value.toolboxIcon;\r\n        result.toolboxLabel = value.toolboxLabel;\r\n        result.toolboxDescription = value.toolboxDescription;\r\n        return result;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Row = function (data, htmlId, htmlClass, htmlStyle, isTemplated, rule, children) {\r\n        LayoutEditor.Element.call(this, \"Row\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n        LayoutEditor.Container.call(this, [\"Column\"], children);\r\n\r\n        var _self = this;\r\n\r\n        function _getTotalColumnsWidth() {\r\n            return _(_self.children).reduce(function (memo, child) {\r\n                return memo + child.offset + child.width;\r\n            }, 0);\r\n        }\r\n\r\n        // Implements a simple algorithm to distribute space (either positive or negative)\r\n        // between the child columns of the row. Negative space is distributed when making\r\n        // room for a new column (e.c. clipboard paste or dropping from the toolbox) while\r\n        // positive space is distributed when filling the grap of a removed column.\r\n        function _distributeSpace(space) {\r\n            if (space == 0)\r\n                return true;\r\n             \r\n            var undistributedSpace = space;\r\n\r\n            if (undistributedSpace < 0) {\r\n                var vacantSpace = 12 - _getTotalColumnsWidth();\r\n                undistributedSpace += vacantSpace;\r\n                if (undistributedSpace > 0)\r\n                    undistributedSpace = 0;\r\n            }\r\n\r\n            // If space is negative, try to decrease offsets first.\r\n            while (undistributedSpace < 0 && _(_self.children).any(function (column) { return column.offset > 0; })) { // While there is still offset left to remove.\r\n                for (i = 0; i < _self.children.length && undistributedSpace < 0; i++) {\r\n                    var column = _self.children[i];\r\n                    if (column.offset > 0) {\r\n                        column.offset--;\r\n                        undistributedSpace++;\r\n                    }\r\n                }\r\n            }\r\n\r\n            function hasWidth(column) {\r\n                if (undistributedSpace > 0)\r\n                    return column.width < 12;\r\n                else if (undistributedSpace < 0)\r\n                    return column.width > 1;\r\n                return false;\r\n            }\r\n\r\n            // Try to distribute remaining space (could be negative or positive) using widths.\r\n            while (undistributedSpace != 0) {\r\n                // Any more column width available for distribution?\r\n                if (!_(_self.children).any(hasWidth))\r\n                    break;\r\n                for (i = 0; i < _self.children.length && undistributedSpace != 0; i++) {\r\n                    var column = _self.children[i % _self.children.length];\r\n                    if (hasWidth(column)) {\r\n                        var delta = undistributedSpace / Math.abs(undistributedSpace);\r\n                        column.width += delta;\r\n                        undistributedSpace -= delta;\r\n                    }\r\n                }                \r\n            }\r\n\r\n            return undistributedSpace == 0;\r\n        }\r\n\r\n        var _isAddingColumn = false;\r\n\r\n        this.canAddColumn = function () {\r\n            return this.children.length < 12;\r\n        };\r\n\r\n        this.beginAddColumn = function (newColumnWidth) {\r\n            if (!!_isAddingColumn)\r\n                throw new Error(\"Column add operation is already in progress.\")\r\n            _(this.children).each(function (column) {\r\n                column.beginChange();\r\n            });\r\n            if (_distributeSpace(-newColumnWidth)) {\r\n                _isAddingColumn = true;\r\n                return true;\r\n            }\r\n            _(this.children).each(function (column) {\r\n                column.rollbackChange();\r\n            });\r\n            return false;\r\n        };\r\n\r\n        this.commitAddColumn = function () {\r\n            if (!_isAddingColumn)\r\n                throw new Error(\"No column add operation in progress.\")\r\n            _(this.children).each(function (column) {\r\n                column.commitChange();\r\n            });\r\n            _isAddingColumn = false;\r\n        };\r\n\r\n        this.rollbackAddColumn = function () {\r\n            if (!_isAddingColumn)\r\n                throw new Error(\"No column add operation in progress.\")\r\n            _(this.children).each(function (column) {\r\n                column.rollbackChange();\r\n            });\r\n            _isAddingColumn = false;\r\n        };\r\n\r\n        var _baseDeleteChild = this.deleteChild;\r\n        this.deleteChild = function (column) { \r\n            var width = column.width;\r\n            _baseDeleteChild.call(this, column);\r\n            _distributeSpace(width);\r\n        };\r\n\r\n        this.canContractColumnRight = function (column, connectAdjacent) {\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0)\r\n                return column.width > 1;\r\n            return false;\r\n        };\r\n\r\n        this.contractColumnRight = function (column, connectAdjacent) {\r\n            if (!this.canContractColumnRight(column, connectAdjacent))\r\n                return;\r\n\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (column.width > 1) {\r\n                    column.width--;\r\n                    if (this.children.length > index + 1) {\r\n                        var nextColumn = this.children[index + 1];\r\n                        if (connectAdjacent && nextColumn.offset == 0)\r\n                            nextColumn.width++;\r\n                        else\r\n                            nextColumn.offset++;\r\n                    }\r\n                }\r\n            }\r\n        };\r\n\r\n        this.canExpandColumnRight = function (column, connectAdjacent) {\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (column.width >= 12)\r\n                    return false;\r\n                if (this.children.length > index + 1) {\r\n                    var nextColumn = this.children[index + 1];\r\n                    if (connectAdjacent && nextColumn.offset == 0)\r\n                        return nextColumn.width > 1;\r\n                    else\r\n                        return nextColumn.offset > 0;\r\n                }\r\n                return _getTotalColumnsWidth() < 12;\r\n            }\r\n            return false;\r\n        };\r\n\r\n        this.expandColumnRight = function (column, connectAdjacent) {\r\n            if (!this.canExpandColumnRight(column, connectAdjacent))\r\n                return;\r\n\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (this.children.length > index + 1) {\r\n                    var nextColumn = this.children[index + 1];\r\n                    if (connectAdjacent && nextColumn.offset == 0)\r\n                        nextColumn.width--;\r\n                    else\r\n                        nextColumn.offset--;\r\n                }\r\n                column.width++;\r\n            }\r\n        };\r\n\r\n        this.canExpandColumnLeft = function (column, connectAdjacent) {\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (column.width >= 12)\r\n                    return false;\r\n                if (index > 0) {\r\n                    var prevColumn = this.children[index - 1];\r\n                    if (connectAdjacent && column.offset == 0)\r\n                        return prevColumn.width > 1;\r\n                }\r\n                return column.offset > 0;\r\n            }\r\n            return false;\r\n        };\r\n\r\n        this.expandColumnLeft = function (column, connectAdjacent) {\r\n            if (!this.canExpandColumnLeft(column, connectAdjacent))\r\n                return;\r\n\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (index > 0) {\r\n                    var prevColumn = this.children[index - 1];\r\n                    if (connectAdjacent && column.offset == 0)\r\n                        prevColumn.width--;\r\n                    else\r\n                        column.offset--;\r\n                }\r\n                else\r\n                    column.offset--;\r\n                column.width++;\r\n            }\r\n        };\r\n\r\n        this.canContractColumnLeft = function (column, connectAdjacent) {\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0)\r\n                return column.width > 1;\r\n            return false;\r\n        };\r\n\r\n        this.contractColumnLeft = function (column, connectAdjacent) {\r\n            if (!this.canContractColumnLeft(column, connectAdjacent))\r\n                return;\r\n\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (index > 0) {\r\n                    var prevColumn = this.children[index - 1];\r\n                    if (connectAdjacent && column.offset == 0)\r\n                        prevColumn.width++;\r\n                    else\r\n                        column.offset++;\r\n                }\r\n                else\r\n                    column.offset++;\r\n                column.width--;\r\n            }\r\n        };\r\n\r\n        this.evenColumns = function () {\r\n            if (this.children.length == 0)\r\n                return;\r\n\r\n            var evenWidth = Math.floor(12 / this.children.length);\r\n            _(this.children).each(function (column) {\r\n                column.width = evenWidth;\r\n                column.offset = 0;\r\n            });\r\n\r\n            var rest = 12 % this.children.length;\r\n            if (rest > 0)\r\n                _distributeSpace(rest);\r\n        };\r\n\r\n        var _basePasteChild = this.pasteChild;\r\n        this.pasteChild = function (child) {\r\n            if (child.type == \"Column\") {\r\n                if (this.beginAddColumn(child.width)) {\r\n                    this.commitAddColumn();\r\n                    _basePasteChild.call(this, child)\r\n                }\r\n            }\r\n            else if (!!this.parent)\r\n                this.parent.pasteChild(child);\r\n        }\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.children = this.childrenToObject();\r\n            return result;\r\n        };\r\n    };\r\n\r\n    LayoutEditor.Row.from = function (value) {\r\n        var result = new LayoutEditor.Row(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.rule,\r\n            LayoutEditor.childrenFrom(value.children));\r\n        result.toolboxIcon = value.toolboxIcon;\r\n        result.toolboxLabel = value.toolboxLabel;\r\n        result.toolboxDescription = value.toolboxDescription;\r\n        return result;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n    LayoutEditor.Column = function (data, htmlId, htmlClass, htmlStyle, isTemplated, width, offset, collapsible, rule, children) {\r\n        LayoutEditor.Element.call(this, \"Column\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n        LayoutEditor.Container.call(this, [\"Grid\", \"Content\"], children);\r\n\r\n        this.width = width;\r\n        this.offset = offset;\r\n        this.collapsible = collapsible;\r\n\r\n        var _hasPendingChange = false;\r\n        var _origWidth = 0;\r\n        var _origOffset = 0;\r\n\r\n        this.beginChange = function () {\r\n            if (!!_hasPendingChange)\r\n                throw new Error(\"Column already has a pending change.\");\r\n            _hasPendingChange = true;\r\n            _origWidth = this.width;\r\n            _origOffset = this.offset;\r\n        };\r\n\r\n        this.commitChange = function () {\r\n            if (!_hasPendingChange)\r\n                throw new Error(\"Column has no pending change.\");\r\n            _origWidth = 0;\r\n            _origOffset = 0;\r\n            _hasPendingChange = false;\r\n        };\r\n\r\n        this.rollbackChange = function () {\r\n            if (!_hasPendingChange)\r\n                throw new Error(\"Column has no pending change.\");\r\n            this.width = _origWidth;\r\n            this.offset = _origOffset;\r\n            _origWidth = 0;\r\n            _origOffset = 0;\r\n            _hasPendingChange = false;\r\n        };\r\n\r\n        this.canSplit = function () {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.width > 1;\r\n        };\r\n\r\n        this.split = function () {\r\n            if (!this.canSplit())\r\n                return;\r\n\r\n            var newColumnWidth = Math.floor(this.width / 2);\r\n            var newColumn = LayoutEditor.Column.from({\r\n                data: null,\r\n                htmlId: null,\r\n                htmlClass: null,\r\n                htmlStyle: null,\r\n                width: newColumnWidth,\r\n                offset: 0,\r\n                children: []\r\n            });\r\n\r\n            this.width = this.width - newColumnWidth;\r\n            this.parent.insertChild(newColumn, this);\r\n            newColumn.setIsFocused();\r\n        };\r\n\r\n        this.canContractRight = function (connectAdjacent) {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.parent.canContractColumnRight(this, connectAdjacent);\r\n        };\r\n\r\n        this.contractRight = function (connectAdjacent) {\r\n            if (!this.canContractRight(connectAdjacent))\r\n                return;\r\n            this.parent.contractColumnRight(this, connectAdjacent);\r\n        };\r\n\r\n        this.canExpandRight = function (connectAdjacent) {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.parent.canExpandColumnRight(this, connectAdjacent);\r\n        };\r\n\r\n        this.expandRight = function (connectAdjacent) {\r\n            if (!this.canExpandRight(connectAdjacent))\r\n                return;\r\n            this.parent.expandColumnRight(this, connectAdjacent);\r\n        };\r\n\r\n        this.canExpandLeft = function (connectAdjacent) {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.parent.canExpandColumnLeft(this, connectAdjacent);\r\n        };\r\n\r\n        this.expandLeft = function (connectAdjacent) {\r\n            if (!this.canExpandLeft(connectAdjacent))\r\n                return;\r\n            this.parent.expandColumnLeft(this, connectAdjacent);\r\n        };\r\n\r\n        this.canContractLeft = function (connectAdjacent) {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.parent.canContractColumnLeft(this, connectAdjacent);\r\n        };\r\n\r\n        this.contractLeft = function (connectAdjacent) {\r\n            if (!this.canContractLeft(connectAdjacent))\r\n                return;\r\n            this.parent.contractColumnLeft(this, connectAdjacent);\r\n        };\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.width = this.width;\r\n            result.offset = this.offset;\r\n            result.collapsible = this.collapsible;\r\n            result.children = this.childrenToObject();\r\n            return result;\r\n        };\r\n    };\r\n\r\n    LayoutEditor.Column.from = function (value) {\r\n        var result = new LayoutEditor.Column(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.width,\r\n            value.offset,\r\n            value.collapsible,\r\n            value.rule,\r\n            LayoutEditor.childrenFrom(value.children));\r\n        result.toolboxIcon = value.toolboxIcon;\r\n        result.toolboxLabel = value.toolboxLabel;\r\n        result.toolboxDescription = value.toolboxDescription;\r\n        return result;\r\n    };\r\n\r\n    LayoutEditor.Column.times = function (value) {\r\n        return _.times(value, function (n) {\r\n            return LayoutEditor.Column.from({\r\n                data: null,\r\n                htmlId: null,\r\n                htmlClass: null,\r\n                isTemplated: false,\r\n                width: 12 / value,\r\n                offset: 0,\r\n                collapsible: null,\r\n                children: []\r\n            });\r\n        });\r\n    };\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Content = function (data, htmlId, htmlClass, htmlStyle, isTemplated, contentType, contentTypeLabel, contentTypeClass, html, hasEditor, rule) {\r\n        LayoutEditor.Element.call(this, \"Content\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n\r\n        this.contentType = contentType;\r\n        this.contentTypeLabel = contentTypeLabel;\r\n        this.contentTypeClass = contentTypeClass;\r\n        this.html = html;\r\n        this.hasEditor = hasEditor;\r\n\r\n        this.getInnerText = function () {\r\n            return $($.parseHTML(\"<div>\" + this.html + \"</div>\")).text();\r\n        };\r\n\r\n        // This function will be overwritten by the Content directive.\r\n        this.setHtml = function (html) {\r\n            this.html = html;\r\n            this.htmlUnsafe = html;\r\n        }\r\n\r\n        this.toObject = function () {\r\n            return {\r\n                \"type\": \"Content\"\r\n            };\r\n        };\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.contentType = this.contentType;\r\n            result.contentTypeLabel = this.contentTypeLabel;\r\n            result.contentTypeClass = this.contentTypeClass;\r\n            result.html = this.html;\r\n            result.hasEditor = hasEditor;\r\n            return result;\r\n        };\r\n\r\n        this.setHtml(html);\r\n    };\r\n\r\n    LayoutEditor.Content.from = function (value) {\r\n        var result = new LayoutEditor.Content(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.contentType,\r\n            value.contentTypeLabel,\r\n            value.contentTypeClass,\r\n            value.html,\r\n            value.hasEditor,\r\n            value.rule);\r\n\r\n        return result;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function ($, LayoutEditor) {\r\n\r\n    LayoutEditor.Html = function (data, htmlId, htmlClass, htmlStyle, isTemplated, contentType, contentTypeLabel, contentTypeClass, html, hasEditor, rule) {\r\n        LayoutEditor.Element.call(this, \"Html\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n\r\n        this.contentType = contentType;\r\n        this.contentTypeLabel = contentTypeLabel;\r\n        this.contentTypeClass = contentTypeClass;\r\n        this.html = html;\r\n        this.hasEditor = hasEditor;\r\n        this.isContainable = true;\r\n\r\n        this.getInnerText = function () {\r\n            return $($.parseHTML(\"<div>\" + this.html + \"</div>\")).text();\r\n        };\r\n\r\n        // This function will be overwritten by the Content directive.\r\n        this.setHtml = function (html) {\r\n            this.html = html;\r\n            this.htmlUnsafe = html;\r\n        }\r\n\r\n        this.toObject = function () {\r\n            return {\r\n                \"type\": \"Html\"\r\n            };\r\n        };\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.contentType = this.contentType;\r\n            result.contentTypeLabel = this.contentTypeLabel;\r\n            result.contentTypeClass = this.contentTypeClass;\r\n            result.html = this.html;\r\n            result.hasEditor = hasEditor;\r\n            return result;\r\n        };\r\n\r\n        var getEditorObject = this.getEditorObject;\r\n        this.getEditorObject = function () {\r\n            var dto = getEditorObject();\r\n            return $.extend(dto, {\r\n                Content: this.html\r\n            });\r\n        }\r\n\r\n        this.setHtml(html);\r\n    };\r\n\r\n    LayoutEditor.Html.from = function (value) {\r\n        var result = new LayoutEditor.Html(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.contentType,\r\n            value.contentTypeLabel,\r\n            value.contentTypeClass,\r\n            value.html,\r\n            value.hasEditor,\r\n            value.rule);\r\n\r\n        return result;\r\n    };\r\n\r\n    LayoutEditor.registerFactory(\"Html\", function(value) { return LayoutEditor.Html.from(value); });\r\n\r\n})(jQuery, LayoutEditor || (LayoutEditor = {}));"],"sourceRoot":"/source/"} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Models.js","Helpers.js","Editor.js","RecycleBin.js","Element.js","Container.js","Canvas.js","Grid.js","Row.js","Column.js","Content.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA,ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC/MA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC3JA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACl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file":"Models.js","sourcesContent":[null,"var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    Array.prototype.move = function (from, to) {\r\n        this.splice(to, 0, this.splice(from, 1)[0]);\r\n    };\r\n\r\n    LayoutEditor.childrenFrom = function(values) {\r\n        return _(values).map(function(value) {\r\n            return LayoutEditor.elementFrom(value);\r\n        });\r\n    };\r\n\r\n    var registerFactory = LayoutEditor.registerFactory = function(type, factory) {\r\n        var factories = LayoutEditor.factories = LayoutEditor.factories || {};\r\n        factories[type] = factory;\r\n    };\r\n\r\n    registerFactory(\"Canvas\", function (value) { return LayoutEditor.Canvas.from(value); });\r\n    registerFactory(\"Grid\", function(value) { return LayoutEditor.Grid.from(value); });\r\n    registerFactory(\"Row\", function(value) { return LayoutEditor.Row.from(value); });\r\n    registerFactory(\"Column\", function(value) { return LayoutEditor.Column.from(value); });\r\n    registerFactory(\"Content\", function(value) { return LayoutEditor.Content.from(value); });\r\n\r\n    LayoutEditor.elementFrom = function (value) {\r\n        var factory = LayoutEditor.factories[value.type];\r\n\r\n        if (!factory)\r\n            throw new Error(\"No element with type \\\"\" + value.type + \"\\\" was found.\");\r\n\r\n        var element = factory(value);\r\n        return element;\r\n    };\r\n\r\n    LayoutEditor.setModel = function (elementSelector, model) {\r\n        $(elementSelector).scope().element = model;\r\n    };\r\n\r\n    LayoutEditor.getModel = function (elementSelector) {\r\n        return $(elementSelector).scope().element;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Editor = function (config, canvasData) {\r\n        this.config = config;\r\n        this.canvas = LayoutEditor.Canvas.from(canvasData);\r\n        this.initialState = JSON.stringify(this.canvas.toObject());\r\n        this.activeElement = null;\r\n        this.focusedElement = null;\r\n        this.dropTargetElement = null;\r\n        this.isDragging = false;\r\n        this.isResizing = false;\r\n        this.recycleBin = new LayoutEditor.RecycleBin();\r\n\r\n        this.resetToolboxElements = function () {\r\n            this.toolboxElements = [\r\n                LayoutEditor.Row.from({\r\n                    children: []\r\n                })\r\n            ];\r\n        };\r\n\r\n        this.isDirty = function() {\r\n            var currentState = JSON.stringify(this.canvas.toObject());\r\n            return this.initialState != currentState;\r\n        };\r\n\r\n        this.resetToolboxElements();\r\n        this.canvas.setEditor(this);\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));\r\n","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.RecycleBin = function () {\r\n        this.elements = [];\r\n\r\n        this.add = function(element) {\r\n            this.elements.push(element);\r\n        };\r\n\r\n        this.toObject = function () {\r\n            var result = {\r\n                type: \"RecycleBin\",\r\n                children: []\r\n            };\r\n\r\n            for (var i = 0; i < this.elements.length; i++) {\r\n                var element = this.elements[i];\r\n                var dto = element.toObject();\r\n                result.children.push(dto);\r\n            }\r\n\r\n            return result;\r\n        };\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));\r\n","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Element = function (type, data, htmlId, htmlClass, htmlStyle, isTemplated, rule) {\r\n        if (!type)\r\n            throw new Error(\"Parameter 'type' is required.\");\r\n\r\n        this.type = type;\r\n        this.data = data;\r\n        this.htmlId = htmlId;\r\n        this.htmlClass = htmlClass;\r\n        this.htmlStyle = htmlStyle;\r\n        this.isTemplated = isTemplated;\r\n        this.rule = rule;\r\n\r\n        this.templateStyles = {};\r\n        this.editor = null;\r\n        this.parent = null;\r\n        this.setIsFocusedEventHandlers = [];\r\n\r\n        this.setEditor = function (editor) {\r\n            this.editor = editor;\r\n            if (!!this.children && _.isArray(this.children)) {\r\n                _(this.children).each(function (child) {\r\n                    child.setEditor(editor);\r\n                });\r\n            }\r\n        };\r\n\r\n        this.setParent = function(parentElement) {\r\n            this.parent = parentElement;\r\n            this.parent.onChildAdded(this);\r\n\r\n            var currentAncestor = parentElement;\r\n            while (!!currentAncestor) {\r\n                currentAncestor.onDescendantAdded(this, parentElement);\r\n                currentAncestor = currentAncestor.parent;\r\n            }\r\n        };\r\n\r\n        this.setIsTemplated = function (value) {\r\n            this.isTemplated = value;\r\n            if (!!this.children && _.isArray(this.children)) {\r\n                _(this.children).each(function (child) {\r\n                    child.setIsTemplated(value);\r\n                });\r\n            }\r\n        };\r\n\r\n        this.applyElementEditorModel = function() { /* Virtual */ };\r\n\r\n        this.getIsActive = function () {\r\n            if (!this.editor)\r\n                return false;\r\n            return this.editor.activeElement === this && !this.getIsFocused();\r\n        };\r\n\r\n        this.setIsActive = function (value) {\r\n            if (!this.editor)\r\n                return;\r\n            if (this.editor.isDragging || this.editor.isResizing)\r\n                return;\r\n\r\n            if (value)\r\n                this.editor.activeElement = this;\r\n            else\r\n                this.editor.activeElement = this.parent;\r\n        };\r\n\r\n        this.getIsFocused = function () {\r\n            if (!this.editor)\r\n                return false;\r\n            return this.editor.focusedElement === this;\r\n        };\r\n\r\n        this.setIsFocused = function () {\r\n            if (!this.editor)\r\n            \treturn;\r\n            if (!this.children && this.isTemplated)\r\n            \treturn;\r\n            if (this.editor.isDragging || this.editor.isResizing)\r\n                return;\r\n\r\n            this.editor.focusedElement = this;\r\n            _(this.setIsFocusedEventHandlers).each(function (item) {\r\n                try {\r\n                    item();\r\n                }\r\n                catch (ex) {\r\n                    // Ignore.\r\n                }\r\n            });\r\n        };\r\n\r\n        this.getIsSelected = function () {\r\n            if (this.getIsFocused())\r\n                return true;\r\n\r\n            if (!!this.children && _.isArray(this.children)) {\r\n                return _(this.children).any(function(child) {\r\n                    return child.getIsSelected();\r\n                });\r\n            }\r\n\r\n            return false;\r\n        };\r\n\r\n        this.getIsDropTarget = function () {\r\n            if (!this.editor)\r\n                return false;\r\n            return this.editor.dropTargetElement === this;\r\n        }\r\n\r\n        this.setIsDropTarget = function (value) {\r\n            if (!this.editor)\r\n                return;\r\n            if (value)\r\n                this.editor.dropTargetElement = this;\r\n            else\r\n                this.editor.dropTargetElement = null;\r\n        };\r\n\r\n        this.canDelete = function () {\r\n            if (this.isTemplated || !this.parent)\r\n                return false;\r\n            return true;\r\n        };\r\n\r\n        this.delete = function () {\r\n            if (!this.canDelete())\r\n                return;\r\n            this.parent.deleteChild(this);\r\n        };\r\n\r\n        this.canMoveUp = function () {\r\n            if (this.isTemplated || !this.parent)\r\n                return false;\r\n            return this.parent.canMoveChildUp(this);\r\n        };\r\n\r\n        this.moveUp = function () {\r\n            if (!this.canMoveUp())\r\n                return;\r\n            this.parent.moveChildUp(this);\r\n        };\r\n\r\n        this.canMoveDown = function () {\r\n            if (this.isTemplated || !this.parent)\r\n                return false;\r\n            return this.parent.canMoveChildDown(this);\r\n        };\r\n\r\n        this.moveDown = function () {\r\n            if (!this.canMoveDown())\r\n                return;\r\n            this.parent.moveChildDown(this);\r\n        };\r\n\r\n        this.elementToObject = function () {\r\n            return {\r\n                type: this.type,\r\n                data: this.data,\r\n                htmlId: this.htmlId,\r\n                htmlClass: this.htmlClass,\r\n                htmlStyle: this.htmlStyle,\r\n                isTemplated: this.isTemplated,\r\n                rule: this.rule\r\n            };\r\n        };\r\n\r\n        this.getEditorObject = function() {\r\n            return {};\r\n        };\r\n\r\n        this.copy = function (clipboardData) {\r\n            var text = this.getInnerText();\r\n            clipboardData.setData(\"text/plain\", text);\r\n\r\n            var data = this.toObject();\r\n            var json = JSON.stringify(data, null, \"\\t\");\r\n            clipboardData.setData(\"text/json\", json);\r\n        };\r\n\r\n        this.cut = function (clipboardData) {\r\n            if (this.canDelete()) {\r\n                this.copy(clipboardData);\r\n                this.delete();\r\n            }\r\n        };\r\n\r\n        this.paste = function (clipboardData) {\r\n            if (!!this.parent)\r\n                this.parent.paste(clipboardData);\r\n        };\r\n\r\n        this.getTemplateStyles = function () {\r\n            var styles = this.templateStyles || {};\r\n            var css = \"\";\r\n\r\n            for (var property in styles) {\r\n                css += property + \":\" + styles[property] + \";\";\r\n            }\r\n\r\n            return css;\r\n        }\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Container = function (allowedChildTypes, children) {\r\n\r\n        this.allowedChildTypes = allowedChildTypes;\r\n        this.children = children;\r\n        this.isContainer = true;\r\n        this.containerTemplateStyles = {};\r\n\r\n        var self = this;\r\n\r\n        this.onChildAdded = function (element) { /* Virtual */ };\r\n        this.onDescendantAdded = function (element, parentElement) { /* Virtual */ };\r\n\r\n        this.setChildren = function (children) {\r\n            this.children = children;\r\n            _(this.children).each(function (child) {\r\n                child.setParent(self);\r\n            });\r\n        };\r\n\r\n        this.setChildren(children);\r\n\r\n        this.getIsSealed = function () {\r\n            return _(this.children).any(function (child) {\r\n                return child.isTemplated;\r\n            });\r\n        };\r\n\r\n        var _baseSetIsFocused = this.setIsFocused;\r\n        this.setIsFocused = function () {\r\n            if (this.getIsSealed())\r\n                return;\r\n            _baseSetIsFocused.call(this);\r\n        };\r\n\r\n        this.addChild = function (child) {\r\n            if (!_(this.children).contains(child) && (_(this.allowedChildTypes).contains(child.type) || child.isContainable))\r\n                this.children.push(child);\r\n            child.setEditor(this.editor);\r\n            child.setIsTemplated(false);\r\n            child.setParent(this);\r\n        };\r\n\r\n        this.deleteChild = function (child) {\r\n            var index = _(this.children).indexOf(child);\r\n            if (index >= 0) {\r\n                this.children.splice(index, 1);\r\n                this.editor.recycleBin.add(child);\r\n                if (child.getIsActive())\r\n                    this.editor.activeElement = null;\r\n                if (child.getIsFocused()) {\r\n                    // If the deleted child was focused, try to set new focus to the most appropriate sibling or parent.\r\n                    if (this.children.length > index)\r\n                        this.children[index].setIsFocused();\r\n                    else if (index > 0)\r\n                        this.children[index - 1].setIsFocused();\r\n                    else\r\n                        this.setIsFocused();\r\n                }\r\n            }\r\n        };\r\n\r\n        this.moveFocusPrevChild = function (child) {\r\n            if (this.children.length < 2)\r\n                return;\r\n            var index = _(this.children).indexOf(child);\r\n            if (index > 0)\r\n                this.children[index - 1].setIsFocused();\r\n        };\r\n\r\n        this.moveFocusNextChild = function (child) {\r\n            if (this.children.length < 2)\r\n                return;\r\n            var index = _(this.children).indexOf(child);\r\n            if (index < this.children.length - 1)\r\n                this.children[index + 1].setIsFocused();\r\n        };\r\n\r\n        this.insertChild = function (child, afterChild) {\r\n            if (!_(this.children).contains(child)) {\r\n                var index = Math.max(_(this.children).indexOf(afterChild), 0);\r\n                this.children.splice(index + 1, 0, child);\r\n                child.setEditor(this.editor);\r\n                child.parent = this;\r\n            }\r\n        };\r\n\r\n        this.moveChildUp = function (child) {\r\n            if (!this.canMoveChildUp(child))\r\n                return;\r\n            var index = _(this.children).indexOf(child);\r\n            this.children.move(index, index - 1);\r\n        };\r\n\r\n        this.moveChildDown = function (child) {\r\n            if (!this.canMoveChildDown(child))\r\n                return;\r\n            var index = _(this.children).indexOf(child);\r\n            this.children.move(index, index + 1);\r\n        };\r\n\r\n        this.canMoveChildUp = function (child) {\r\n            var index = _(this.children).indexOf(child);\r\n            return index > 0;\r\n        };\r\n\r\n        this.canMoveChildDown = function (child) {\r\n            var index = _(this.children).indexOf(child);\r\n            return index < this.children.length - 1;\r\n        };\r\n\r\n        this.childrenToObject = function () {\r\n            return _(this.children).map(function (child) {\r\n                return child.toObject();\r\n            });\r\n        };\r\n\r\n        this.getInnerText = function () {\r\n            return _(this.children).reduce(function (memo, child) {\r\n                return memo + \"\\n\" + child.getInnerText();\r\n            }, \"\");\r\n        }\r\n\r\n        this.paste = function (clipboardData) {\r\n            var json = clipboardData.getData(\"text/json\");\r\n            if (!!json) {\r\n                var data = JSON.parse(json);\r\n                var child = LayoutEditor.elementFrom(data);\r\n                this.pasteChild(child);\r\n            }\r\n        };\r\n\r\n        this.pasteChild = function (child) {\r\n            if (_(this.allowedChildTypes).contains(child.type) || child.isContainable) {\r\n                this.addChild(child);\r\n                child.setIsFocused();\r\n            }\r\n            else if (!!this.parent)\r\n                this.parent.pasteChild(child);\r\n        }\r\n\r\n        this.getContainerTemplateStyles = function () {\r\n            var styles = this.containerTemplateStyles || {};\r\n            var css = \"\";\r\n\r\n            for (var property in styles) {\r\n                css += property + \":\" + styles[property] + \";\";\r\n            }\r\n\r\n            return css;\r\n        }\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Canvas = function (data, htmlId, htmlClass, htmlStyle, isTemplated, rule, children) {\r\n        LayoutEditor.Element.call(this, \"Canvas\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n        LayoutEditor.Container.call(this, [\"Canvas\", \"Grid\", \"Content\"], children);\r\n\r\n        this.isContainable = true;\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.children = this.childrenToObject();\r\n            return result;\r\n        };\r\n    };\r\n\r\n    LayoutEditor.Canvas.from = function (value) {\r\n        var result = new LayoutEditor.Canvas(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.rule,\r\n            LayoutEditor.childrenFrom(value.children));\r\n\r\n        result.toolboxIcon = value.toolboxIcon;\r\n        result.toolboxLabel = value.toolboxLabel;\r\n        result.toolboxDescription = value.toolboxDescription;\r\n\r\n        return result;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));\r\n","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Grid = function (data, htmlId, htmlClass, htmlStyle, isTemplated, rule, children) {\r\n        LayoutEditor.Element.call(this, \"Grid\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n        LayoutEditor.Container.call(this, [\"Row\"], children);\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.children = this.childrenToObject();\r\n            return result;\r\n        };\r\n    };\r\n\r\n    LayoutEditor.Grid.from = function (value) {\r\n        var result = new LayoutEditor.Grid(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.rule,\r\n            LayoutEditor.childrenFrom(value.children));\r\n        result.toolboxIcon = value.toolboxIcon;\r\n        result.toolboxLabel = value.toolboxLabel;\r\n        result.toolboxDescription = value.toolboxDescription;\r\n        return result;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Row = function (data, htmlId, htmlClass, htmlStyle, isTemplated, rule, children) {\r\n        LayoutEditor.Element.call(this, \"Row\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n        LayoutEditor.Container.call(this, [\"Column\"], children);\r\n\r\n        var _self = this;\r\n\r\n        function _getTotalColumnsWidth() {\r\n            return _(_self.children).reduce(function (memo, child) {\r\n                return memo + child.offset + child.width;\r\n            }, 0);\r\n        }\r\n\r\n        // Implements a simple algorithm to distribute space (either positive or negative)\r\n        // between the child columns of the row. Negative space is distributed when making\r\n        // room for a new column (e.c. clipboard paste or dropping from the toolbox) while\r\n        // positive space is distributed when filling the grap of a removed column.\r\n        function _distributeSpace(space) {\r\n            if (space == 0)\r\n                return true;\r\n             \r\n            var undistributedSpace = space;\r\n\r\n            if (undistributedSpace < 0) {\r\n                var vacantSpace = 12 - _getTotalColumnsWidth();\r\n                undistributedSpace += vacantSpace;\r\n                if (undistributedSpace > 0)\r\n                    undistributedSpace = 0;\r\n            }\r\n\r\n            // If space is negative, try to decrease offsets first.\r\n            while (undistributedSpace < 0 && _(_self.children).any(function (column) { return column.offset > 0; })) { // While there is still offset left to remove.\r\n                for (i = 0; i < _self.children.length && undistributedSpace < 0; i++) {\r\n                    var column = _self.children[i];\r\n                    if (column.offset > 0) {\r\n                        column.offset--;\r\n                        undistributedSpace++;\r\n                    }\r\n                }\r\n            }\r\n\r\n            function hasWidth(column) {\r\n                if (undistributedSpace > 0)\r\n                    return column.width < 12;\r\n                else if (undistributedSpace < 0)\r\n                    return column.width > 1;\r\n                return false;\r\n            }\r\n\r\n            // Try to distribute remaining space (could be negative or positive) using widths.\r\n            while (undistributedSpace != 0) {\r\n                // Any more column width available for distribution?\r\n                if (!_(_self.children).any(hasWidth))\r\n                    break;\r\n                for (i = 0; i < _self.children.length && undistributedSpace != 0; i++) {\r\n                    var column = _self.children[i % _self.children.length];\r\n                    if (hasWidth(column)) {\r\n                        var delta = undistributedSpace / Math.abs(undistributedSpace);\r\n                        column.width += delta;\r\n                        undistributedSpace -= delta;\r\n                    }\r\n                }                \r\n            }\r\n\r\n            return undistributedSpace == 0;\r\n        }\r\n\r\n        var _isAddingColumn = false;\r\n\r\n        this.canAddColumn = function () {\r\n            return this.children.length < 12;\r\n        };\r\n\r\n        this.beginAddColumn = function (newColumnWidth) {\r\n            if (!!_isAddingColumn)\r\n                throw new Error(\"Column add operation is already in progress.\")\r\n            _(this.children).each(function (column) {\r\n                column.beginChange();\r\n            });\r\n            if (_distributeSpace(-newColumnWidth)) {\r\n                _isAddingColumn = true;\r\n                return true;\r\n            }\r\n            _(this.children).each(function (column) {\r\n                column.rollbackChange();\r\n            });\r\n            return false;\r\n        };\r\n\r\n        this.commitAddColumn = function () {\r\n            if (!_isAddingColumn)\r\n                throw new Error(\"No column add operation in progress.\")\r\n            _(this.children).each(function (column) {\r\n                column.commitChange();\r\n            });\r\n            _isAddingColumn = false;\r\n        };\r\n\r\n        this.rollbackAddColumn = function () {\r\n            if (!_isAddingColumn)\r\n                throw new Error(\"No column add operation in progress.\")\r\n            _(this.children).each(function (column) {\r\n                column.rollbackChange();\r\n            });\r\n            _isAddingColumn = false;\r\n        };\r\n\r\n        var _baseDeleteChild = this.deleteChild;\r\n        this.deleteChild = function (column) { \r\n            var width = column.width;\r\n            _baseDeleteChild.call(this, column);\r\n            _distributeSpace(width);\r\n        };\r\n\r\n        this.canContractColumnRight = function (column, connectAdjacent) {\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0)\r\n                return column.width > 1;\r\n            return false;\r\n        };\r\n\r\n        this.contractColumnRight = function (column, connectAdjacent) {\r\n            if (!this.canContractColumnRight(column, connectAdjacent))\r\n                return;\r\n\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (column.width > 1) {\r\n                    column.width--;\r\n                    if (this.children.length > index + 1) {\r\n                        var nextColumn = this.children[index + 1];\r\n                        if (connectAdjacent && nextColumn.offset == 0)\r\n                            nextColumn.width++;\r\n                        else\r\n                            nextColumn.offset++;\r\n                    }\r\n                }\r\n            }\r\n        };\r\n\r\n        this.canExpandColumnRight = function (column, connectAdjacent) {\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (column.width >= 12)\r\n                    return false;\r\n                if (this.children.length > index + 1) {\r\n                    var nextColumn = this.children[index + 1];\r\n                    if (connectAdjacent && nextColumn.offset == 0)\r\n                        return nextColumn.width > 1;\r\n                    else\r\n                        return nextColumn.offset > 0;\r\n                }\r\n                return _getTotalColumnsWidth() < 12;\r\n            }\r\n            return false;\r\n        };\r\n\r\n        this.expandColumnRight = function (column, connectAdjacent) {\r\n            if (!this.canExpandColumnRight(column, connectAdjacent))\r\n                return;\r\n\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (this.children.length > index + 1) {\r\n                    var nextColumn = this.children[index + 1];\r\n                    if (connectAdjacent && nextColumn.offset == 0)\r\n                        nextColumn.width--;\r\n                    else\r\n                        nextColumn.offset--;\r\n                }\r\n                column.width++;\r\n            }\r\n        };\r\n\r\n        this.canExpandColumnLeft = function (column, connectAdjacent) {\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (column.width >= 12)\r\n                    return false;\r\n                if (index > 0) {\r\n                    var prevColumn = this.children[index - 1];\r\n                    if (connectAdjacent && column.offset == 0)\r\n                        return prevColumn.width > 1;\r\n                }\r\n                return column.offset > 0;\r\n            }\r\n            return false;\r\n        };\r\n\r\n        this.expandColumnLeft = function (column, connectAdjacent) {\r\n            if (!this.canExpandColumnLeft(column, connectAdjacent))\r\n                return;\r\n\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (index > 0) {\r\n                    var prevColumn = this.children[index - 1];\r\n                    if (connectAdjacent && column.offset == 0)\r\n                        prevColumn.width--;\r\n                    else\r\n                        column.offset--;\r\n                }\r\n                else\r\n                    column.offset--;\r\n                column.width++;\r\n            }\r\n        };\r\n\r\n        this.canContractColumnLeft = function (column, connectAdjacent) {\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0)\r\n                return column.width > 1;\r\n            return false;\r\n        };\r\n\r\n        this.contractColumnLeft = function (column, connectAdjacent) {\r\n            if (!this.canContractColumnLeft(column, connectAdjacent))\r\n                return;\r\n\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (index > 0) {\r\n                    var prevColumn = this.children[index - 1];\r\n                    if (connectAdjacent && column.offset == 0)\r\n                        prevColumn.width++;\r\n                    else\r\n                        column.offset++;\r\n                }\r\n                else\r\n                    column.offset++;\r\n                column.width--;\r\n            }\r\n        };\r\n\r\n        this.evenColumns = function () {\r\n            if (this.children.length == 0)\r\n                return;\r\n\r\n            var evenWidth = Math.floor(12 / this.children.length);\r\n            _(this.children).each(function (column) {\r\n                column.width = evenWidth;\r\n                column.offset = 0;\r\n            });\r\n\r\n            var rest = 12 % this.children.length;\r\n            if (rest > 0)\r\n                _distributeSpace(rest);\r\n        };\r\n\r\n        var _basePasteChild = this.pasteChild;\r\n        this.pasteChild = function (child) {\r\n            if (child.type == \"Column\") {\r\n                if (this.beginAddColumn(child.width)) {\r\n                    this.commitAddColumn();\r\n                    _basePasteChild.call(this, child)\r\n                }\r\n            }\r\n            else if (!!this.parent)\r\n                this.parent.pasteChild(child);\r\n        }\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.children = this.childrenToObject();\r\n            return result;\r\n        };\r\n    };\r\n\r\n    LayoutEditor.Row.from = function (value) {\r\n        var result = new LayoutEditor.Row(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.rule,\r\n            LayoutEditor.childrenFrom(value.children));\r\n        result.toolboxIcon = value.toolboxIcon;\r\n        result.toolboxLabel = value.toolboxLabel;\r\n        result.toolboxDescription = value.toolboxDescription;\r\n        return result;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n    LayoutEditor.Column = function (data, htmlId, htmlClass, htmlStyle, isTemplated, width, offset, collapsible, rule, children) {\r\n        LayoutEditor.Element.call(this, \"Column\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n        LayoutEditor.Container.call(this, [\"Grid\", \"Content\"], children);\r\n\r\n        this.width = width;\r\n        this.offset = offset;\r\n        this.collapsible = collapsible;\r\n\r\n        var _hasPendingChange = false;\r\n        var _origWidth = 0;\r\n        var _origOffset = 0;\r\n\r\n        this.beginChange = function () {\r\n            if (!!_hasPendingChange)\r\n                throw new Error(\"Column already has a pending change.\");\r\n            _hasPendingChange = true;\r\n            _origWidth = this.width;\r\n            _origOffset = this.offset;\r\n        };\r\n\r\n        this.commitChange = function () {\r\n            if (!_hasPendingChange)\r\n                throw new Error(\"Column has no pending change.\");\r\n            _origWidth = 0;\r\n            _origOffset = 0;\r\n            _hasPendingChange = false;\r\n        };\r\n\r\n        this.rollbackChange = function () {\r\n            if (!_hasPendingChange)\r\n                throw new Error(\"Column has no pending change.\");\r\n            this.width = _origWidth;\r\n            this.offset = _origOffset;\r\n            _origWidth = 0;\r\n            _origOffset = 0;\r\n            _hasPendingChange = false;\r\n        };\r\n\r\n        this.canSplit = function () {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.width > 1;\r\n        };\r\n\r\n        this.split = function () {\r\n            if (!this.canSplit())\r\n                return;\r\n\r\n            var newColumnWidth = Math.floor(this.width / 2);\r\n            var newColumn = LayoutEditor.Column.from({\r\n                data: null,\r\n                htmlId: null,\r\n                htmlClass: null,\r\n                htmlStyle: null,\r\n                width: newColumnWidth,\r\n                offset: 0,\r\n                children: []\r\n            });\r\n\r\n            this.width = this.width - newColumnWidth;\r\n            this.parent.insertChild(newColumn, this);\r\n            newColumn.setIsFocused();\r\n        };\r\n\r\n        this.canContractRight = function (connectAdjacent) {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.parent.canContractColumnRight(this, connectAdjacent);\r\n        };\r\n\r\n        this.contractRight = function (connectAdjacent) {\r\n            if (!this.canContractRight(connectAdjacent))\r\n                return;\r\n            this.parent.contractColumnRight(this, connectAdjacent);\r\n        };\r\n\r\n        this.canExpandRight = function (connectAdjacent) {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.parent.canExpandColumnRight(this, connectAdjacent);\r\n        };\r\n\r\n        this.expandRight = function (connectAdjacent) {\r\n            if (!this.canExpandRight(connectAdjacent))\r\n                return;\r\n            this.parent.expandColumnRight(this, connectAdjacent);\r\n        };\r\n\r\n        this.canExpandLeft = function (connectAdjacent) {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.parent.canExpandColumnLeft(this, connectAdjacent);\r\n        };\r\n\r\n        this.expandLeft = function (connectAdjacent) {\r\n            if (!this.canExpandLeft(connectAdjacent))\r\n                return;\r\n            this.parent.expandColumnLeft(this, connectAdjacent);\r\n        };\r\n\r\n        this.canContractLeft = function (connectAdjacent) {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.parent.canContractColumnLeft(this, connectAdjacent);\r\n        };\r\n\r\n        this.contractLeft = function (connectAdjacent) {\r\n            if (!this.canContractLeft(connectAdjacent))\r\n                return;\r\n            this.parent.contractColumnLeft(this, connectAdjacent);\r\n        };\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.width = this.width;\r\n            result.offset = this.offset;\r\n            result.collapsible = this.collapsible;\r\n            result.children = this.childrenToObject();\r\n            return result;\r\n        };\r\n    };\r\n\r\n    LayoutEditor.Column.from = function (value) {\r\n        var result = new LayoutEditor.Column(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.width,\r\n            value.offset,\r\n            value.collapsible,\r\n            value.rule,\r\n            LayoutEditor.childrenFrom(value.children));\r\n        result.toolboxIcon = value.toolboxIcon;\r\n        result.toolboxLabel = value.toolboxLabel;\r\n        result.toolboxDescription = value.toolboxDescription;\r\n        return result;\r\n    };\r\n\r\n    LayoutEditor.Column.times = function (value) {\r\n        return _.times(value, function (n) {\r\n            return LayoutEditor.Column.from({\r\n                data: null,\r\n                htmlId: null,\r\n                htmlClass: null,\r\n                isTemplated: false,\r\n                width: 12 / value,\r\n                offset: 0,\r\n                collapsible: null,\r\n                children: []\r\n            });\r\n        });\r\n    };\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Content = function (data, htmlId, htmlClass, htmlStyle, isTemplated, contentType, contentTypeLabel, contentTypeClass, html, hasEditor, rule) {\r\n        LayoutEditor.Element.call(this, \"Content\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n\r\n        this.contentType = contentType;\r\n        this.contentTypeLabel = contentTypeLabel;\r\n        this.contentTypeClass = contentTypeClass;\r\n        this.html = html;\r\n        this.hasEditor = hasEditor;\r\n\r\n        this.getInnerText = function () {\r\n            return $($.parseHTML(\"<div>\" + this.html + \"</div>\")).text();\r\n        };\r\n\r\n        // This function will be overwritten by the Content directive.\r\n        this.setHtml = function (html) {\r\n            this.html = html;\r\n            this.htmlUnsafe = html;\r\n        }\r\n\r\n        this.toObject = function () {\r\n            return {\r\n                \"type\": \"Content\"\r\n            };\r\n        };\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.contentType = this.contentType;\r\n            result.contentTypeLabel = this.contentTypeLabel;\r\n            result.contentTypeClass = this.contentTypeClass;\r\n            result.html = this.html;\r\n            result.hasEditor = hasEditor;\r\n            return result;\r\n        };\r\n\r\n        this.setHtml(html);\r\n    };\r\n\r\n    LayoutEditor.Content.from = function (value) {\r\n        var result = new LayoutEditor.Content(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.contentType,\r\n            value.contentTypeLabel,\r\n            value.contentTypeClass,\r\n            value.html,\r\n            value.hasEditor,\r\n            value.rule);\r\n\r\n        return result;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));"],"sourceRoot":"/source/"} diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.min.js b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.min.js index 0a4e26bbb..70a52d0b1 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.min.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.min.js @@ -1 +1 @@ -var LayoutEditor;!function(t){Array.prototype.move=function(t,i){this.splice(i,0,this.splice(t,1)[0])},t.childrenFrom=function(i){return _(i).map(function(i){return t.elementFrom(i)})};var i=t.registerFactory=function(i,n){var e=t.factories=t.factories||{};e[i]=n};i("Canvas",function(i){return t.Canvas.from(i)}),i("Grid",function(i){return t.Grid.from(i)}),i("Row",function(i){return t.Row.from(i)}),i("Column",function(i){return t.Column.from(i)}),i("Content",function(i){return t.Content.from(i)}),t.elementFrom=function(i){var n=t.factories[i.type];if(!n)throw new Error('No element with type "'+i.type+'" was found.');var e=n(i);return e},t.setModel=function(t,i){$(t).scope().element=i},t.getModel=function(t){return $(t).scope().element}}(LayoutEditor||(LayoutEditor={}));var LayoutEditor;!function(t){t.Editor=function(i,n){this.config=i,this.canvas=t.Canvas.from(n),this.initialState=JSON.stringify(this.canvas.toObject()),this.activeElement=null,this.focusedElement=null,this.dropTargetElement=null,this.isDragging=!1,this.isResizing=!1,this.recycleBin=new t.RecycleBin,this.resetToolboxElements=function(){this.toolboxElements=[t.Row.from({children:[]})]},this.isDirty=function(){var t=JSON.stringify(this.canvas.toObject());return this.initialState!=t},this.resetToolboxElements(),this.canvas.setEditor(this)}}(LayoutEditor||(LayoutEditor={}));var LayoutEditor;!function(t){t.RecycleBin=function(){this.elements=[],this.add=function(t){this.elements.push(t)},this.toObject=function(){for(var t={type:"RecycleBin",children:[]},i=0;i=0&&(this.children.splice(i,1),this.editor.recycleBin.add(t),t.getIsActive()&&(this.editor.activeElement=null),t.getIsFocused()&&(this.children.length>i?this.children[i].setIsFocused():i>0?this.children[i-1].setIsFocused():this.setIsFocused()))},this.moveFocusPrevChild=function(t){if(!(this.children.length<2)){var i=_(this.children).indexOf(t);i>0&&this.children[i-1].setIsFocused()}},this.moveFocusNextChild=function(t){if(!(this.children.length<2)){var i=_(this.children).indexOf(t);i0},this.canMoveChildDown=function(t){var i=_(this.children).indexOf(t);return i0?t.width<12:0>e?t.width>1:!1}if(0==t)return!0;var e=t;if(0>e){var o=12-c();e+=o,e>0&&(e=0)}for(;0>e&&_(d.children).any(function(t){return t.offset>0});)for(i=0;ie;i++){var s=d.children[i];s.offset>0&&(s.offset--,e++)}for(;0!=e&&_(d.children).any(n);)for(i=0;i=0?t.width>1:!1},this.contractColumnRight=function(t,i){if(this.canContractColumnRight(t,i)){var n=_(this.children).indexOf(t);if(n>=0&&t.width>1&&(t.width--,this.children.length>n+1)){var e=this.children[n+1];i&&0==e.offset?e.width++:e.offset++}}},this.canExpandColumnRight=function(t,i){var n=_(this.children).indexOf(t);if(n>=0){if(t.width>=12)return!1;if(this.children.length>n+1){var e=this.children[n+1];return i&&0==e.offset?e.width>1:e.offset>0}return c()<12}return!1},this.expandColumnRight=function(t,i){if(this.canExpandColumnRight(t,i)){var n=_(this.children).indexOf(t);if(n>=0){if(this.children.length>n+1){var e=this.children[n+1];i&&0==e.offset?e.width--:e.offset--}t.width++}}},this.canExpandColumnLeft=function(t,i){var n=_(this.children).indexOf(t);if(n>=0){if(t.width>=12)return!1;if(n>0){var e=this.children[n-1];if(i&&0==t.offset)return e.width>1}return t.offset>0}return!1},this.expandColumnLeft=function(t,i){if(this.canExpandColumnLeft(t,i)){var n=_(this.children).indexOf(t);if(n>=0){if(n>0){var e=this.children[n-1];i&&0==t.offset?e.width--:t.offset--}else t.offset--;t.width++}}},this.canContractColumnLeft=function(t,i){var n=_(this.children).indexOf(t);return n>=0?t.width>1:!1},this.contractColumnLeft=function(t,i){if(this.canContractColumnLeft(t,i)){var n=_(this.children).indexOf(t);if(n>=0){if(n>0){var e=this.children[n-1];i&&0==t.offset?e.width++:t.offset++}else t.offset++;t.width--}}},this.evenColumns=function(){if(0!=this.children.length){var t=Math.floor(12/this.children.length);_(this.children).each(function(i){i.width=t,i.offset=0});var i=12%this.children.length;i>0&&a(i)}};var m=this.pasteChild;this.pasteChild=function(t){"Column"==t.type?this.beginAddColumn(t.width)&&(this.commitAddColumn(),m.call(this,t)):this.parent&&this.parent.pasteChild(t)},this.toObject=function(){var t=this.elementToObject();return t.children=this.childrenToObject(),t}},t.Row.from=function(i){var n=new t.Row(i.data,i.htmlId,i.htmlClass,i.htmlStyle,i.isTemplated,i.rule,t.childrenFrom(i.children));return n.toolboxIcon=i.toolboxIcon,n.toolboxLabel=i.toolboxLabel,n.toolboxDescription=i.toolboxDescription,n}}(LayoutEditor||(LayoutEditor={}));var LayoutEditor;!function(t){t.Column=function(i,n,e,o,s,h,r,l,c,a){t.Element.call(this,"Column",i,n,e,o,s,c),t.Container.call(this,["Grid","Content"],a),this.width=h,this.offset=r,this.collapsible=l;var d=!1,u=0,f=0;this.beginChange=function(){if(d)throw new Error("Column already has a pending change.");d=!0,u=this.width,f=this.offset},this.commitChange=function(){if(!d)throw new Error("Column has no pending change.");u=0,f=0,d=!1},this.rollbackChange=function(){if(!d)throw new Error("Column has no pending change.");this.width=u,this.offset=f,u=0,f=0,d=!1},this.canSplit=function(){return this.isTemplated?!1:this.width>1},this.split=function(){if(this.canSplit()){var i=Math.floor(this.width/2),n=t.Column.from({data:null,htmlId:null,htmlClass:null,htmlStyle:null,width:i,offset:0,children:[]});this.width=this.width-i,this.parent.insertChild(n,this),n.setIsFocused()}},this.canContractRight=function(t){return this.isTemplated?!1:this.parent.canContractColumnRight(this,t)},this.contractRight=function(t){this.canContractRight(t)&&this.parent.contractColumnRight(this,t)},this.canExpandRight=function(t){return this.isTemplated?!1:this.parent.canExpandColumnRight(this,t)},this.expandRight=function(t){this.canExpandRight(t)&&this.parent.expandColumnRight(this,t)},this.canExpandLeft=function(t){return this.isTemplated?!1:this.parent.canExpandColumnLeft(this,t)},this.expandLeft=function(t){this.canExpandLeft(t)&&this.parent.expandColumnLeft(this,t)},this.canContractLeft=function(t){return this.isTemplated?!1:this.parent.canContractColumnLeft(this,t)},this.contractLeft=function(t){this.canContractLeft(t)&&this.parent.contractColumnLeft(this,t)},this.toObject=function(){var t=this.elementToObject();return t.width=this.width,t.offset=this.offset,t.collapsible=this.collapsible,t.children=this.childrenToObject(),t}},t.Column.from=function(i){var n=new t.Column(i.data,i.htmlId,i.htmlClass,i.htmlStyle,i.isTemplated,i.width,i.offset,i.collapsible,i.rule,t.childrenFrom(i.children));return n.toolboxIcon=i.toolboxIcon,n.toolboxLabel=i.toolboxLabel,n.toolboxDescription=i.toolboxDescription,n},t.Column.times=function(i){return _.times(i,function(n){return t.Column.from({data:null,htmlId:null,htmlClass:null,isTemplated:!1,width:12/i,offset:0,collapsible:null,children:[]})})}}(LayoutEditor||(LayoutEditor={}));var LayoutEditor;!function(t){t.Content=function(i,n,e,o,s,h,r,l,c,a,d){t.Element.call(this,"Content",i,n,e,o,s,d),this.contentType=h,this.contentTypeLabel=r,this.contentTypeClass=l,this.html=c,this.hasEditor=a,this.getInnerText=function(){return $($.parseHTML("
    "+this.html+"
    ")).text()},this.setHtml=function(t){this.html=t,this.htmlUnsafe=t},this.toObject=function(){return{type:"Content"}},this.toObject=function(){var t=this.elementToObject();return t.contentType=this.contentType,t.contentTypeLabel=this.contentTypeLabel,t.contentTypeClass=this.contentTypeClass,t.html=this.html,t.hasEditor=a,t},this.setHtml(c)},t.Content.from=function(i){var n=new t.Content(i.data,i.htmlId,i.htmlClass,i.htmlStyle,i.isTemplated,i.contentType,i.contentTypeLabel,i.contentTypeClass,i.html,i.hasEditor,i.rule);return n}}(LayoutEditor||(LayoutEditor={}));var LayoutEditor;!function(t,i){i.Html=function(n,e,o,s,h,r,l,c,a,d,u){i.Element.call(this,"Html",n,e,o,s,h,u),this.contentType=r,this.contentTypeLabel=l,this.contentTypeClass=c,this.html=a,this.hasEditor=d,this.isContainable=!0,this.getInnerText=function(){return t(t.parseHTML("
    "+this.html+"
    ")).text()},this.setHtml=function(t){this.html=t,this.htmlUnsafe=t},this.toObject=function(){return{type:"Html"}},this.toObject=function(){var t=this.elementToObject();return t.contentType=this.contentType,t.contentTypeLabel=this.contentTypeLabel,t.contentTypeClass=this.contentTypeClass,t.html=this.html,t.hasEditor=d,t};var f=this.getEditorObject;this.getEditorObject=function(){var i=f();return t.extend(i,{Content:this.html})},this.setHtml(a)},i.Html.from=function(t){var n=new i.Html(t.data,t.htmlId,t.htmlClass,t.htmlStyle,t.isTemplated,t.contentType,t.contentTypeLabel,t.contentTypeClass,t.html,t.hasEditor,t.rule);return n},i.registerFactory("Html",function(t){return i.Html.from(t)})}(jQuery,LayoutEditor||(LayoutEditor={})); \ No newline at end of file +var LayoutEditor;!function(t){Array.prototype.move=function(t,i){this.splice(i,0,this.splice(t,1)[0])},t.childrenFrom=function(i){return _(i).map(function(i){return t.elementFrom(i)})};var i=t.registerFactory=function(i,n){var e=t.factories=t.factories||{};e[i]=n};i("Canvas",function(i){return t.Canvas.from(i)}),i("Grid",function(i){return t.Grid.from(i)}),i("Row",function(i){return t.Row.from(i)}),i("Column",function(i){return t.Column.from(i)}),i("Content",function(i){return t.Content.from(i)}),t.elementFrom=function(i){var n=t.factories[i.type];if(!n)throw new Error('No element with type "'+i.type+'" was found.');var e=n(i);return e},t.setModel=function(t,i){$(t).scope().element=i},t.getModel=function(t){return $(t).scope().element}}(LayoutEditor||(LayoutEditor={}));var LayoutEditor;!function(t){t.Editor=function(i,n){this.config=i,this.canvas=t.Canvas.from(n),this.initialState=JSON.stringify(this.canvas.toObject()),this.activeElement=null,this.focusedElement=null,this.dropTargetElement=null,this.isDragging=!1,this.isResizing=!1,this.recycleBin=new t.RecycleBin,this.resetToolboxElements=function(){this.toolboxElements=[t.Row.from({children:[]})]},this.isDirty=function(){var t=JSON.stringify(this.canvas.toObject());return this.initialState!=t},this.resetToolboxElements(),this.canvas.setEditor(this)}}(LayoutEditor||(LayoutEditor={}));var LayoutEditor;!function(t){t.RecycleBin=function(){this.elements=[],this.add=function(t){this.elements.push(t)},this.toObject=function(){for(var t={type:"RecycleBin",children:[]},i=0;i=0&&(this.children.splice(i,1),this.editor.recycleBin.add(t),t.getIsActive()&&(this.editor.activeElement=null),t.getIsFocused()&&(this.children.length>i?this.children[i].setIsFocused():i>0?this.children[i-1].setIsFocused():this.setIsFocused()))},this.moveFocusPrevChild=function(t){if(!(this.children.length<2)){var i=_(this.children).indexOf(t);i>0&&this.children[i-1].setIsFocused()}},this.moveFocusNextChild=function(t){if(!(this.children.length<2)){var i=_(this.children).indexOf(t);i0},this.canMoveChildDown=function(t){var i=_(this.children).indexOf(t);return i0?t.width<12:0>e?t.width>1:!1}if(0==t)return!0;var e=t;if(0>e){var o=12-c();e+=o,e>0&&(e=0)}for(;0>e&&_(d.children).any(function(t){return t.offset>0});)for(i=0;ie;i++){var s=d.children[i];s.offset>0&&(s.offset--,e++)}for(;0!=e&&_(d.children).any(n);)for(i=0;i=0?t.width>1:!1},this.contractColumnRight=function(t,i){if(this.canContractColumnRight(t,i)){var n=_(this.children).indexOf(t);if(n>=0&&t.width>1&&(t.width--,this.children.length>n+1)){var e=this.children[n+1];i&&0==e.offset?e.width++:e.offset++}}},this.canExpandColumnRight=function(t,i){var n=_(this.children).indexOf(t);if(n>=0){if(t.width>=12)return!1;if(this.children.length>n+1){var e=this.children[n+1];return i&&0==e.offset?e.width>1:e.offset>0}return c()<12}return!1},this.expandColumnRight=function(t,i){if(this.canExpandColumnRight(t,i)){var n=_(this.children).indexOf(t);if(n>=0){if(this.children.length>n+1){var e=this.children[n+1];i&&0==e.offset?e.width--:e.offset--}t.width++}}},this.canExpandColumnLeft=function(t,i){var n=_(this.children).indexOf(t);if(n>=0){if(t.width>=12)return!1;if(n>0){var e=this.children[n-1];if(i&&0==t.offset)return e.width>1}return t.offset>0}return!1},this.expandColumnLeft=function(t,i){if(this.canExpandColumnLeft(t,i)){var n=_(this.children).indexOf(t);if(n>=0){if(n>0){var e=this.children[n-1];i&&0==t.offset?e.width--:t.offset--}else t.offset--;t.width++}}},this.canContractColumnLeft=function(t,i){var n=_(this.children).indexOf(t);return n>=0?t.width>1:!1},this.contractColumnLeft=function(t,i){if(this.canContractColumnLeft(t,i)){var n=_(this.children).indexOf(t);if(n>=0){if(n>0){var e=this.children[n-1];i&&0==t.offset?e.width++:t.offset++}else t.offset++;t.width--}}},this.evenColumns=function(){if(0!=this.children.length){var t=Math.floor(12/this.children.length);_(this.children).each(function(i){i.width=t,i.offset=0});var i=12%this.children.length;i>0&&a(i)}};var m=this.pasteChild;this.pasteChild=function(t){"Column"==t.type?this.beginAddColumn(t.width)&&(this.commitAddColumn(),m.call(this,t)):this.parent&&this.parent.pasteChild(t)},this.toObject=function(){var t=this.elementToObject();return t.children=this.childrenToObject(),t}},t.Row.from=function(i){var n=new t.Row(i.data,i.htmlId,i.htmlClass,i.htmlStyle,i.isTemplated,i.rule,t.childrenFrom(i.children));return n.toolboxIcon=i.toolboxIcon,n.toolboxLabel=i.toolboxLabel,n.toolboxDescription=i.toolboxDescription,n}}(LayoutEditor||(LayoutEditor={}));var LayoutEditor;!function(t){t.Column=function(i,n,e,o,s,h,r,l,c,a){t.Element.call(this,"Column",i,n,e,o,s,c),t.Container.call(this,["Grid","Content"],a),this.width=h,this.offset=r,this.collapsible=l;var d=!1,u=0,f=0;this.beginChange=function(){if(d)throw new Error("Column already has a pending change.");d=!0,u=this.width,f=this.offset},this.commitChange=function(){if(!d)throw new Error("Column has no pending change.");u=0,f=0,d=!1},this.rollbackChange=function(){if(!d)throw new Error("Column has no pending change.");this.width=u,this.offset=f,u=0,f=0,d=!1},this.canSplit=function(){return this.isTemplated?!1:this.width>1},this.split=function(){if(this.canSplit()){var i=Math.floor(this.width/2),n=t.Column.from({data:null,htmlId:null,htmlClass:null,htmlStyle:null,width:i,offset:0,children:[]});this.width=this.width-i,this.parent.insertChild(n,this),n.setIsFocused()}},this.canContractRight=function(t){return this.isTemplated?!1:this.parent.canContractColumnRight(this,t)},this.contractRight=function(t){this.canContractRight(t)&&this.parent.contractColumnRight(this,t)},this.canExpandRight=function(t){return this.isTemplated?!1:this.parent.canExpandColumnRight(this,t)},this.expandRight=function(t){this.canExpandRight(t)&&this.parent.expandColumnRight(this,t)},this.canExpandLeft=function(t){return this.isTemplated?!1:this.parent.canExpandColumnLeft(this,t)},this.expandLeft=function(t){this.canExpandLeft(t)&&this.parent.expandColumnLeft(this,t)},this.canContractLeft=function(t){return this.isTemplated?!1:this.parent.canContractColumnLeft(this,t)},this.contractLeft=function(t){this.canContractLeft(t)&&this.parent.contractColumnLeft(this,t)},this.toObject=function(){var t=this.elementToObject();return t.width=this.width,t.offset=this.offset,t.collapsible=this.collapsible,t.children=this.childrenToObject(),t}},t.Column.from=function(i){var n=new t.Column(i.data,i.htmlId,i.htmlClass,i.htmlStyle,i.isTemplated,i.width,i.offset,i.collapsible,i.rule,t.childrenFrom(i.children));return n.toolboxIcon=i.toolboxIcon,n.toolboxLabel=i.toolboxLabel,n.toolboxDescription=i.toolboxDescription,n},t.Column.times=function(i){return _.times(i,function(n){return t.Column.from({data:null,htmlId:null,htmlClass:null,isTemplated:!1,width:12/i,offset:0,collapsible:null,children:[]})})}}(LayoutEditor||(LayoutEditor={}));var LayoutEditor;!function(t){t.Content=function(i,n,e,o,s,h,r,l,c,a,d){t.Element.call(this,"Content",i,n,e,o,s,d),this.contentType=h,this.contentTypeLabel=r,this.contentTypeClass=l,this.html=c,this.hasEditor=a,this.getInnerText=function(){return $($.parseHTML("
    "+this.html+"
    ")).text()},this.setHtml=function(t){this.html=t,this.htmlUnsafe=t},this.toObject=function(){return{type:"Content"}},this.toObject=function(){var t=this.elementToObject();return t.contentType=this.contentType,t.contentTypeLabel=this.contentTypeLabel,t.contentTypeClass=this.contentTypeClass,t.html=this.html,t.hasEditor=a,t},this.setHtml(c)},t.Content.from=function(i){var n=new t.Content(i.data,i.htmlId,i.htmlClass,i.htmlStyle,i.isTemplated,i.contentType,i.contentTypeLabel,i.contentTypeClass,i.html,i.hasEditor,i.rule);return n}}(LayoutEditor||(LayoutEditor={})); \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Services/DefaultModelMaps.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Services/DefaultModelMaps.cs index 197e76c8b..ee1abd0b9 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Services/DefaultModelMaps.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Services/DefaultModelMaps.cs @@ -35,8 +35,13 @@ namespace Orchard.Layouts.Services { node["htmlId"] = element.HtmlId; node["htmlClass"] = element.HtmlClass; node["htmlStyle"] = element.HtmlStyle; - node["isTemplated"] = element.IsTemplated; node["rule"] = element.Rule; + node["isTemplated"] = element.IsTemplated; + node["hasEditor"] = element.Descriptor.EnableEditorDialog; + node["contentType"] = element.Descriptor.TypeName; + node["contentTypeLabel"] = element.Descriptor.DisplayText.Text; + node["contentTypeClass"] = element.DisplayText.Text.HtmlClassify(); + node["contentTypeDescription"] = element.Descriptor.Description.Text; } protected virtual void ToElement(T element, JToken node) { diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Views/LayoutEditor.Template.Children.cshtml b/src/Orchard.Web/Modules/Orchard.Layouts/Views/LayoutEditor.Template.Children.cshtml index 5aa2368a1..9670c0b2f 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Views/LayoutEditor.Template.Children.cshtml +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Views/LayoutEditor.Template.Children.cshtml @@ -1,4 +1,4 @@ -
    +
    diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Views/LayoutEditor.Template.Content.cshtml b/src/Orchard.Web/Modules/Orchard.Layouts/Views/LayoutEditor.Template.Content.cshtml index bd57cbbd7..c79866340 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Views/LayoutEditor.Template.Content.cshtml +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Views/LayoutEditor.Template.Content.cshtml @@ -7,5 +7,5 @@
    • -
    +
    \ No newline at end of file From a492f89ea03b950266091bd28228882b5d7fd31b Mon Sep 17 00:00:00 2001 From: Sipke Schoorstra Date: Mon, 21 Dec 2015 20:59:47 +0100 Subject: [PATCH 30/30] Further Layouts client-side scripting improvements. - Pushed the editElement function further down from Content to Element, which means even less code for custom container elements. - Fixed a bug where client-side element editor state would not be applied after editing that element. - Pushed down the toObject function from Content to Element, which means less code is necessary for custom container elements. - --- .../LayoutEditor/Directives/Content.js | 15 +------------ .../Services/ScopeConfigurator.js | 4 ++++ .../Assets/JavaScript/Models/Content.js | 11 ++-------- .../Assets/JavaScript/Models/Element.js | 9 +++++++- .../Orchard.Layouts/Scripts/LayoutEditor.js | 21 +++++------------- .../Scripts/LayoutEditor.min.js | 2 +- .../Modules/Orchard.Layouts/Scripts/Models.js | 22 +++++++++---------- .../Orchard.Layouts/Scripts/Models.min.js | 2 +- 8 files changed, 34 insertions(+), 52 deletions(-) diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Directives/Content.js b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Directives/Content.js index 69292804a..43ff14920 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Directives/Content.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Directives/Content.js @@ -8,20 +8,7 @@ controller: ["$scope", "$element", function ($scope, $element) { scopeConfigurator.configureForElement($scope, $element); - if ($scope.element.hasEditor) { - $scope.edit = function () { - $scope.$root.editElement($scope.element).then(function (args) { - $scope.$apply(function () { - if (args.cancel) - return; - - $scope.element.data = args.element.data; - $scope.element.setHtml(args.element.html); - }); - }); - }; - } - + // Overwrite the setHtml function so that we can use the $sce service to trust the html (and not have the html binding strip certain tags). $scope.element.setHtml = function (html) { $scope.element.html = html; diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Services/ScopeConfigurator.js b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Services/ScopeConfigurator.js index 3f3710d2c..9a42f8a8f 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Services/ScopeConfigurator.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/LayoutEditor/Services/ScopeConfigurator.js @@ -159,6 +159,10 @@ return; $scope.element.data = args.element.data; + $scope.element.applyElementEditorModel(args.elementEditorModel); + + if (!!$scope.element.setHtml) + $scope.element.setHtml(args.element.html); }); }); }; diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Content.js b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Content.js index 15a974b9d..05e498144 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Content.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Content.js @@ -20,19 +20,12 @@ this.htmlUnsafe = html; } + var baseToObject = this.toObject; this.toObject = function () { - return { - "type": "Content" - }; - }; - - this.toObject = function () { - var result = this.elementToObject(); - result.contentType = this.contentType; + var result = baseToObject(); result.contentTypeLabel = this.contentTypeLabel; result.contentTypeClass = this.contentTypeClass; result.html = this.html; - result.hasEditor = hasEditor; return result; }; diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Element.js b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Element.js index 94e2533a5..cdedc0df3 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Element.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Element.js @@ -5,6 +5,7 @@ if (!type) throw new Error("Parameter 'type' is required."); + var self = this; this.type = type; this.data = data; this.htmlId = htmlId; @@ -164,7 +165,9 @@ htmlClass: this.htmlClass, htmlStyle: this.htmlStyle, isTemplated: this.isTemplated, - rule: this.rule + rule: this.rule, + contentType: this.contentType, + hasEditor: this.hasEditor }; }; @@ -172,6 +175,10 @@ return {}; }; + this.toObject = function () { + return self.elementToObject(); + }; + this.copy = function (clipboardData) { var text = this.getInnerText(); clipboardData.setData("text/plain", text); diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutEditor.js b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutEditor.js index b5c6420a9..e910d5158 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutEditor.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutEditor.js @@ -211,6 +211,10 @@ angular return; $scope.element.data = args.element.data; + $scope.element.applyElementEditorModel(args.elementEditorModel); + + if (!!$scope.element.setHtml) + $scope.element.setHtml(args.element.html); }); }); }; @@ -635,20 +639,7 @@ angular controller: ["$scope", "$element", function ($scope, $element) { scopeConfigurator.configureForElement($scope, $element); - if ($scope.element.hasEditor) { - $scope.edit = function () { - $scope.$root.editElement($scope.element).then(function (args) { - $scope.$apply(function () { - if (args.cancel) - return; - - $scope.element.data = args.element.data; - $scope.element.setHtml(args.element.html); - }); - }); - }; - } - + // Overwrite the setHtml function so that we can use the $sce service to trust the html (and not have the html binding strip certain tags). $scope.element.setHtml = function (html) { $scope.element.html = html; @@ -973,4 +964,4 @@ angular }; } ]); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["LayoutEditor.js","Module.js","Clipboard.js","ScopeConfigurator.js","Editor.js","Canvas.js","Child.js","Column.js","Content.js","Grid.js","Row.js","Popup.js","Toolbox.js","ToolboxGroup.js"],"names":[],"mappings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zIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACrCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC9MA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"LayoutEditor.js","sourcesContent":[null,"angular.module(\"LayoutEditor\", [\"ngSanitize\", \"ngResource\", \"ui.sortable\"]);","var LayoutEditor;\r\n(function(LayoutEditor) {\r\n\r\n    var Clipboard = function () {\r\n        var self = this;\r\n        this._clipboardData = {};\r\n        this._isDisabled = false;\r\n        this._wasInvoked = false;\r\n\r\n        this.setData = function(contentType, data) {\r\n            self._clipboardData[contentType] = data;\r\n            self._wasInvoked = true;\r\n        };\r\n        this.getData = function (contentType) {\r\n            return self._clipboardData[contentType];\r\n            self._wasInvoked = true;\r\n        };\r\n        this.disable = function() {\r\n            self._isDisabled = true;\r\n            self._wasInvoked = false;\r\n            self._clipboardData = {};\r\n        };\r\n        this.isDisabled = function () {\r\n            return self._isDisabled;\r\n        }\r\n        this.wasInvoked = function () {\r\n            return self._wasInvoked;\r\n        }\r\n    }\r\n\r\n    LayoutEditor.Clipboard = new Clipboard();\r\n\r\n    angular\r\n        .module(\"LayoutEditor\")\r\n        .factory(\"clipboard\", [\r\n            function() {\r\n                return {\r\n                    setData: LayoutEditor.Clipboard.setData,\r\n                    getData: LayoutEditor.Clipboard.getData,\r\n                    disable: LayoutEditor.Clipboard.disable,\r\n                    isDisabled: LayoutEditor.Clipboard.isDisabled,\r\n                    wasInvoked: LayoutEditor.Clipboard.wasInvoked\r\n                };\r\n            }\r\n        ]);\r\n})(LayoutEditor || (LayoutEditor = {}));","angular\r\n    .module(\"LayoutEditor\")\r\n    .factory(\"scopeConfigurator\", [\"$timeout\", \"clipboard\",\r\n        function ($timeout, clipboard) {\r\n            return {\r\n\r\n                configureForElement: function ($scope, $element) {\r\n                \r\n                    $element.find(\".layout-panel\").click(function (e) {\r\n                        e.stopPropagation();\r\n                    });\r\n\r\n                    $element.parent().keydown(function (e) {\r\n                        var handled = false;\r\n                        var resetFocus = false;\r\n                        var element = $scope.element;\r\n                    \r\n                        if (element.editor.isDragging)\r\n                            return;\r\n\r\n                        // If native clipboard support exists, the pseudo-clipboard will have been disabled.\r\n                        if (!clipboard.isDisabled()) {\r\n                            var focusedElement = element.editor.focusedElement;\r\n                            if (!!focusedElement) {\r\n                                // Pseudo clipboard handling for browsers not allowing real clipboard operations.\r\n                                if (e.ctrlKey) {\r\n                                    switch (e.which) {\r\n                                    case 67: // C\r\n                                        focusedElement.copy(clipboard);\r\n                                        break;\r\n                                    case 88: // X\r\n                                        focusedElement.cut(clipboard);\r\n                                        break;\r\n                                    case 86: // V\r\n                                        focusedElement.paste(clipboard);\r\n                                        break;\r\n                                    }\r\n                                }\r\n                            }\r\n                        }\r\n\r\n                        if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 46) { // Del\r\n                            $scope.delete(element);\r\n                            handled = true;\r\n                        } else if (!e.ctrlKey && !e.shiftKey && !e.altKey && (e.which == 32 || e.which == 27)) { // Space or Esc\r\n                            $element.find(\".layout-panel-action-properties\").first().click();\r\n                            handled = true;\r\n                        }\r\n\r\n                        if (element.type == \"Content\") { // This is a content element.\r\n                            if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 13) { // Enter\r\n                                $element.find(\".layout-panel-action-edit\").first().click();\r\n                                handled = true;\r\n                            }\r\n                        }\r\n\r\n                        if (!!element.children) { // This is a container.\r\n                            if (!e.ctrlKey && !e.shiftKey && e.altKey && e.which == 40) { // Alt+Down\r\n                                if (element.children.length > 0)\r\n                                    element.children[0].setIsFocused();\r\n                                handled = true;\r\n                            }\r\n\r\n                            if (element.type == \"Column\") { // This is a column.\r\n                                var connectAdjacent = !e.ctrlKey;\r\n                                if (e.which == 37) { // Left\r\n                                    if (e.altKey)\r\n                                        element.expandLeft(connectAdjacent);\r\n                                    if (e.shiftKey)\r\n                                        element.contractRight(connectAdjacent);\r\n                                    handled = true;\r\n                                } else if (e.which == 39) { // Right\r\n                                    if (e.altKey)\r\n                                        element.contractLeft(connectAdjacent);\r\n                                    if (e.shiftKey)\r\n                                        element.expandRight(connectAdjacent);\r\n                                    handled = true;\r\n                                }\r\n                            }\r\n                        }\r\n\r\n                        if (!!element.parent) { // This is a child.\r\n                            if (e.altKey && e.which == 38) { // Alt+Up\r\n                                element.parent.setIsFocused();\r\n                                handled = true;\r\n                            }\r\n\r\n                            if (element.parent.type == \"Row\") { // Parent is a horizontal container.\r\n                                if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 37) { // Left\r\n                                    element.parent.moveFocusPrevChild(element);\r\n                                    handled = true;\r\n                                }\r\n                                else if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 39) { // Right\r\n                                    element.parent.moveFocusNextChild(element);\r\n                                    handled = true;\r\n                                }\r\n                                else if (e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 37) { // Ctrl+Left\r\n                                    element.moveUp();\r\n                                    resetFocus = true;\r\n                                    handled = true;\r\n                                }\r\n                                else if (e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 39) { // Ctrl+Right\r\n                                    element.moveDown();\r\n                                    handled = true;\r\n                                }\r\n                            }\r\n                            else { // Parent is a vertical container.\r\n                                if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 38) { // Up\r\n                                    element.parent.moveFocusPrevChild(element);\r\n                                    handled = true;\r\n                                }\r\n                                else if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 40) { // Down\r\n                                    element.parent.moveFocusNextChild(element);\r\n                                    handled = true;\r\n                                }\r\n                                else if (e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 38) { // Ctrl+Up\r\n                                    element.moveUp();\r\n                                    resetFocus = true;\r\n                                    handled = true;\r\n                                }\r\n                                else if (e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 40) { // Ctrl+Down\r\n                                    element.moveDown();\r\n                                    handled = true;\r\n                                }\r\n                            }\r\n                        }\r\n\r\n                        if (handled) {\r\n                            e.preventDefault();\r\n                        }\r\n\r\n                        e.stopPropagation();\r\n\r\n                        $scope.$apply(); // Event is not triggered by Angular directive but raw event handler on element.\r\n\r\n                        // HACK: Workaround because of how Angular treats the DOM when elements are shifted around - input focus is sometimes lost.\r\n                        if (resetFocus) {\r\n                            window.setTimeout(function () {\r\n                                $scope.$apply(function () {\r\n                                    element.editor.focusedElement.setIsFocused();\r\n                                });\r\n                            }, 100);\r\n                        }\r\n                    });\r\n\r\n                    $scope.element.setIsFocusedEventHandlers.push(function () {\r\n                        $element.parent().focus();\r\n                    });\r\n\r\n                    $scope.delete = function (element) {\r\n                        element.delete();\r\n                    }\r\n\r\n                    if ($scope.element.hasEditor) {\r\n                        $scope.edit = function () {\r\n                            $scope.$root.editElement($scope.element).then(function (args) {\r\n                                $scope.$apply(function () {\r\n                                    if (args.cancel)\r\n                                        return;\r\n\r\n                                    $scope.element.data = args.element.data;\r\n                                });\r\n                            });\r\n                        };\r\n                    }\r\n                },\r\n\r\n                configureForContainer: function ($scope, $element) {\r\n                    var element = $scope.element;\r\n\r\n                    //$scope.isReceiving = false; // True when container is receiving an external element via drag/drop.\r\n                    $scope.getShowChildrenPlaceholder = function () {\r\n                        return $scope.element.children.length === 0 && !$scope.element.getIsDropTarget();\r\n                    };\r\n\r\n                    $scope.sortableOptions = {\r\n                        cursor: \"move\",\r\n                        delay: 150,\r\n                        disabled: element.getIsSealed(),\r\n                        distance: 5,\r\n                        //handle: element.children.length < 2 ? \".imaginary-class\" : false, // For some reason doesn't get re-evaluated after adding more children.\r\n                        start: function (e, ui) {\r\n                            $scope.$apply(function () {\r\n                                element.setIsDropTarget(true);\r\n                                element.editor.isDragging = true;\r\n                            });\r\n                            // Make the drop target placeholder as high as the item being dragged.\r\n                            ui.placeholder.height(ui.item.height() - 4);\r\n                            ui.placeholder.css(\"min-height\", 0);\r\n                        },\r\n                        stop: function (e, ui) {\r\n                            $scope.$apply(function () {\r\n                                element.editor.isDragging = false;\r\n                                element.setIsDropTarget(false);\r\n                            });\r\n                        },\r\n                        over: function (e, ui) {\r\n                            if (!!ui.sender && !!ui.sender[0].isToolbox) {\r\n                                if (!!ui.sender[0].dropTargetTimeout) {\r\n                                    $timeout.cancel(ui.sender[0].dropTargetTimeout);\r\n                                    ui.sender[0].dropTargetTimeout = null;\r\n                                }\r\n                                $timeout(function () {\r\n                                    if (element.type == \"Row\") {\r\n                                        // If there was a previous drop target and it was a row, roll back any pending column adds to it.\r\n                                        var previousDropTarget = element.editor.dropTargetElement;\r\n                                        if (!!previousDropTarget && previousDropTarget.type == \"Row\")\r\n                                            previousDropTarget.rollbackAddColumn();\r\n                                    }\r\n                                    element.setIsDropTarget(false);\r\n                                });\r\n                                ui.sender[0].dropTargetTimeout = $timeout(function () {\r\n                                    if (element.type == \"Row\") {\r\n                                        var receivedColumn = ui.item.sortable.model;\r\n                                        var receivedColumnWidth = Math.floor(12 / (element.children.length + 1));\r\n                                        receivedColumn.width = receivedColumnWidth;\r\n                                        receivedColumn.offset = 0;\r\n                                        element.beginAddColumn(receivedColumnWidth);\r\n                                        // Make the drop target placeholder the correct width and as high as the highest existing column in the row.\r\n                                        var maxHeight = _.max(_($element.find(\"> .layout-children > .layout-column:not(.ui-sortable-placeholder)\")).map(function (e) {\r\n                                            return $(e).height();\r\n                                        }));\r\n                                        for (i = 1; i <= 12; i++)\r\n                                            ui.placeholder.removeClass(\"col-xs-\" + i);\r\n                                        ui.placeholder.addClass(\"col-xs-\" + receivedColumn.width);\r\n                                        if (maxHeight > 0) {\r\n                                            ui.placeholder.height(maxHeight);\r\n                                            ui.placeholder.css(\"min-height\", 0);\r\n                                        }\r\n                                        else {\r\n                                            ui.placeholder.height(0);\r\n                                            ui.placeholder.css(\"min-height\", \"\");\r\n                                        }\r\n                                    }\r\n                                    element.setIsDropTarget(true);\r\n                                }, 150);\r\n                            }\r\n                        },\r\n                        receive: function (e, ui) {\r\n                            if (!!ui.sender && !!ui.sender[0].isToolbox) {\r\n                                $scope.$apply(function () {\r\n                                    var receivedElement = ui.item.sortable.model;\r\n                                    if (!!receivedElement) {\r\n                                        if (element.type == \"Row\")\r\n                                            element.commitAddColumn();\r\n                                        // Should ideally call LayoutEditor.Container.addChild() instead, but since this handler\r\n                                        // is run *before* the ui-sortable directive's handler, if we try to add the child to the\r\n                                        // array that handler will get an exception when trying to do the same.\r\n                                        // Because of this, we need to invoke \"setParent\" so that specific container types can perform element speficic initialization.\r\n                                        receivedElement.setEditor(element.editor);\r\n                                        receivedElement.setParent(element);\r\n\r\n                                        if (!!receivedElement.hasEditor) {\r\n                                            $scope.$root.editElement(receivedElement).then(function (args) {\r\n                                                if (!args.cancel) {\r\n                                                    receivedElement.data = args.element.data;\r\n                                                    receivedElement.applyElementEditorModel(args.elementEditorModel);\r\n\r\n                                                    if (!!receivedElement.setHtml)\r\n                                                        receivedElement.setHtml(args.element.html);\r\n                                                }\r\n                                                $timeout(function () {\r\n                                                    if (!!args.cancel)\r\n                                                        receivedElement.delete();\r\n                                                    else\r\n                                                        receivedElement.setIsFocused();\r\n                                                    //$scope.isReceiving = false;\r\n                                                    element.setIsDropTarget(false);\r\n\r\n                                                });\r\n                                                return;\r\n                                            });\r\n                                        }\r\n                                    }\r\n                                    $timeout(function () {\r\n                                        //$scope.isReceiving = false;\r\n                                        element.setIsDropTarget(false);\r\n                                        if (!!receivedElement)\r\n                                            receivedElement.setIsFocused();\r\n                                    });\r\n                                });\r\n                            }\r\n                        }\r\n                    };\r\n\r\n                    $scope.click = function (child, e) {\r\n                        if (!child.editor.isDragging)\r\n                            child.setIsFocused();\r\n                        e.stopPropagation();\r\n                    };\r\n\r\n                    $scope.getClasses = function (child) {\r\n                        var result = [\"layout-element\"];\r\n\r\n                        if (!!child.children) {\r\n                            result.push(\"layout-container\");\r\n                            if (child.getIsSealed())\r\n                                result.push(\"layout-container-sealed\");\r\n                        }\r\n\r\n                        result.push(\"layout-\" + child.type.toLowerCase());\r\n\r\n                        if (!!child.dropTargetClass)\r\n                            result.push(child.dropTargetClass);\r\n\r\n                        // TODO: Move these to either the Column directive or the Column model class.\r\n                        if (child.type == \"Row\") {\r\n                            result.push(\"row\");\r\n                            if (!child.canAddColumn())\r\n                                result.push(\"layout-row-full\");\r\n                        }\r\n                        if (child.type == \"Column\") {\r\n                            result.push(\"col-xs-\" + child.width);\r\n                            result.push(\"col-xs-offset-\" + child.offset);\r\n                        }\r\n                        if (child.type == \"Content\")\r\n                            result.push(\"layout-content-\" + child.contentTypeClass);\r\n\r\n                        if (child.getIsActive())\r\n                            result.push(\"layout-element-active\");\r\n                        if (child.getIsFocused())\r\n                            result.push(\"layout-element-focused\");\r\n                        if (child.getIsSelected())\r\n                            result.push(\"layout-element-selected\");\r\n                        if (child.getIsDropTarget())\r\n                            result.push(\"layout-element-droptarget\");\r\n                        if (child.isTemplated)\r\n                            result.push(\"layout-element-templated\");\r\n\r\n                        return result;\r\n                    };\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutEditor\", [\"environment\",\r\n        function (environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: {},\r\n                controller: [\"$scope\", \"$element\", \"$attrs\", \"$compile\", \"clipboard\",\r\n                    function ($scope, $element, $attrs, $compile, clipboard) {\r\n                        if (!!$attrs.model)\r\n                            $scope.element = eval($attrs.model);\r\n                        else\r\n                            throw new Error(\"The 'model' attribute must evaluate to a LayoutEditor.Editor object.\");\r\n\r\n                        $scope.click = function (canvas, e) {\r\n                            if (!canvas.editor.isDragging)\r\n                                canvas.setIsFocused();\r\n                            e.stopPropagation();\r\n                        };\r\n\r\n                        $scope.getClasses = function (canvas) {\r\n                            var result = [\"layout-element\", \"layout-container\", \"layout-canvas\"];\r\n\r\n                            if (canvas.getIsActive())\r\n                                result.push(\"layout-element-active\");\r\n                            if (canvas.getIsFocused())\r\n                                result.push(\"layout-element-focused\");\r\n                            if (canvas.getIsSelected())\r\n                                result.push(\"layout-element-selected\");\r\n                            if (canvas.getIsDropTarget())\r\n                                result.push(\"layout-element-droptarget\");\r\n                            if (canvas.isTemplated)\r\n                                result.push(\"layout-element-templated\");\r\n\r\n                            return result;\r\n                        };\r\n\r\n                        // An unfortunate side-effect of the next hack on line 54 is that the created elements aren't added to the DOM yet, so we can't use it to get to the parent \".layout-desiger\" element.\r\n                        // Work around: access that element directly (which efectively turns multiple layout editors on a single page impossible). \r\n                        // //var layoutDesignerHost = $element.closest(\".layout-designer\").data(\"layout-designer-host\");\r\n                        var layoutDesignerHost = $(\".layout-designer\").data(\"layout-designer-host\");\r\n\r\n                        $scope.$root.layoutDesignerHost = layoutDesignerHost;\r\n\r\n                        layoutDesignerHost.element.on(\"replacecanvas\", function (e, args) {\r\n                            var editor = $scope.element;\r\n                            var canvasData = {\r\n                                data: args.canvas.data,\r\n                                htmlId: args.canvas.htmlId,\r\n                                htmlClass: args.canvas.htmlClass,\r\n                                htmlStyle: args.canvas.htmlStyle,\r\n                                isTemplated: args.canvas.isTemplated,\r\n                                children: args.canvas.children\r\n                            };\r\n\r\n                            // HACK: Instead of simply updating the $scope.element with a new instance, we need to replace the entire orc-layout-editor markup\r\n                            // in order for angular to rebind starting with the Canvas element. Otherwise, for some reason, it will rebind starting with the first child of Canvas.\r\n                            // You can see this happening when setting a breakpoint in ScopeConfigurator where containers are initialized with drag & drop: on page load, the first element\r\n                            // is a Canvas (good), but after having selected another template, the first element is (typically) a Grid (bad).\r\n                            // Simply recompiling the orc-layout-editor directive will cause the entire thing to be generated, which works just fine as well (even though not is nice as simply leveraging model binding).\r\n                            layoutDesignerHost.editor = window.layoutEditor = new LayoutEditor.Editor(editor.config, canvasData);\r\n                            var template = \"<orc-layout-editor\" + \" model='window.layoutEditor' />\";\r\n                            var html = $compile(template)($scope);\r\n                            $(\".layout-editor-holder\").html(html);\r\n                        });\r\n\r\n                        $scope.$root.editElement = function (element) {\r\n                            var host = $scope.$root.layoutDesignerHost;\r\n                            return host.editElement(element);\r\n                        };\r\n\r\n                        $scope.$root.addElement = function (contentType) {\r\n                            var host = $scope.$root.layoutDesignerHost;\r\n                            return host.addElement(contentType);\r\n                        };\r\n\r\n                        $(document).on(\"cut copy paste\", function (e) {\r\n                            // If the pseudo clipboard was already invoked (which happens on the first clipboard\r\n                            // operation after page load even if native clipboard support exists) then sit this\r\n                            // one operation out, but make sure whatever is on the pseudo clipboard gets migrated\r\n                            // to the native clipboard for subsequent operations.\r\n                            if (clipboard.wasInvoked()) {\r\n                                e.originalEvent.clipboardData.setData(\"text/plain\", clipboard.getData(\"text/plain\"));\r\n                                e.originalEvent.clipboardData.setData(\"text/json\", clipboard.getData(\"text/json\"));\r\n                                e.preventDefault();\r\n                            }\r\n                            else {\r\n                                var focusedElement = $scope.element.focusedElement;\r\n                                if (!!focusedElement) {\r\n                                    $scope.$apply(function () {\r\n                                        switch (e.type) {\r\n                                            case \"copy\":\r\n                                                focusedElement.copy(e.originalEvent.clipboardData);\r\n                                                break;\r\n                                            case \"cut\":\r\n                                                focusedElement.cut(e.originalEvent.clipboardData);\r\n                                                break;\r\n                                            case \"paste\":\r\n                                                focusedElement.paste(e.originalEvent.clipboardData);\r\n                                                break;\r\n                                        }\r\n                                    });\r\n\r\n                                    // HACK: Workaround because of how Angular treats the DOM when elements are shifted around - input focus is sometimes lost.\r\n                                    window.setTimeout(function () {\r\n                                        $scope.$apply(function () {\r\n                                            if (!!$scope.element.focusedElement)\r\n                                                $scope.element.focusedElement.setIsFocused();\r\n                                        });\r\n                                    }, 100);\r\n\r\n                                    e.preventDefault();\r\n                                }\r\n                            }\r\n\r\n                            // Native clipboard support obviously exists, so disable the peudo clipboard from now on.\r\n                            clipboard.disable();\r\n                        });\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Editor\"),\r\n                replace: true,\r\n                link: function (scope, element) {\r\n                    // No clicks should propagate from the TinyMCE toolbars.\r\n                    element.find(\".layout-toolbar-container\").click(function (e) {\r\n                        e.stopPropagation();\r\n                    });\r\n                    // Unfocus and unselect everything on click outside of canvas.\r\n                    $(window).click(function (e) {\r\n                        scope.$apply(function () {\r\n                            scope.element.activeElement = null;\r\n                            scope.element.focusedElement = null;\r\n                        });\r\n                    });\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutCanvas\", [\"scopeConfigurator\", \"environment\",\r\n        function (scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\", \"$attrs\",\r\n                    function ($scope, $element, $attrs) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        scopeConfigurator.configureForContainer($scope, $element);\r\n                        $scope.sortableOptions[\"axis\"] = \"y\";\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Canvas\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutChild\", [\"$compile\",\r\n        function ($compile) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                link: function (scope, element) {\r\n                    var template = \"<orc-layout-\" + scope.element.type.toLowerCase() + \" element='element' />\";\r\n                    var html = $compile(template)(scope);\r\n                    $(element).replaceWith(html);\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutColumn\", [\"$compile\", \"scopeConfigurator\", \"environment\",\r\n        function ($compile, scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        scopeConfigurator.configureForContainer($scope, $element);\r\n                        $scope.sortableOptions[\"axis\"] = \"y\";\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Column\"),\r\n                replace: true,\r\n                link: function (scope, element, attrs) {\r\n                    element.find(\".layout-column-resize-bar\").draggable({\r\n                        axis: \"x\",\r\n                        helper: \"clone\",\r\n                        revert: true,\r\n                        start: function (e, ui) {\r\n                            scope.$apply(function () {\r\n                                scope.element.editor.isResizing = true;\r\n                            });\r\n                        },\r\n                        drag: function (e, ui) {\r\n                            var columnElement = element.parent();\r\n                            var columnSize = columnElement.width() / scope.element.width;\r\n                            var connectAdjacent = !e.ctrlKey;\r\n                            if ($(e.target).hasClass(\"layout-column-resize-bar-left\")) {\r\n                                var delta = ui.offset.left - columnElement.offset().left;\r\n                                if (delta < -columnSize && scope.element.canExpandLeft(connectAdjacent)) {\r\n                                    scope.$apply(function () {\r\n                                        scope.element.expandLeft(connectAdjacent);\r\n                                    });\r\n                                }\r\n                                else if (delta > columnSize && scope.element.canContractLeft(connectAdjacent)) {\r\n                                    scope.$apply(function () {\r\n                                        scope.element.contractLeft(connectAdjacent);\r\n                                    });\r\n                                }\r\n                            }\r\n                            else if ($(e.target).hasClass(\"layout-column-resize-bar-right\")) {\r\n                                var delta = ui.offset.left - columnElement.width() - columnElement.offset().left;\r\n                                if (delta > columnSize && scope.element.canExpandRight(connectAdjacent)) {\r\n                                    scope.$apply(function () {\r\n                                        scope.element.expandRight(connectAdjacent);\r\n                                    });\r\n                                }\r\n                                else if (delta < -columnSize && scope.element.canContractRight(connectAdjacent)) {\r\n                                    scope.$apply(function () {\r\n                                        scope.element.contractRight(connectAdjacent);\r\n                                    });\r\n                                }\r\n                            }\r\n\r\n                        },\r\n                        stop: function (e, ui) {\r\n                            scope.$apply(function () {\r\n                              scope.element.editor.isResizing = false;\r\n                            });\r\n                        }\r\n                    });\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutContent\", [\"$sce\", \"scopeConfigurator\", \"environment\",\r\n        function ($sce, scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        if ($scope.element.hasEditor) {\r\n                            $scope.edit = function () {\r\n                                $scope.$root.editElement($scope.element).then(function (args) {\r\n                                    $scope.$apply(function () {\r\n                                        if (args.cancel)\r\n                                            return;\r\n\r\n                                        $scope.element.data = args.element.data;\r\n                                        $scope.element.setHtml(args.element.html);\r\n                                    });\r\n                                });\r\n                            };\r\n                        }\r\n\r\n                        // Overwrite the setHtml function so that we can use the $sce service to trust the html (and not have the html binding strip certain tags).\r\n                        $scope.element.setHtml = function (html) {\r\n                            $scope.element.html = html;\r\n                            $scope.element.htmlUnsafe = $sce.trustAsHtml(html);\r\n                        };\r\n\r\n                        $scope.element.setHtml($scope.element.html);\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Content\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutGrid\", [\"$compile\", \"scopeConfigurator\", \"environment\",\r\n        function ($compile, scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        scopeConfigurator.configureForContainer($scope, $element);\r\n                        $scope.sortableOptions[\"axis\"] = \"y\";\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Grid\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutRow\", [\"$compile\", \"scopeConfigurator\", \"environment\",\r\n        function ($compile, scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        scopeConfigurator.configureForContainer($scope, $element);\r\n                        $scope.sortableOptions[\"axis\"] = \"x\";\r\n                        $scope.sortableOptions[\"ui-floating\"] = true;\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Row\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutPopup\", [\r\n        function () {\r\n            return {\r\n                restrict: \"A\",\r\n                link: function (scope, element, attrs) {\r\n                    var popup = $(element);\r\n                    var trigger = popup.closest(\".layout-popup-trigger\");\r\n                    var parentElement = popup.closest(\".layout-element\");\r\n                    trigger.click(function () {\r\n                        popup.toggle();\r\n                        if (popup.is(\":visible\")) {\r\n                            popup.position({\r\n                                my: attrs.orcLayoutPopupMy || \"left top\",\r\n                                at: attrs.orcLayoutPopupAt || \"left bottom+4px\",\r\n                                of: trigger\r\n                            });\r\n                            popup.find(\"input\").first().focus();\r\n                        }\r\n                    });\r\n                    popup.click(function (e) {\r\n                        e.stopPropagation();\r\n                    });\r\n                    parentElement.click(function (e) {\r\n                        popup.hide();\r\n                    });\r\n                    popup.keydown(function (e) {\r\n                        if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 27) // Esc\r\n                            popup.hide();\r\n                        e.stopPropagation();\r\n                    });\r\n                    popup.on(\"cut copy paste\", function (e) {\r\n                        // Allow clipboard operations in popup without invoking clipboard event handlers on parent element.\r\n                        e.stopPropagation();\r\n                    });\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutToolbox\", [\"$compile\", \"environment\",\r\n        function ($compile, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n\r\n                        $scope.resetElements = function () {\r\n\r\n                            $scope.gridElements = [\r\n                                LayoutEditor.Grid.from({\r\n                                    toolboxIcon: \"\\uf00a\",\r\n                                    toolboxLabel: \"Grid\",\r\n                                    toolboxDescription: \"Empty grid.\",\r\n                                    children: []\r\n                                })\r\n                            ];\r\n\r\n                            $scope.rowElements = [\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (1 column)\",\r\n                                    toolboxDescription: \"Row with 1 column.\",\r\n                                    children: LayoutEditor.Column.times(1)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (2 columns)\",\r\n                                    toolboxDescription: \"Row with 2 columns.\",\r\n                                    children: LayoutEditor.Column.times(2)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (3 columns)\",\r\n                                    toolboxDescription: \"Row with 3 columns.\",\r\n                                    children: LayoutEditor.Column.times(3)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (4 columns)\",\r\n                                    toolboxDescription: \"Row with 4 columns.\",\r\n                                    children: LayoutEditor.Column.times(4)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (6 columns)\",\r\n                                    toolboxDescription: \"Row with 6 columns.\",\r\n                                    children: LayoutEditor.Column.times(6)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (12 columns)\",\r\n                                    toolboxDescription: \"Row with 12 columns.\",\r\n                                    children: LayoutEditor.Column.times(12)\r\n                                }), LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (empty)\",\r\n                                    toolboxDescription: \"Empty row.\",\r\n                                    children: []\r\n                                })\r\n                            ];\r\n\r\n                            $scope.columnElements = [\r\n                                LayoutEditor.Column.from({\r\n                                    toolboxIcon: \"\\uf0db\",\r\n                                    toolboxLabel: \"Column\",\r\n                                    toolboxDescription: \"Empty column.\",\r\n                                    width: 1,\r\n                                    offset: 0,\r\n                                    children: []\r\n                                })\r\n                            ];\r\n\r\n                            $scope.canvasElements = [\r\n                                LayoutEditor.Canvas.from({\r\n                                    toolboxIcon: \"\\uf044\",\r\n                                    toolboxLabel: \"Canvas\",\r\n                                    toolboxDescription: \"Empty canvas.\",\r\n                                    children: []\r\n                                })\r\n                            ];\r\n\r\n                            $scope.contentElementCategories = _($scope.element.config.categories).map(function (category) {\r\n                                return {\r\n                                    name: category.name,\r\n                                    elements: _(category.contentTypes).map(function (contentType) {\r\n                                        var type = contentType.type;\r\n                                        var factory = LayoutEditor.factories[type] || LayoutEditor.factories[\"Content\"];\r\n                                        var item = {\r\n                                            isTemplated: false,\r\n                                            contentType: contentType.id,\r\n                                            contentTypeLabel: contentType.label,\r\n                                            contentTypeClass: contentType.typeClass,\r\n                                            data: null,\r\n                                            hasEditor: contentType.hasEditor,\r\n                                            html: contentType.html\r\n                                        };\r\n                                        var element = factory(item);\r\n                                        element.toolboxIcon = contentType.icon || \"\\uf1c9\";\r\n                                        element.toolboxLabel = contentType.label;\r\n                                        element.toolboxDescription = contentType.description;\r\n                                        return element;\r\n                                    })\r\n                                };\r\n                            });\r\n\r\n                        };\r\n\r\n                        $scope.resetElements();\r\n\r\n                        $scope.getSortableOptions = function (type) {\r\n                            var editorId = $element.closest(\".layout-editor\").attr(\"id\");\r\n                            var parentClasses;\r\n                            var placeholderClasses;\r\n                            var floating = false;\r\n\r\n                            switch (type) {\r\n                                case \"Grid\":\r\n                                    parentClasses = [\".layout-canvas\", \".layout-column\", \".layout-common-holder\"];\r\n                                    placeholderClasses = \"layout-element layout-container layout-grid ui-sortable-placeholder\";\r\n                                    break;\r\n                                case \"Row\":\r\n                                    parentClasses = [\".layout-grid\"];\r\n                                    placeholderClasses = \"layout-element layout-container layout-row row ui-sortable-placeholder\";\r\n                                    break;\r\n                                case \"Column\":\r\n                                    parentClasses = [\".layout-row:not(.layout-row-full)\"];\r\n                                    placeholderClasses = \"layout-element layout-container layout-column ui-sortable-placeholder\";\r\n                                    floating = true; // To ensure a smooth horizontal-list reordering. https://github.com/angular-ui/ui-sortable#floating\r\n                                    break;\r\n                                case \"Content\":\r\n                                    parentClasses = [\".layout-canvas\", \".layout-column\", \".layout-common-holder\"];\r\n                                    placeholderClasses = \"layout-element layout-content ui-sortable-placeholder\";\r\n                                    break;\r\n                                case \"Canvas\":\r\n                                    parentClasses = [\".layout-canvas\", \".layout-column\", \".layout-common-holder\"];\r\n                                    placeholderClasses = \"layout-element layout-container layout-grid ui-sortable-placeholder\";\r\n                                    break;\r\n                            }\r\n\r\n                            return {\r\n                                cursor: \"move\",\r\n                                connectWith: _(parentClasses).map(function (e) { return \"#\" + editorId + \" \" + e + \":not(.layout-container-sealed) > .layout-element-wrapper > .layout-children\"; }).join(\", \"),\r\n                                placeholder: placeholderClasses,\r\n                                \"ui-floating\": floating,\r\n                                create: function (e, ui) {\r\n                                    e.target.isToolbox = true; // Will indicate to connected sortables that dropped items were sent from toolbox.\r\n                                },\r\n                                start: function (e, ui) {\r\n                                    $scope.$apply(function () {\r\n                                        $scope.element.isDragging = true;\r\n                                    });\r\n                                },\r\n                                stop: function (e, ui) {\r\n                                    $scope.$apply(function () {\r\n                                        $scope.element.isDragging = false;\r\n                                        $scope.resetElements();\r\n                                    });\r\n                                },\r\n                                over: function (e, ui) {\r\n                                    $scope.$apply(function () {\r\n                                        $scope.element.canvas.setIsDropTarget(false);\r\n                                    });\r\n                                },\r\n                            }\r\n                        };\r\n\r\n                        var layoutIsCollapsedCookieName = \"layoutToolboxCategory_Layout_IsCollapsed\";\r\n                        $scope.layoutIsCollapsed = $.cookie(layoutIsCollapsedCookieName) === \"true\";\r\n\r\n                        $scope.toggleLayoutIsCollapsed = function (e) {\r\n                            $scope.layoutIsCollapsed = !$scope.layoutIsCollapsed;\r\n                            $.cookie(layoutIsCollapsedCookieName, $scope.layoutIsCollapsed, { expires: 365 }); // Remember collapsed state for a year.\r\n                            e.preventDefault();\r\n                            e.stopPropagation();\r\n                        };\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Toolbox\"),\r\n                replace: true,\r\n                link: function (scope, element) {\r\n                    var toolbox = element.find(\".layout-toolbox\");\r\n                    $(window).on(\"resize scroll\", function (e) {\r\n                        var canvas = element.parent().find(\".layout-canvas\");\r\n                        // If the canvas is taller than the toolbox, make the toolbox sticky-positioned within the editor\r\n                        // to help the user avoid excessive vertical scrolling.\r\n                        var canvasIsTaller = !!canvas && canvas.height() > toolbox.height();\r\n                        var windowPos = $(window).scrollTop();\r\n                        if (canvasIsTaller && windowPos > element.offset().top + element.height() - toolbox.height()) {\r\n                            toolbox.addClass(\"sticky-bottom\");\r\n                            toolbox.removeClass(\"sticky-top\");\r\n                        }\r\n                        else if (canvasIsTaller && windowPos > element.offset().top) {\r\n                            toolbox.addClass(\"sticky-top\");\r\n                            toolbox.removeClass(\"sticky-bottom\");\r\n                        }\r\n                        else {\r\n                            toolbox.removeClass(\"sticky-top\");\r\n                            toolbox.removeClass(\"sticky-bottom\");\r\n                        }\r\n                    });\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutToolboxGroup\", [\"$compile\", \"environment\",\r\n        function ($compile, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { category: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        var isCollapsedCookieName = \"layoutToolboxCategory_\" + $scope.category.name + \"_IsCollapsed\";\r\n                        $scope.isCollapsed = $.cookie(isCollapsedCookieName) === \"true\";\r\n                        $scope.toggleIsCollapsed = function (e) {\r\n                            $scope.isCollapsed = !$scope.isCollapsed;\r\n                            $.cookie(isCollapsedCookieName, $scope.isCollapsed, { expires: 365 }); // Remember collapsed state for a year.\r\n                            e.preventDefault();\r\n                            e.stopPropagation();\r\n                        };\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"ToolboxGroup\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);"],"sourceRoot":"/source/"} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["LayoutEditor.js","Module.js","Clipboard.js","ScopeConfigurator.js","Editor.js","Canvas.js","Child.js","Column.js","Content.js","Grid.js","Row.js","Popup.js","Toolbox.js","ToolboxGroup.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA,ACLA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AClVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACzIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC9MA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"LayoutEditor.js","sourcesContent":[null,"angular.module(\"LayoutEditor\", [\"ngSanitize\", \"ngResource\", \"ui.sortable\"]);","var LayoutEditor;\r\n(function(LayoutEditor) {\r\n\r\n    var Clipboard = function () {\r\n        var self = this;\r\n        this._clipboardData = {};\r\n        this._isDisabled = false;\r\n        this._wasInvoked = false;\r\n\r\n        this.setData = function(contentType, data) {\r\n            self._clipboardData[contentType] = data;\r\n            self._wasInvoked = true;\r\n        };\r\n        this.getData = function (contentType) {\r\n            return self._clipboardData[contentType];\r\n            self._wasInvoked = true;\r\n        };\r\n        this.disable = function() {\r\n            self._isDisabled = true;\r\n            self._wasInvoked = false;\r\n            self._clipboardData = {};\r\n        };\r\n        this.isDisabled = function () {\r\n            return self._isDisabled;\r\n        }\r\n        this.wasInvoked = function () {\r\n            return self._wasInvoked;\r\n        }\r\n    }\r\n\r\n    LayoutEditor.Clipboard = new Clipboard();\r\n\r\n    angular\r\n        .module(\"LayoutEditor\")\r\n        .factory(\"clipboard\", [\r\n            function() {\r\n                return {\r\n                    setData: LayoutEditor.Clipboard.setData,\r\n                    getData: LayoutEditor.Clipboard.getData,\r\n                    disable: LayoutEditor.Clipboard.disable,\r\n                    isDisabled: LayoutEditor.Clipboard.isDisabled,\r\n                    wasInvoked: LayoutEditor.Clipboard.wasInvoked\r\n                };\r\n            }\r\n        ]);\r\n})(LayoutEditor || (LayoutEditor = {}));","angular\r\n    .module(\"LayoutEditor\")\r\n    .factory(\"scopeConfigurator\", [\"$timeout\", \"clipboard\",\r\n        function ($timeout, clipboard) {\r\n            return {\r\n\r\n                configureForElement: function ($scope, $element) {\r\n                \r\n                    $element.find(\".layout-panel\").click(function (e) {\r\n                        e.stopPropagation();\r\n                    });\r\n\r\n                    $element.parent().keydown(function (e) {\r\n                        var handled = false;\r\n                        var resetFocus = false;\r\n                        var element = $scope.element;\r\n                    \r\n                        if (element.editor.isDragging)\r\n                            return;\r\n\r\n                        // If native clipboard support exists, the pseudo-clipboard will have been disabled.\r\n                        if (!clipboard.isDisabled()) {\r\n                            var focusedElement = element.editor.focusedElement;\r\n                            if (!!focusedElement) {\r\n                                // Pseudo clipboard handling for browsers not allowing real clipboard operations.\r\n                                if (e.ctrlKey) {\r\n                                    switch (e.which) {\r\n                                    case 67: // C\r\n                                        focusedElement.copy(clipboard);\r\n                                        break;\r\n                                    case 88: // X\r\n                                        focusedElement.cut(clipboard);\r\n                                        break;\r\n                                    case 86: // V\r\n                                        focusedElement.paste(clipboard);\r\n                                        break;\r\n                                    }\r\n                                }\r\n                            }\r\n                        }\r\n\r\n                        if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 46) { // Del\r\n                            $scope.delete(element);\r\n                            handled = true;\r\n                        } else if (!e.ctrlKey && !e.shiftKey && !e.altKey && (e.which == 32 || e.which == 27)) { // Space or Esc\r\n                            $element.find(\".layout-panel-action-properties\").first().click();\r\n                            handled = true;\r\n                        }\r\n\r\n                        if (element.type == \"Content\") { // This is a content element.\r\n                            if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 13) { // Enter\r\n                                $element.find(\".layout-panel-action-edit\").first().click();\r\n                                handled = true;\r\n                            }\r\n                        }\r\n\r\n                        if (!!element.children) { // This is a container.\r\n                            if (!e.ctrlKey && !e.shiftKey && e.altKey && e.which == 40) { // Alt+Down\r\n                                if (element.children.length > 0)\r\n                                    element.children[0].setIsFocused();\r\n                                handled = true;\r\n                            }\r\n\r\n                            if (element.type == \"Column\") { // This is a column.\r\n                                var connectAdjacent = !e.ctrlKey;\r\n                                if (e.which == 37) { // Left\r\n                                    if (e.altKey)\r\n                                        element.expandLeft(connectAdjacent);\r\n                                    if (e.shiftKey)\r\n                                        element.contractRight(connectAdjacent);\r\n                                    handled = true;\r\n                                } else if (e.which == 39) { // Right\r\n                                    if (e.altKey)\r\n                                        element.contractLeft(connectAdjacent);\r\n                                    if (e.shiftKey)\r\n                                        element.expandRight(connectAdjacent);\r\n                                    handled = true;\r\n                                }\r\n                            }\r\n                        }\r\n\r\n                        if (!!element.parent) { // This is a child.\r\n                            if (e.altKey && e.which == 38) { // Alt+Up\r\n                                element.parent.setIsFocused();\r\n                                handled = true;\r\n                            }\r\n\r\n                            if (element.parent.type == \"Row\") { // Parent is a horizontal container.\r\n                                if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 37) { // Left\r\n                                    element.parent.moveFocusPrevChild(element);\r\n                                    handled = true;\r\n                                }\r\n                                else if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 39) { // Right\r\n                                    element.parent.moveFocusNextChild(element);\r\n                                    handled = true;\r\n                                }\r\n                                else if (e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 37) { // Ctrl+Left\r\n                                    element.moveUp();\r\n                                    resetFocus = true;\r\n                                    handled = true;\r\n                                }\r\n                                else if (e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 39) { // Ctrl+Right\r\n                                    element.moveDown();\r\n                                    handled = true;\r\n                                }\r\n                            }\r\n                            else { // Parent is a vertical container.\r\n                                if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 38) { // Up\r\n                                    element.parent.moveFocusPrevChild(element);\r\n                                    handled = true;\r\n                                }\r\n                                else if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 40) { // Down\r\n                                    element.parent.moveFocusNextChild(element);\r\n                                    handled = true;\r\n                                }\r\n                                else if (e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 38) { // Ctrl+Up\r\n                                    element.moveUp();\r\n                                    resetFocus = true;\r\n                                    handled = true;\r\n                                }\r\n                                else if (e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 40) { // Ctrl+Down\r\n                                    element.moveDown();\r\n                                    handled = true;\r\n                                }\r\n                            }\r\n                        }\r\n\r\n                        if (handled) {\r\n                            e.preventDefault();\r\n                        }\r\n\r\n                        e.stopPropagation();\r\n\r\n                        $scope.$apply(); // Event is not triggered by Angular directive but raw event handler on element.\r\n\r\n                        // HACK: Workaround because of how Angular treats the DOM when elements are shifted around - input focus is sometimes lost.\r\n                        if (resetFocus) {\r\n                            window.setTimeout(function () {\r\n                                $scope.$apply(function () {\r\n                                    element.editor.focusedElement.setIsFocused();\r\n                                });\r\n                            }, 100);\r\n                        }\r\n                    });\r\n\r\n                    $scope.element.setIsFocusedEventHandlers.push(function () {\r\n                        $element.parent().focus();\r\n                    });\r\n\r\n                    $scope.delete = function (element) {\r\n                        element.delete();\r\n                    }\r\n\r\n                    if ($scope.element.hasEditor) {\r\n                        $scope.edit = function () {\r\n                            $scope.$root.editElement($scope.element).then(function (args) {\r\n                                $scope.$apply(function () {\r\n                                    if (args.cancel)\r\n                                        return;\r\n\r\n                                    $scope.element.data = args.element.data;\r\n                                    $scope.element.applyElementEditorModel(args.elementEditorModel);\r\n\r\n                                    if (!!$scope.element.setHtml)\r\n                                        $scope.element.setHtml(args.element.html);\r\n                                });\r\n                            });\r\n                        };\r\n                    }\r\n                },\r\n\r\n                configureForContainer: function ($scope, $element) {\r\n                    var element = $scope.element;\r\n\r\n                    //$scope.isReceiving = false; // True when container is receiving an external element via drag/drop.\r\n                    $scope.getShowChildrenPlaceholder = function () {\r\n                        return $scope.element.children.length === 0 && !$scope.element.getIsDropTarget();\r\n                    };\r\n\r\n                    $scope.sortableOptions = {\r\n                        cursor: \"move\",\r\n                        delay: 150,\r\n                        disabled: element.getIsSealed(),\r\n                        distance: 5,\r\n                        //handle: element.children.length < 2 ? \".imaginary-class\" : false, // For some reason doesn't get re-evaluated after adding more children.\r\n                        start: function (e, ui) {\r\n                            $scope.$apply(function () {\r\n                                element.setIsDropTarget(true);\r\n                                element.editor.isDragging = true;\r\n                            });\r\n                            // Make the drop target placeholder as high as the item being dragged.\r\n                            ui.placeholder.height(ui.item.height() - 4);\r\n                            ui.placeholder.css(\"min-height\", 0);\r\n                        },\r\n                        stop: function (e, ui) {\r\n                            $scope.$apply(function () {\r\n                                element.editor.isDragging = false;\r\n                                element.setIsDropTarget(false);\r\n                            });\r\n                        },\r\n                        over: function (e, ui) {\r\n                            if (!!ui.sender && !!ui.sender[0].isToolbox) {\r\n                                if (!!ui.sender[0].dropTargetTimeout) {\r\n                                    $timeout.cancel(ui.sender[0].dropTargetTimeout);\r\n                                    ui.sender[0].dropTargetTimeout = null;\r\n                                }\r\n                                $timeout(function () {\r\n                                    if (element.type == \"Row\") {\r\n                                        // If there was a previous drop target and it was a row, roll back any pending column adds to it.\r\n                                        var previousDropTarget = element.editor.dropTargetElement;\r\n                                        if (!!previousDropTarget && previousDropTarget.type == \"Row\")\r\n                                            previousDropTarget.rollbackAddColumn();\r\n                                    }\r\n                                    element.setIsDropTarget(false);\r\n                                });\r\n                                ui.sender[0].dropTargetTimeout = $timeout(function () {\r\n                                    if (element.type == \"Row\") {\r\n                                        var receivedColumn = ui.item.sortable.model;\r\n                                        var receivedColumnWidth = Math.floor(12 / (element.children.length + 1));\r\n                                        receivedColumn.width = receivedColumnWidth;\r\n                                        receivedColumn.offset = 0;\r\n                                        element.beginAddColumn(receivedColumnWidth);\r\n                                        // Make the drop target placeholder the correct width and as high as the highest existing column in the row.\r\n                                        var maxHeight = _.max(_($element.find(\"> .layout-children > .layout-column:not(.ui-sortable-placeholder)\")).map(function (e) {\r\n                                            return $(e).height();\r\n                                        }));\r\n                                        for (i = 1; i <= 12; i++)\r\n                                            ui.placeholder.removeClass(\"col-xs-\" + i);\r\n                                        ui.placeholder.addClass(\"col-xs-\" + receivedColumn.width);\r\n                                        if (maxHeight > 0) {\r\n                                            ui.placeholder.height(maxHeight);\r\n                                            ui.placeholder.css(\"min-height\", 0);\r\n                                        }\r\n                                        else {\r\n                                            ui.placeholder.height(0);\r\n                                            ui.placeholder.css(\"min-height\", \"\");\r\n                                        }\r\n                                    }\r\n                                    element.setIsDropTarget(true);\r\n                                }, 150);\r\n                            }\r\n                        },\r\n                        receive: function (e, ui) {\r\n                            if (!!ui.sender && !!ui.sender[0].isToolbox) {\r\n                                $scope.$apply(function () {\r\n                                    var receivedElement = ui.item.sortable.model;\r\n                                    if (!!receivedElement) {\r\n                                        if (element.type == \"Row\")\r\n                                            element.commitAddColumn();\r\n                                        // Should ideally call LayoutEditor.Container.addChild() instead, but since this handler\r\n                                        // is run *before* the ui-sortable directive's handler, if we try to add the child to the\r\n                                        // array that handler will get an exception when trying to do the same.\r\n                                        // Because of this, we need to invoke \"setParent\" so that specific container types can perform element speficic initialization.\r\n                                        receivedElement.setEditor(element.editor);\r\n                                        receivedElement.setParent(element);\r\n\r\n                                        if (!!receivedElement.hasEditor) {\r\n                                            $scope.$root.editElement(receivedElement).then(function (args) {\r\n                                                if (!args.cancel) {\r\n                                                    receivedElement.data = args.element.data;\r\n                                                    receivedElement.applyElementEditorModel(args.elementEditorModel);\r\n\r\n                                                    if (!!receivedElement.setHtml)\r\n                                                        receivedElement.setHtml(args.element.html);\r\n                                                }\r\n                                                $timeout(function () {\r\n                                                    if (!!args.cancel)\r\n                                                        receivedElement.delete();\r\n                                                    else\r\n                                                        receivedElement.setIsFocused();\r\n                                                    //$scope.isReceiving = false;\r\n                                                    element.setIsDropTarget(false);\r\n\r\n                                                });\r\n                                                return;\r\n                                            });\r\n                                        }\r\n                                    }\r\n                                    $timeout(function () {\r\n                                        //$scope.isReceiving = false;\r\n                                        element.setIsDropTarget(false);\r\n                                        if (!!receivedElement)\r\n                                            receivedElement.setIsFocused();\r\n                                    });\r\n                                });\r\n                            }\r\n                        }\r\n                    };\r\n\r\n                    $scope.click = function (child, e) {\r\n                        if (!child.editor.isDragging)\r\n                            child.setIsFocused();\r\n                        e.stopPropagation();\r\n                    };\r\n\r\n                    $scope.getClasses = function (child) {\r\n                        var result = [\"layout-element\"];\r\n\r\n                        if (!!child.children) {\r\n                            result.push(\"layout-container\");\r\n                            if (child.getIsSealed())\r\n                                result.push(\"layout-container-sealed\");\r\n                        }\r\n\r\n                        result.push(\"layout-\" + child.type.toLowerCase());\r\n\r\n                        if (!!child.dropTargetClass)\r\n                            result.push(child.dropTargetClass);\r\n\r\n                        // TODO: Move these to either the Column directive or the Column model class.\r\n                        if (child.type == \"Row\") {\r\n                            result.push(\"row\");\r\n                            if (!child.canAddColumn())\r\n                                result.push(\"layout-row-full\");\r\n                        }\r\n                        if (child.type == \"Column\") {\r\n                            result.push(\"col-xs-\" + child.width);\r\n                            result.push(\"col-xs-offset-\" + child.offset);\r\n                        }\r\n                        if (child.type == \"Content\")\r\n                            result.push(\"layout-content-\" + child.contentTypeClass);\r\n\r\n                        if (child.getIsActive())\r\n                            result.push(\"layout-element-active\");\r\n                        if (child.getIsFocused())\r\n                            result.push(\"layout-element-focused\");\r\n                        if (child.getIsSelected())\r\n                            result.push(\"layout-element-selected\");\r\n                        if (child.getIsDropTarget())\r\n                            result.push(\"layout-element-droptarget\");\r\n                        if (child.isTemplated)\r\n                            result.push(\"layout-element-templated\");\r\n\r\n                        return result;\r\n                    };\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutEditor\", [\"environment\",\r\n        function (environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: {},\r\n                controller: [\"$scope\", \"$element\", \"$attrs\", \"$compile\", \"clipboard\",\r\n                    function ($scope, $element, $attrs, $compile, clipboard) {\r\n                        if (!!$attrs.model)\r\n                            $scope.element = eval($attrs.model);\r\n                        else\r\n                            throw new Error(\"The 'model' attribute must evaluate to a LayoutEditor.Editor object.\");\r\n\r\n                        $scope.click = function (canvas, e) {\r\n                            if (!canvas.editor.isDragging)\r\n                                canvas.setIsFocused();\r\n                            e.stopPropagation();\r\n                        };\r\n\r\n                        $scope.getClasses = function (canvas) {\r\n                            var result = [\"layout-element\", \"layout-container\", \"layout-canvas\"];\r\n\r\n                            if (canvas.getIsActive())\r\n                                result.push(\"layout-element-active\");\r\n                            if (canvas.getIsFocused())\r\n                                result.push(\"layout-element-focused\");\r\n                            if (canvas.getIsSelected())\r\n                                result.push(\"layout-element-selected\");\r\n                            if (canvas.getIsDropTarget())\r\n                                result.push(\"layout-element-droptarget\");\r\n                            if (canvas.isTemplated)\r\n                                result.push(\"layout-element-templated\");\r\n\r\n                            return result;\r\n                        };\r\n\r\n                        // An unfortunate side-effect of the next hack on line 54 is that the created elements aren't added to the DOM yet, so we can't use it to get to the parent \".layout-desiger\" element.\r\n                        // Work around: access that element directly (which efectively turns multiple layout editors on a single page impossible). \r\n                        // //var layoutDesignerHost = $element.closest(\".layout-designer\").data(\"layout-designer-host\");\r\n                        var layoutDesignerHost = $(\".layout-designer\").data(\"layout-designer-host\");\r\n\r\n                        $scope.$root.layoutDesignerHost = layoutDesignerHost;\r\n\r\n                        layoutDesignerHost.element.on(\"replacecanvas\", function (e, args) {\r\n                            var editor = $scope.element;\r\n                            var canvasData = {\r\n                                data: args.canvas.data,\r\n                                htmlId: args.canvas.htmlId,\r\n                                htmlClass: args.canvas.htmlClass,\r\n                                htmlStyle: args.canvas.htmlStyle,\r\n                                isTemplated: args.canvas.isTemplated,\r\n                                children: args.canvas.children\r\n                            };\r\n\r\n                            // HACK: Instead of simply updating the $scope.element with a new instance, we need to replace the entire orc-layout-editor markup\r\n                            // in order for angular to rebind starting with the Canvas element. Otherwise, for some reason, it will rebind starting with the first child of Canvas.\r\n                            // You can see this happening when setting a breakpoint in ScopeConfigurator where containers are initialized with drag & drop: on page load, the first element\r\n                            // is a Canvas (good), but after having selected another template, the first element is (typically) a Grid (bad).\r\n                            // Simply recompiling the orc-layout-editor directive will cause the entire thing to be generated, which works just fine as well (even though not is nice as simply leveraging model binding).\r\n                            layoutDesignerHost.editor = window.layoutEditor = new LayoutEditor.Editor(editor.config, canvasData);\r\n                            var template = \"<orc-layout-editor\" + \" model='window.layoutEditor' />\";\r\n                            var html = $compile(template)($scope);\r\n                            $(\".layout-editor-holder\").html(html);\r\n                        });\r\n\r\n                        $scope.$root.editElement = function (element) {\r\n                            var host = $scope.$root.layoutDesignerHost;\r\n                            return host.editElement(element);\r\n                        };\r\n\r\n                        $scope.$root.addElement = function (contentType) {\r\n                            var host = $scope.$root.layoutDesignerHost;\r\n                            return host.addElement(contentType);\r\n                        };\r\n\r\n                        $(document).on(\"cut copy paste\", function (e) {\r\n                            // If the pseudo clipboard was already invoked (which happens on the first clipboard\r\n                            // operation after page load even if native clipboard support exists) then sit this\r\n                            // one operation out, but make sure whatever is on the pseudo clipboard gets migrated\r\n                            // to the native clipboard for subsequent operations.\r\n                            if (clipboard.wasInvoked()) {\r\n                                e.originalEvent.clipboardData.setData(\"text/plain\", clipboard.getData(\"text/plain\"));\r\n                                e.originalEvent.clipboardData.setData(\"text/json\", clipboard.getData(\"text/json\"));\r\n                                e.preventDefault();\r\n                            }\r\n                            else {\r\n                                var focusedElement = $scope.element.focusedElement;\r\n                                if (!!focusedElement) {\r\n                                    $scope.$apply(function () {\r\n                                        switch (e.type) {\r\n                                            case \"copy\":\r\n                                                focusedElement.copy(e.originalEvent.clipboardData);\r\n                                                break;\r\n                                            case \"cut\":\r\n                                                focusedElement.cut(e.originalEvent.clipboardData);\r\n                                                break;\r\n                                            case \"paste\":\r\n                                                focusedElement.paste(e.originalEvent.clipboardData);\r\n                                                break;\r\n                                        }\r\n                                    });\r\n\r\n                                    // HACK: Workaround because of how Angular treats the DOM when elements are shifted around - input focus is sometimes lost.\r\n                                    window.setTimeout(function () {\r\n                                        $scope.$apply(function () {\r\n                                            if (!!$scope.element.focusedElement)\r\n                                                $scope.element.focusedElement.setIsFocused();\r\n                                        });\r\n                                    }, 100);\r\n\r\n                                    e.preventDefault();\r\n                                }\r\n                            }\r\n\r\n                            // Native clipboard support obviously exists, so disable the peudo clipboard from now on.\r\n                            clipboard.disable();\r\n                        });\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Editor\"),\r\n                replace: true,\r\n                link: function (scope, element) {\r\n                    // No clicks should propagate from the TinyMCE toolbars.\r\n                    element.find(\".layout-toolbar-container\").click(function (e) {\r\n                        e.stopPropagation();\r\n                    });\r\n                    // Unfocus and unselect everything on click outside of canvas.\r\n                    $(window).click(function (e) {\r\n                        scope.$apply(function () {\r\n                            scope.element.activeElement = null;\r\n                            scope.element.focusedElement = null;\r\n                        });\r\n                    });\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutCanvas\", [\"scopeConfigurator\", \"environment\",\r\n        function (scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\", \"$attrs\",\r\n                    function ($scope, $element, $attrs) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        scopeConfigurator.configureForContainer($scope, $element);\r\n                        $scope.sortableOptions[\"axis\"] = \"y\";\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Canvas\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutChild\", [\"$compile\",\r\n        function ($compile) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                link: function (scope, element) {\r\n                    var template = \"<orc-layout-\" + scope.element.type.toLowerCase() + \" element='element' />\";\r\n                    var html = $compile(template)(scope);\r\n                    $(element).replaceWith(html);\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutColumn\", [\"$compile\", \"scopeConfigurator\", \"environment\",\r\n        function ($compile, scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        scopeConfigurator.configureForContainer($scope, $element);\r\n                        $scope.sortableOptions[\"axis\"] = \"y\";\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Column\"),\r\n                replace: true,\r\n                link: function (scope, element, attrs) {\r\n                    element.find(\".layout-column-resize-bar\").draggable({\r\n                        axis: \"x\",\r\n                        helper: \"clone\",\r\n                        revert: true,\r\n                        start: function (e, ui) {\r\n                            scope.$apply(function () {\r\n                                scope.element.editor.isResizing = true;\r\n                            });\r\n                        },\r\n                        drag: function (e, ui) {\r\n                            var columnElement = element.parent();\r\n                            var columnSize = columnElement.width() / scope.element.width;\r\n                            var connectAdjacent = !e.ctrlKey;\r\n                            if ($(e.target).hasClass(\"layout-column-resize-bar-left\")) {\r\n                                var delta = ui.offset.left - columnElement.offset().left;\r\n                                if (delta < -columnSize && scope.element.canExpandLeft(connectAdjacent)) {\r\n                                    scope.$apply(function () {\r\n                                        scope.element.expandLeft(connectAdjacent);\r\n                                    });\r\n                                }\r\n                                else if (delta > columnSize && scope.element.canContractLeft(connectAdjacent)) {\r\n                                    scope.$apply(function () {\r\n                                        scope.element.contractLeft(connectAdjacent);\r\n                                    });\r\n                                }\r\n                            }\r\n                            else if ($(e.target).hasClass(\"layout-column-resize-bar-right\")) {\r\n                                var delta = ui.offset.left - columnElement.width() - columnElement.offset().left;\r\n                                if (delta > columnSize && scope.element.canExpandRight(connectAdjacent)) {\r\n                                    scope.$apply(function () {\r\n                                        scope.element.expandRight(connectAdjacent);\r\n                                    });\r\n                                }\r\n                                else if (delta < -columnSize && scope.element.canContractRight(connectAdjacent)) {\r\n                                    scope.$apply(function () {\r\n                                        scope.element.contractRight(connectAdjacent);\r\n                                    });\r\n                                }\r\n                            }\r\n\r\n                        },\r\n                        stop: function (e, ui) {\r\n                            scope.$apply(function () {\r\n                              scope.element.editor.isResizing = false;\r\n                            });\r\n                        }\r\n                    });\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutContent\", [\"$sce\", \"scopeConfigurator\", \"environment\",\r\n        function ($sce, scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        \r\n                        // Overwrite the setHtml function so that we can use the $sce service to trust the html (and not have the html binding strip certain tags).\r\n                        $scope.element.setHtml = function (html) {\r\n                            $scope.element.html = html;\r\n                            $scope.element.htmlUnsafe = $sce.trustAsHtml(html);\r\n                        };\r\n\r\n                        $scope.element.setHtml($scope.element.html);\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Content\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutGrid\", [\"$compile\", \"scopeConfigurator\", \"environment\",\r\n        function ($compile, scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        scopeConfigurator.configureForContainer($scope, $element);\r\n                        $scope.sortableOptions[\"axis\"] = \"y\";\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Grid\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutRow\", [\"$compile\", \"scopeConfigurator\", \"environment\",\r\n        function ($compile, scopeConfigurator, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { element: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        scopeConfigurator.configureForElement($scope, $element);\r\n                        scopeConfigurator.configureForContainer($scope, $element);\r\n                        $scope.sortableOptions[\"axis\"] = \"x\";\r\n                        $scope.sortableOptions[\"ui-floating\"] = true;\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Row\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutPopup\", [\r\n        function () {\r\n            return {\r\n                restrict: \"A\",\r\n                link: function (scope, element, attrs) {\r\n                    var popup = $(element);\r\n                    var trigger = popup.closest(\".layout-popup-trigger\");\r\n                    var parentElement = popup.closest(\".layout-element\");\r\n                    trigger.click(function () {\r\n                        popup.toggle();\r\n                        if (popup.is(\":visible\")) {\r\n                            popup.position({\r\n                                my: attrs.orcLayoutPopupMy || \"left top\",\r\n                                at: attrs.orcLayoutPopupAt || \"left bottom+4px\",\r\n                                of: trigger\r\n                            });\r\n                            popup.find(\"input\").first().focus();\r\n                        }\r\n                    });\r\n                    popup.click(function (e) {\r\n                        e.stopPropagation();\r\n                    });\r\n                    parentElement.click(function (e) {\r\n                        popup.hide();\r\n                    });\r\n                    popup.keydown(function (e) {\r\n                        if (!e.ctrlKey && !e.shiftKey && !e.altKey && e.which == 27) // Esc\r\n                            popup.hide();\r\n                        e.stopPropagation();\r\n                    });\r\n                    popup.on(\"cut copy paste\", function (e) {\r\n                        // Allow clipboard operations in popup without invoking clipboard event handlers on parent element.\r\n                        e.stopPropagation();\r\n                    });\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutToolbox\", [\"$compile\", \"environment\",\r\n        function ($compile, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n\r\n                        $scope.resetElements = function () {\r\n\r\n                            $scope.gridElements = [\r\n                                LayoutEditor.Grid.from({\r\n                                    toolboxIcon: \"\\uf00a\",\r\n                                    toolboxLabel: \"Grid\",\r\n                                    toolboxDescription: \"Empty grid.\",\r\n                                    children: []\r\n                                })\r\n                            ];\r\n\r\n                            $scope.rowElements = [\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (1 column)\",\r\n                                    toolboxDescription: \"Row with 1 column.\",\r\n                                    children: LayoutEditor.Column.times(1)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (2 columns)\",\r\n                                    toolboxDescription: \"Row with 2 columns.\",\r\n                                    children: LayoutEditor.Column.times(2)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (3 columns)\",\r\n                                    toolboxDescription: \"Row with 3 columns.\",\r\n                                    children: LayoutEditor.Column.times(3)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (4 columns)\",\r\n                                    toolboxDescription: \"Row with 4 columns.\",\r\n                                    children: LayoutEditor.Column.times(4)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (6 columns)\",\r\n                                    toolboxDescription: \"Row with 6 columns.\",\r\n                                    children: LayoutEditor.Column.times(6)\r\n                                }),\r\n                                LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (12 columns)\",\r\n                                    toolboxDescription: \"Row with 12 columns.\",\r\n                                    children: LayoutEditor.Column.times(12)\r\n                                }), LayoutEditor.Row.from({\r\n                                    toolboxIcon: \"\\uf0c9\",\r\n                                    toolboxLabel: \"Row (empty)\",\r\n                                    toolboxDescription: \"Empty row.\",\r\n                                    children: []\r\n                                })\r\n                            ];\r\n\r\n                            $scope.columnElements = [\r\n                                LayoutEditor.Column.from({\r\n                                    toolboxIcon: \"\\uf0db\",\r\n                                    toolboxLabel: \"Column\",\r\n                                    toolboxDescription: \"Empty column.\",\r\n                                    width: 1,\r\n                                    offset: 0,\r\n                                    children: []\r\n                                })\r\n                            ];\r\n\r\n                            $scope.canvasElements = [\r\n                                LayoutEditor.Canvas.from({\r\n                                    toolboxIcon: \"\\uf044\",\r\n                                    toolboxLabel: \"Canvas\",\r\n                                    toolboxDescription: \"Empty canvas.\",\r\n                                    children: []\r\n                                })\r\n                            ];\r\n\r\n                            $scope.contentElementCategories = _($scope.element.config.categories).map(function (category) {\r\n                                return {\r\n                                    name: category.name,\r\n                                    elements: _(category.contentTypes).map(function (contentType) {\r\n                                        var type = contentType.type;\r\n                                        var factory = LayoutEditor.factories[type] || LayoutEditor.factories[\"Content\"];\r\n                                        var item = {\r\n                                            isTemplated: false,\r\n                                            contentType: contentType.id,\r\n                                            contentTypeLabel: contentType.label,\r\n                                            contentTypeClass: contentType.typeClass,\r\n                                            data: null,\r\n                                            hasEditor: contentType.hasEditor,\r\n                                            html: contentType.html\r\n                                        };\r\n                                        var element = factory(item);\r\n                                        element.toolboxIcon = contentType.icon || \"\\uf1c9\";\r\n                                        element.toolboxLabel = contentType.label;\r\n                                        element.toolboxDescription = contentType.description;\r\n                                        return element;\r\n                                    })\r\n                                };\r\n                            });\r\n\r\n                        };\r\n\r\n                        $scope.resetElements();\r\n\r\n                        $scope.getSortableOptions = function (type) {\r\n                            var editorId = $element.closest(\".layout-editor\").attr(\"id\");\r\n                            var parentClasses;\r\n                            var placeholderClasses;\r\n                            var floating = false;\r\n\r\n                            switch (type) {\r\n                                case \"Grid\":\r\n                                    parentClasses = [\".layout-canvas\", \".layout-column\", \".layout-common-holder\"];\r\n                                    placeholderClasses = \"layout-element layout-container layout-grid ui-sortable-placeholder\";\r\n                                    break;\r\n                                case \"Row\":\r\n                                    parentClasses = [\".layout-grid\"];\r\n                                    placeholderClasses = \"layout-element layout-container layout-row row ui-sortable-placeholder\";\r\n                                    break;\r\n                                case \"Column\":\r\n                                    parentClasses = [\".layout-row:not(.layout-row-full)\"];\r\n                                    placeholderClasses = \"layout-element layout-container layout-column ui-sortable-placeholder\";\r\n                                    floating = true; // To ensure a smooth horizontal-list reordering. https://github.com/angular-ui/ui-sortable#floating\r\n                                    break;\r\n                                case \"Content\":\r\n                                    parentClasses = [\".layout-canvas\", \".layout-column\", \".layout-common-holder\"];\r\n                                    placeholderClasses = \"layout-element layout-content ui-sortable-placeholder\";\r\n                                    break;\r\n                                case \"Canvas\":\r\n                                    parentClasses = [\".layout-canvas\", \".layout-column\", \".layout-common-holder\"];\r\n                                    placeholderClasses = \"layout-element layout-container layout-grid ui-sortable-placeholder\";\r\n                                    break;\r\n                            }\r\n\r\n                            return {\r\n                                cursor: \"move\",\r\n                                connectWith: _(parentClasses).map(function (e) { return \"#\" + editorId + \" \" + e + \":not(.layout-container-sealed) > .layout-element-wrapper > .layout-children\"; }).join(\", \"),\r\n                                placeholder: placeholderClasses,\r\n                                \"ui-floating\": floating,\r\n                                create: function (e, ui) {\r\n                                    e.target.isToolbox = true; // Will indicate to connected sortables that dropped items were sent from toolbox.\r\n                                },\r\n                                start: function (e, ui) {\r\n                                    $scope.$apply(function () {\r\n                                        $scope.element.isDragging = true;\r\n                                    });\r\n                                },\r\n                                stop: function (e, ui) {\r\n                                    $scope.$apply(function () {\r\n                                        $scope.element.isDragging = false;\r\n                                        $scope.resetElements();\r\n                                    });\r\n                                },\r\n                                over: function (e, ui) {\r\n                                    $scope.$apply(function () {\r\n                                        $scope.element.canvas.setIsDropTarget(false);\r\n                                    });\r\n                                },\r\n                            }\r\n                        };\r\n\r\n                        var layoutIsCollapsedCookieName = \"layoutToolboxCategory_Layout_IsCollapsed\";\r\n                        $scope.layoutIsCollapsed = $.cookie(layoutIsCollapsedCookieName) === \"true\";\r\n\r\n                        $scope.toggleLayoutIsCollapsed = function (e) {\r\n                            $scope.layoutIsCollapsed = !$scope.layoutIsCollapsed;\r\n                            $.cookie(layoutIsCollapsedCookieName, $scope.layoutIsCollapsed, { expires: 365 }); // Remember collapsed state for a year.\r\n                            e.preventDefault();\r\n                            e.stopPropagation();\r\n                        };\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"Toolbox\"),\r\n                replace: true,\r\n                link: function (scope, element) {\r\n                    var toolbox = element.find(\".layout-toolbox\");\r\n                    $(window).on(\"resize scroll\", function (e) {\r\n                        var canvas = element.parent().find(\".layout-canvas\");\r\n                        // If the canvas is taller than the toolbox, make the toolbox sticky-positioned within the editor\r\n                        // to help the user avoid excessive vertical scrolling.\r\n                        var canvasIsTaller = !!canvas && canvas.height() > toolbox.height();\r\n                        var windowPos = $(window).scrollTop();\r\n                        if (canvasIsTaller && windowPos > element.offset().top + element.height() - toolbox.height()) {\r\n                            toolbox.addClass(\"sticky-bottom\");\r\n                            toolbox.removeClass(\"sticky-top\");\r\n                        }\r\n                        else if (canvasIsTaller && windowPos > element.offset().top) {\r\n                            toolbox.addClass(\"sticky-top\");\r\n                            toolbox.removeClass(\"sticky-bottom\");\r\n                        }\r\n                        else {\r\n                            toolbox.removeClass(\"sticky-top\");\r\n                            toolbox.removeClass(\"sticky-bottom\");\r\n                        }\r\n                    });\r\n                }\r\n            };\r\n        }\r\n    ]);","angular\r\n    .module(\"LayoutEditor\")\r\n    .directive(\"orcLayoutToolboxGroup\", [\"$compile\", \"environment\",\r\n        function ($compile, environment) {\r\n            return {\r\n                restrict: \"E\",\r\n                scope: { category: \"=\" },\r\n                controller: [\"$scope\", \"$element\",\r\n                    function ($scope, $element) {\r\n                        var isCollapsedCookieName = \"layoutToolboxCategory_\" + $scope.category.name + \"_IsCollapsed\";\r\n                        $scope.isCollapsed = $.cookie(isCollapsedCookieName) === \"true\";\r\n                        $scope.toggleIsCollapsed = function (e) {\r\n                            $scope.isCollapsed = !$scope.isCollapsed;\r\n                            $.cookie(isCollapsedCookieName, $scope.isCollapsed, { expires: 365 }); // Remember collapsed state for a year.\r\n                            e.preventDefault();\r\n                            e.stopPropagation();\r\n                        };\r\n                    }\r\n                ],\r\n                templateUrl: environment.templateUrl(\"ToolboxGroup\"),\r\n                replace: true\r\n            };\r\n        }\r\n    ]);"],"sourceRoot":"/source/"} diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutEditor.min.js b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutEditor.min.js index 51fa7093c..ab6aa3b3f 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutEditor.min.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutEditor.min.js @@ -1 +1 @@ -angular.module("LayoutEditor",["ngSanitize","ngResource","ui.sortable"]);var LayoutEditor;!function(e){var t=function(){var e=this;this._clipboardData={},this._isDisabled=!1,this._wasInvoked=!1,this.setData=function(t,o){e._clipboardData[t]=o,e._wasInvoked=!0},this.getData=function(t){return e._clipboardData[t]},this.disable=function(){e._isDisabled=!0,e._wasInvoked=!1,e._clipboardData={}},this.isDisabled=function(){return e._isDisabled},this.wasInvoked=function(){return e._wasInvoked}};e.Clipboard=new t,angular.module("LayoutEditor").factory("clipboard",[function(){return{setData:e.Clipboard.setData,getData:e.Clipboard.getData,disable:e.Clipboard.disable,isDisabled:e.Clipboard.isDisabled,wasInvoked:e.Clipboard.wasInvoked}}])}(LayoutEditor||(LayoutEditor={})),angular.module("LayoutEditor").factory("scopeConfigurator",["$timeout","clipboard",function(e,t){return{configureForElement:function(e,o){o.find(".layout-panel").click(function(e){e.stopPropagation()}),o.parent().keydown(function(n){var l=!1,a=!1,i=e.element;if(!i.editor.isDragging){if(!t.isDisabled()){var r=i.editor.focusedElement;if(r&&n.ctrlKey)switch(n.which){case 67:r.copy(t);break;case 88:r.cut(t);break;case 86:r.paste(t)}}if(n.ctrlKey||n.shiftKey||n.altKey||46!=n.which?n.ctrlKey||n.shiftKey||n.altKey||32!=n.which&&27!=n.which||(o.find(".layout-panel-action-properties").first().click(),l=!0):(e["delete"](i),l=!0),"Content"==i.type&&(n.ctrlKey||n.shiftKey||n.altKey||13!=n.which||(o.find(".layout-panel-action-edit").first().click(),l=!0)),i.children&&(n.ctrlKey||n.shiftKey||!n.altKey||40!=n.which||(i.children.length>0&&i.children[0].setIsFocused(),l=!0),"Column"==i.type)){var c=!n.ctrlKey;37==n.which?(n.altKey&&i.expandLeft(c),n.shiftKey&&i.contractRight(c),l=!0):39==n.which&&(n.altKey&&i.contractLeft(c),n.shiftKey&&i.expandRight(c),l=!0)}i.parent&&(n.altKey&&38==n.which&&(i.parent.setIsFocused(),l=!0),"Row"==i.parent.type?n.ctrlKey||n.shiftKey||n.altKey||37!=n.which?n.ctrlKey||n.shiftKey||n.altKey||39!=n.which?!n.ctrlKey||n.shiftKey||n.altKey||37!=n.which?!n.ctrlKey||n.shiftKey||n.altKey||39!=n.which||(i.moveDown(),l=!0):(i.moveUp(),a=!0,l=!0):(i.parent.moveFocusNextChild(i),l=!0):(i.parent.moveFocusPrevChild(i),l=!0):n.ctrlKey||n.shiftKey||n.altKey||38!=n.which?n.ctrlKey||n.shiftKey||n.altKey||40!=n.which?!n.ctrlKey||n.shiftKey||n.altKey||38!=n.which?!n.ctrlKey||n.shiftKey||n.altKey||40!=n.which||(i.moveDown(),l=!0):(i.moveUp(),a=!0,l=!0):(i.parent.moveFocusNextChild(i),l=!0):(i.parent.moveFocusPrevChild(i),l=!0)),l&&n.preventDefault(),n.stopPropagation(),e.$apply(),a&&window.setTimeout(function(){e.$apply(function(){i.editor.focusedElement.setIsFocused()})},100)}}),e.element.setIsFocusedEventHandlers.push(function(){o.parent().focus()}),e["delete"]=function(e){e["delete"]()},e.element.hasEditor&&(e.edit=function(){e.$root.editElement(e.element).then(function(t){e.$apply(function(){t.cancel||(e.element.data=t.element.data)})})})},configureForContainer:function(t,o){var n=t.element;t.getShowChildrenPlaceholder=function(){return 0===t.element.children.length&&!t.element.getIsDropTarget()},t.sortableOptions={cursor:"move",delay:150,disabled:n.getIsSealed(),distance:5,start:function(e,o){t.$apply(function(){n.setIsDropTarget(!0),n.editor.isDragging=!0}),o.placeholder.height(o.item.height()-4),o.placeholder.css("min-height",0)},stop:function(e,o){t.$apply(function(){n.editor.isDragging=!1,n.setIsDropTarget(!1)})},over:function(t,l){l.sender&&l.sender[0].isToolbox&&(l.sender[0].dropTargetTimeout&&(e.cancel(l.sender[0].dropTargetTimeout),l.sender[0].dropTargetTimeout=null),e(function(){if("Row"==n.type){var e=n.editor.dropTargetElement;e&&"Row"==e.type&&e.rollbackAddColumn()}n.setIsDropTarget(!1)}),l.sender[0].dropTargetTimeout=e(function(){if("Row"==n.type){var e=l.item.sortable.model,t=Math.floor(12/(n.children.length+1));e.width=t,e.offset=0,n.beginAddColumn(t);var a=_.max(_(o.find("> .layout-children > .layout-column:not(.ui-sortable-placeholder)")).map(function(e){return $(e).height()}));for(i=1;i<=12;i++)l.placeholder.removeClass("col-xs-"+i);l.placeholder.addClass("col-xs-"+e.width),a>0?(l.placeholder.height(a),l.placeholder.css("min-height",0)):(l.placeholder.height(0),l.placeholder.css("min-height",""))}n.setIsDropTarget(!0)},150))},receive:function(o,l){l.sender&&l.sender[0].isToolbox&&t.$apply(function(){var o=l.item.sortable.model;o&&("Row"==n.type&&n.commitAddColumn(),o.setEditor(n.editor),o.setParent(n),o.hasEditor&&t.$root.editElement(o).then(function(t){t.cancel||(o.data=t.element.data,o.applyElementEditorModel(t.elementEditorModel),o.setHtml&&o.setHtml(t.element.html)),e(function(){t.cancel?o["delete"]():o.setIsFocused(),n.setIsDropTarget(!1)})})),e(function(){n.setIsDropTarget(!1),o&&o.setIsFocused()})})}},t.click=function(e,t){e.editor.isDragging||e.setIsFocused(),t.stopPropagation()},t.getClasses=function(e){var t=["layout-element"];return e.children&&(t.push("layout-container"),e.getIsSealed()&&t.push("layout-container-sealed")),t.push("layout-"+e.type.toLowerCase()),e.dropTargetClass&&t.push(e.dropTargetClass),"Row"==e.type&&(t.push("row"),e.canAddColumn()||t.push("layout-row-full")),"Column"==e.type&&(t.push("col-xs-"+e.width),t.push("col-xs-offset-"+e.offset)),"Content"==e.type&&t.push("layout-content-"+e.contentTypeClass),e.getIsActive()&&t.push("layout-element-active"),e.getIsFocused()&&t.push("layout-element-focused"),e.getIsSelected()&&t.push("layout-element-selected"),e.getIsDropTarget()&&t.push("layout-element-droptarget"),e.isTemplated&&t.push("layout-element-templated"),t}}}}]),angular.module("LayoutEditor").directive("orcLayoutEditor",["environment",function(environment){return{restrict:"E",scope:{},controller:["$scope","$element","$attrs","$compile","clipboard",function($scope,$element,$attrs,$compile,clipboard){if(!$attrs.model)throw new Error("The 'model' attribute must evaluate to a LayoutEditor.Editor object.");$scope.element=eval($attrs.model),$scope.click=function(e,t){e.editor.isDragging||e.setIsFocused(),t.stopPropagation()},$scope.getClasses=function(e){var t=["layout-element","layout-container","layout-canvas"];return e.getIsActive()&&t.push("layout-element-active"),e.getIsFocused()&&t.push("layout-element-focused"),e.getIsSelected()&&t.push("layout-element-selected"),e.getIsDropTarget()&&t.push("layout-element-droptarget"),e.isTemplated&&t.push("layout-element-templated"),t};var layoutDesignerHost=$(".layout-designer").data("layout-designer-host");$scope.$root.layoutDesignerHost=layoutDesignerHost,layoutDesignerHost.element.on("replacecanvas",function(e,t){var o=$scope.element,n={data:t.canvas.data,htmlId:t.canvas.htmlId,htmlClass:t.canvas.htmlClass,htmlStyle:t.canvas.htmlStyle,isTemplated:t.canvas.isTemplated,children:t.canvas.children};layoutDesignerHost.editor=window.layoutEditor=new LayoutEditor.Editor(o.config,n);var l="",a=$compile(l)($scope);$(".layout-editor-holder").html(a)}),$scope.$root.editElement=function(e){var t=$scope.$root.layoutDesignerHost;return t.editElement(e)},$scope.$root.addElement=function(e){var t=$scope.$root.layoutDesignerHost;return t.addElement(e)},$(document).on("cut copy paste",function(e){if(clipboard.wasInvoked())e.originalEvent.clipboardData.setData("text/plain",clipboard.getData("text/plain")),e.originalEvent.clipboardData.setData("text/json",clipboard.getData("text/json")),e.preventDefault();else{var t=$scope.element.focusedElement;t&&($scope.$apply(function(){switch(e.type){case"copy":t.copy(e.originalEvent.clipboardData);break;case"cut":t.cut(e.originalEvent.clipboardData);break;case"paste":t.paste(e.originalEvent.clipboardData)}}),window.setTimeout(function(){$scope.$apply(function(){$scope.element.focusedElement&&$scope.element.focusedElement.setIsFocused()})},100),e.preventDefault())}clipboard.disable()})}],templateUrl:environment.templateUrl("Editor"),replace:!0,link:function(e,t){t.find(".layout-toolbar-container").click(function(e){e.stopPropagation()}),$(window).click(function(t){e.$apply(function(){e.element.activeElement=null,e.element.focusedElement=null})})}}}]),angular.module("LayoutEditor").directive("orcLayoutCanvas",["scopeConfigurator","environment",function(e,t){return{restrict:"E",scope:{element:"="},controller:["$scope","$element","$attrs",function(t,o,n){e.configureForElement(t,o),e.configureForContainer(t,o),t.sortableOptions.axis="y"}],templateUrl:t.templateUrl("Canvas"),replace:!0}}]),angular.module("LayoutEditor").directive("orcLayoutChild",["$compile",function(e){return{restrict:"E",scope:{element:"="},link:function(t,o){var n="",l=e(n)(t);$(o).replaceWith(l)}}}]),angular.module("LayoutEditor").directive("orcLayoutColumn",["$compile","scopeConfigurator","environment",function(e,t,o){return{restrict:"E",scope:{element:"="},controller:["$scope","$element",function(e,o){t.configureForElement(e,o),t.configureForContainer(e,o),e.sortableOptions.axis="y"}],templateUrl:o.templateUrl("Column"),replace:!0,link:function(e,t,o){t.find(".layout-column-resize-bar").draggable({axis:"x",helper:"clone",revert:!0,start:function(t,o){e.$apply(function(){e.element.editor.isResizing=!0})},drag:function(o,n){var l=t.parent(),a=l.width()/e.element.width,i=!o.ctrlKey;if($(o.target).hasClass("layout-column-resize-bar-left")){var r=n.offset.left-l.offset().left;-a>r&&e.element.canExpandLeft(i)?e.$apply(function(){e.element.expandLeft(i)}):r>a&&e.element.canContractLeft(i)&&e.$apply(function(){e.element.contractLeft(i)})}else if($(o.target).hasClass("layout-column-resize-bar-right")){var r=n.offset.left-l.width()-l.offset().left;r>a&&e.element.canExpandRight(i)?e.$apply(function(){e.element.expandRight(i)}):-a>r&&e.element.canContractRight(i)&&e.$apply(function(){e.element.contractRight(i)})}},stop:function(t,o){e.$apply(function(){e.element.editor.isResizing=!1})}})}}}]),angular.module("LayoutEditor").directive("orcLayoutContent",["$sce","scopeConfigurator","environment",function(e,t,o){return{restrict:"E",scope:{element:"="},controller:["$scope","$element",function(o,n){t.configureForElement(o,n),o.element.hasEditor&&(o.edit=function(){o.$root.editElement(o.element).then(function(e){o.$apply(function(){e.cancel||(o.element.data=e.element.data,o.element.setHtml(e.element.html))})})}),o.element.setHtml=function(t){o.element.html=t,o.element.htmlUnsafe=e.trustAsHtml(t)},o.element.setHtml(o.element.html)}],templateUrl:o.templateUrl("Content"),replace:!0}}]),angular.module("LayoutEditor").directive("orcLayoutGrid",["$compile","scopeConfigurator","environment",function(e,t,o){return{restrict:"E",scope:{element:"="},controller:["$scope","$element",function(e,o){t.configureForElement(e,o),t.configureForContainer(e,o),e.sortableOptions.axis="y"}],templateUrl:o.templateUrl("Grid"),replace:!0}}]),angular.module("LayoutEditor").directive("orcLayoutRow",["$compile","scopeConfigurator","environment",function(e,t,o){return{restrict:"E",scope:{element:"="},controller:["$scope","$element",function(e,o){t.configureForElement(e,o),t.configureForContainer(e,o),e.sortableOptions.axis="x",e.sortableOptions["ui-floating"]=!0}],templateUrl:o.templateUrl("Row"),replace:!0}}]),angular.module("LayoutEditor").directive("orcLayoutPopup",[function(){return{restrict:"A",link:function(e,t,o){var n=$(t),l=n.closest(".layout-popup-trigger"),a=n.closest(".layout-element");l.click(function(){n.toggle(),n.is(":visible")&&(n.position({my:o.orcLayoutPopupMy||"left top",at:o.orcLayoutPopupAt||"left bottom+4px",of:l}),n.find("input").first().focus())}),n.click(function(e){e.stopPropagation()}),a.click(function(e){n.hide()}),n.keydown(function(e){e.ctrlKey||e.shiftKey||e.altKey||27!=e.which||n.hide(),e.stopPropagation()}),n.on("cut copy paste",function(e){e.stopPropagation()})}}}]),angular.module("LayoutEditor").directive("orcLayoutToolbox",["$compile","environment",function(e,t){return{restrict:"E",controller:["$scope","$element",function(e,t){e.resetElements=function(){e.gridElements=[LayoutEditor.Grid.from({toolboxIcon:"",toolboxLabel:"Grid",toolboxDescription:"Empty grid.",children:[]})],e.rowElements=[LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (1 column)",toolboxDescription:"Row with 1 column.",children:LayoutEditor.Column.times(1)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (2 columns)",toolboxDescription:"Row with 2 columns.",children:LayoutEditor.Column.times(2)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (3 columns)",toolboxDescription:"Row with 3 columns.",children:LayoutEditor.Column.times(3)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (4 columns)",toolboxDescription:"Row with 4 columns.",children:LayoutEditor.Column.times(4)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (6 columns)",toolboxDescription:"Row with 6 columns.",children:LayoutEditor.Column.times(6)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (12 columns)",toolboxDescription:"Row with 12 columns.",children:LayoutEditor.Column.times(12)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (empty)",toolboxDescription:"Empty row.",children:[]})],e.columnElements=[LayoutEditor.Column.from({toolboxIcon:"",toolboxLabel:"Column",toolboxDescription:"Empty column.",width:1,offset:0,children:[]})],e.canvasElements=[LayoutEditor.Canvas.from({toolboxIcon:"",toolboxLabel:"Canvas",toolboxDescription:"Empty canvas.",children:[]})],e.contentElementCategories=_(e.element.config.categories).map(function(e){return{name:e.name,elements:_(e.contentTypes).map(function(e){var t=e.type,o=LayoutEditor.factories[t]||LayoutEditor.factories.Content,n={isTemplated:!1,contentType:e.id,contentTypeLabel:e.label,contentTypeClass:e.typeClass,data:null,hasEditor:e.hasEditor,html:e.html},l=o(n);return l.toolboxIcon=e.icon||"",l.toolboxLabel=e.label,l.toolboxDescription=e.description,l})}})},e.resetElements(),e.getSortableOptions=function(o){var n,l,a=t.closest(".layout-editor").attr("id"),i=!1;switch(o){case"Grid":n=[".layout-canvas",".layout-column",".layout-common-holder"],l="layout-element layout-container layout-grid ui-sortable-placeholder";break;case"Row":n=[".layout-grid"],l="layout-element layout-container layout-row row ui-sortable-placeholder";break;case"Column":n=[".layout-row:not(.layout-row-full)"],l="layout-element layout-container layout-column ui-sortable-placeholder",i=!0;break;case"Content":n=[".layout-canvas",".layout-column",".layout-common-holder"],l="layout-element layout-content ui-sortable-placeholder";break;case"Canvas":n=[".layout-canvas",".layout-column",".layout-common-holder"],l="layout-element layout-container layout-grid ui-sortable-placeholder"}return{cursor:"move",connectWith:_(n).map(function(e){return"#"+a+" "+e+":not(.layout-container-sealed) > .layout-element-wrapper > .layout-children"}).join(", "),placeholder:l,"ui-floating":i,create:function(e,t){e.target.isToolbox=!0},start:function(t,o){e.$apply(function(){e.element.isDragging=!0})},stop:function(t,o){e.$apply(function(){e.element.isDragging=!1,e.resetElements()})},over:function(t,o){e.$apply(function(){e.element.canvas.setIsDropTarget(!1)})}}};var o="layoutToolboxCategory_Layout_IsCollapsed";e.layoutIsCollapsed="true"===$.cookie(o),e.toggleLayoutIsCollapsed=function(t){e.layoutIsCollapsed=!e.layoutIsCollapsed,$.cookie(o,e.layoutIsCollapsed,{expires:365}),t.preventDefault(),t.stopPropagation()}}],templateUrl:t.templateUrl("Toolbox"),replace:!0,link:function(e,t){var o=t.find(".layout-toolbox");$(window).on("resize scroll",function(e){var n=t.parent().find(".layout-canvas"),l=!!n&&n.height()>o.height(),a=$(window).scrollTop();l&&a>t.offset().top+t.height()-o.height()?(o.addClass("sticky-bottom"),o.removeClass("sticky-top")):l&&a>t.offset().top?(o.addClass("sticky-top"),o.removeClass("sticky-bottom")):(o.removeClass("sticky-top"),o.removeClass("sticky-bottom"))})}}}]),angular.module("LayoutEditor").directive("orcLayoutToolboxGroup",["$compile","environment",function(e,t){return{restrict:"E",scope:{category:"="},controller:["$scope","$element",function(e,t){var o="layoutToolboxCategory_"+e.category.name+"_IsCollapsed";e.isCollapsed="true"===$.cookie(o),e.toggleIsCollapsed=function(t){e.isCollapsed=!e.isCollapsed,$.cookie(o,e.isCollapsed,{expires:365}),t.preventDefault(),t.stopPropagation()}}],templateUrl:t.templateUrl("ToolboxGroup"),replace:!0}}]); \ No newline at end of file +angular.module("LayoutEditor",["ngSanitize","ngResource","ui.sortable"]);var LayoutEditor;!function(e){var t=function(){var e=this;this._clipboardData={},this._isDisabled=!1,this._wasInvoked=!1,this.setData=function(t,o){e._clipboardData[t]=o,e._wasInvoked=!0},this.getData=function(t){return e._clipboardData[t]},this.disable=function(){e._isDisabled=!0,e._wasInvoked=!1,e._clipboardData={}},this.isDisabled=function(){return e._isDisabled},this.wasInvoked=function(){return e._wasInvoked}};e.Clipboard=new t,angular.module("LayoutEditor").factory("clipboard",[function(){return{setData:e.Clipboard.setData,getData:e.Clipboard.getData,disable:e.Clipboard.disable,isDisabled:e.Clipboard.isDisabled,wasInvoked:e.Clipboard.wasInvoked}}])}(LayoutEditor||(LayoutEditor={})),angular.module("LayoutEditor").factory("scopeConfigurator",["$timeout","clipboard",function(e,t){return{configureForElement:function(e,o){o.find(".layout-panel").click(function(e){e.stopPropagation()}),o.parent().keydown(function(n){var l=!1,a=!1,r=e.element;if(!r.editor.isDragging){if(!t.isDisabled()){var i=r.editor.focusedElement;if(i&&n.ctrlKey)switch(n.which){case 67:i.copy(t);break;case 88:i.cut(t);break;case 86:i.paste(t)}}if(n.ctrlKey||n.shiftKey||n.altKey||46!=n.which?n.ctrlKey||n.shiftKey||n.altKey||32!=n.which&&27!=n.which||(o.find(".layout-panel-action-properties").first().click(),l=!0):(e["delete"](r),l=!0),"Content"==r.type&&(n.ctrlKey||n.shiftKey||n.altKey||13!=n.which||(o.find(".layout-panel-action-edit").first().click(),l=!0)),r.children&&(n.ctrlKey||n.shiftKey||!n.altKey||40!=n.which||(r.children.length>0&&r.children[0].setIsFocused(),l=!0),"Column"==r.type)){var c=!n.ctrlKey;37==n.which?(n.altKey&&r.expandLeft(c),n.shiftKey&&r.contractRight(c),l=!0):39==n.which&&(n.altKey&&r.contractLeft(c),n.shiftKey&&r.expandRight(c),l=!0)}r.parent&&(n.altKey&&38==n.which&&(r.parent.setIsFocused(),l=!0),"Row"==r.parent.type?n.ctrlKey||n.shiftKey||n.altKey||37!=n.which?n.ctrlKey||n.shiftKey||n.altKey||39!=n.which?!n.ctrlKey||n.shiftKey||n.altKey||37!=n.which?!n.ctrlKey||n.shiftKey||n.altKey||39!=n.which||(r.moveDown(),l=!0):(r.moveUp(),a=!0,l=!0):(r.parent.moveFocusNextChild(r),l=!0):(r.parent.moveFocusPrevChild(r),l=!0):n.ctrlKey||n.shiftKey||n.altKey||38!=n.which?n.ctrlKey||n.shiftKey||n.altKey||40!=n.which?!n.ctrlKey||n.shiftKey||n.altKey||38!=n.which?!n.ctrlKey||n.shiftKey||n.altKey||40!=n.which||(r.moveDown(),l=!0):(r.moveUp(),a=!0,l=!0):(r.parent.moveFocusNextChild(r),l=!0):(r.parent.moveFocusPrevChild(r),l=!0)),l&&n.preventDefault(),n.stopPropagation(),e.$apply(),a&&window.setTimeout(function(){e.$apply(function(){r.editor.focusedElement.setIsFocused()})},100)}}),e.element.setIsFocusedEventHandlers.push(function(){o.parent().focus()}),e["delete"]=function(e){e["delete"]()},e.element.hasEditor&&(e.edit=function(){e.$root.editElement(e.element).then(function(t){e.$apply(function(){t.cancel||(e.element.data=t.element.data,e.element.applyElementEditorModel(t.elementEditorModel),e.element.setHtml&&e.element.setHtml(t.element.html))})})})},configureForContainer:function(t,o){var n=t.element;t.getShowChildrenPlaceholder=function(){return 0===t.element.children.length&&!t.element.getIsDropTarget()},t.sortableOptions={cursor:"move",delay:150,disabled:n.getIsSealed(),distance:5,start:function(e,o){t.$apply(function(){n.setIsDropTarget(!0),n.editor.isDragging=!0}),o.placeholder.height(o.item.height()-4),o.placeholder.css("min-height",0)},stop:function(e,o){t.$apply(function(){n.editor.isDragging=!1,n.setIsDropTarget(!1)})},over:function(t,l){l.sender&&l.sender[0].isToolbox&&(l.sender[0].dropTargetTimeout&&(e.cancel(l.sender[0].dropTargetTimeout),l.sender[0].dropTargetTimeout=null),e(function(){if("Row"==n.type){var e=n.editor.dropTargetElement;e&&"Row"==e.type&&e.rollbackAddColumn()}n.setIsDropTarget(!1)}),l.sender[0].dropTargetTimeout=e(function(){if("Row"==n.type){var e=l.item.sortable.model,t=Math.floor(12/(n.children.length+1));e.width=t,e.offset=0,n.beginAddColumn(t);var a=_.max(_(o.find("> .layout-children > .layout-column:not(.ui-sortable-placeholder)")).map(function(e){return $(e).height()}));for(i=1;i<=12;i++)l.placeholder.removeClass("col-xs-"+i);l.placeholder.addClass("col-xs-"+e.width),a>0?(l.placeholder.height(a),l.placeholder.css("min-height",0)):(l.placeholder.height(0),l.placeholder.css("min-height",""))}n.setIsDropTarget(!0)},150))},receive:function(o,l){l.sender&&l.sender[0].isToolbox&&t.$apply(function(){var o=l.item.sortable.model;o&&("Row"==n.type&&n.commitAddColumn(),o.setEditor(n.editor),o.setParent(n),o.hasEditor&&t.$root.editElement(o).then(function(t){t.cancel||(o.data=t.element.data,o.applyElementEditorModel(t.elementEditorModel),o.setHtml&&o.setHtml(t.element.html)),e(function(){t.cancel?o["delete"]():o.setIsFocused(),n.setIsDropTarget(!1)})})),e(function(){n.setIsDropTarget(!1),o&&o.setIsFocused()})})}},t.click=function(e,t){e.editor.isDragging||e.setIsFocused(),t.stopPropagation()},t.getClasses=function(e){var t=["layout-element"];return e.children&&(t.push("layout-container"),e.getIsSealed()&&t.push("layout-container-sealed")),t.push("layout-"+e.type.toLowerCase()),e.dropTargetClass&&t.push(e.dropTargetClass),"Row"==e.type&&(t.push("row"),e.canAddColumn()||t.push("layout-row-full")),"Column"==e.type&&(t.push("col-xs-"+e.width),t.push("col-xs-offset-"+e.offset)),"Content"==e.type&&t.push("layout-content-"+e.contentTypeClass),e.getIsActive()&&t.push("layout-element-active"),e.getIsFocused()&&t.push("layout-element-focused"),e.getIsSelected()&&t.push("layout-element-selected"),e.getIsDropTarget()&&t.push("layout-element-droptarget"),e.isTemplated&&t.push("layout-element-templated"),t}}}}]),angular.module("LayoutEditor").directive("orcLayoutEditor",["environment",function(environment){return{restrict:"E",scope:{},controller:["$scope","$element","$attrs","$compile","clipboard",function($scope,$element,$attrs,$compile,clipboard){if(!$attrs.model)throw new Error("The 'model' attribute must evaluate to a LayoutEditor.Editor object.");$scope.element=eval($attrs.model),$scope.click=function(e,t){e.editor.isDragging||e.setIsFocused(),t.stopPropagation()},$scope.getClasses=function(e){var t=["layout-element","layout-container","layout-canvas"];return e.getIsActive()&&t.push("layout-element-active"),e.getIsFocused()&&t.push("layout-element-focused"),e.getIsSelected()&&t.push("layout-element-selected"),e.getIsDropTarget()&&t.push("layout-element-droptarget"),e.isTemplated&&t.push("layout-element-templated"),t};var layoutDesignerHost=$(".layout-designer").data("layout-designer-host");$scope.$root.layoutDesignerHost=layoutDesignerHost,layoutDesignerHost.element.on("replacecanvas",function(e,t){var o=$scope.element,n={data:t.canvas.data,htmlId:t.canvas.htmlId,htmlClass:t.canvas.htmlClass,htmlStyle:t.canvas.htmlStyle,isTemplated:t.canvas.isTemplated,children:t.canvas.children};layoutDesignerHost.editor=window.layoutEditor=new LayoutEditor.Editor(o.config,n);var l="",a=$compile(l)($scope);$(".layout-editor-holder").html(a)}),$scope.$root.editElement=function(e){var t=$scope.$root.layoutDesignerHost;return t.editElement(e)},$scope.$root.addElement=function(e){var t=$scope.$root.layoutDesignerHost;return t.addElement(e)},$(document).on("cut copy paste",function(e){if(clipboard.wasInvoked())e.originalEvent.clipboardData.setData("text/plain",clipboard.getData("text/plain")),e.originalEvent.clipboardData.setData("text/json",clipboard.getData("text/json")),e.preventDefault();else{var t=$scope.element.focusedElement;t&&($scope.$apply(function(){switch(e.type){case"copy":t.copy(e.originalEvent.clipboardData);break;case"cut":t.cut(e.originalEvent.clipboardData);break;case"paste":t.paste(e.originalEvent.clipboardData)}}),window.setTimeout(function(){$scope.$apply(function(){$scope.element.focusedElement&&$scope.element.focusedElement.setIsFocused()})},100),e.preventDefault())}clipboard.disable()})}],templateUrl:environment.templateUrl("Editor"),replace:!0,link:function(e,t){t.find(".layout-toolbar-container").click(function(e){e.stopPropagation()}),$(window).click(function(t){e.$apply(function(){e.element.activeElement=null,e.element.focusedElement=null})})}}}]),angular.module("LayoutEditor").directive("orcLayoutCanvas",["scopeConfigurator","environment",function(e,t){return{restrict:"E",scope:{element:"="},controller:["$scope","$element","$attrs",function(t,o,n){e.configureForElement(t,o),e.configureForContainer(t,o),t.sortableOptions.axis="y"}],templateUrl:t.templateUrl("Canvas"),replace:!0}}]),angular.module("LayoutEditor").directive("orcLayoutChild",["$compile",function(e){return{restrict:"E",scope:{element:"="},link:function(t,o){var n="",l=e(n)(t);$(o).replaceWith(l)}}}]),angular.module("LayoutEditor").directive("orcLayoutColumn",["$compile","scopeConfigurator","environment",function(e,t,o){return{restrict:"E",scope:{element:"="},controller:["$scope","$element",function(e,o){t.configureForElement(e,o),t.configureForContainer(e,o),e.sortableOptions.axis="y"}],templateUrl:o.templateUrl("Column"),replace:!0,link:function(e,t,o){t.find(".layout-column-resize-bar").draggable({axis:"x",helper:"clone",revert:!0,start:function(t,o){e.$apply(function(){e.element.editor.isResizing=!0})},drag:function(o,n){var l=t.parent(),a=l.width()/e.element.width,r=!o.ctrlKey;if($(o.target).hasClass("layout-column-resize-bar-left")){var i=n.offset.left-l.offset().left;-a>i&&e.element.canExpandLeft(r)?e.$apply(function(){e.element.expandLeft(r)}):i>a&&e.element.canContractLeft(r)&&e.$apply(function(){e.element.contractLeft(r)})}else if($(o.target).hasClass("layout-column-resize-bar-right")){var i=n.offset.left-l.width()-l.offset().left;i>a&&e.element.canExpandRight(r)?e.$apply(function(){e.element.expandRight(r)}):-a>i&&e.element.canContractRight(r)&&e.$apply(function(){e.element.contractRight(r)})}},stop:function(t,o){e.$apply(function(){e.element.editor.isResizing=!1})}})}}}]),angular.module("LayoutEditor").directive("orcLayoutContent",["$sce","scopeConfigurator","environment",function(e,t,o){return{restrict:"E",scope:{element:"="},controller:["$scope","$element",function(o,n){t.configureForElement(o,n),o.element.setHtml=function(t){o.element.html=t,o.element.htmlUnsafe=e.trustAsHtml(t)},o.element.setHtml(o.element.html)}],templateUrl:o.templateUrl("Content"),replace:!0}}]),angular.module("LayoutEditor").directive("orcLayoutGrid",["$compile","scopeConfigurator","environment",function(e,t,o){return{restrict:"E",scope:{element:"="},controller:["$scope","$element",function(e,o){t.configureForElement(e,o),t.configureForContainer(e,o),e.sortableOptions.axis="y"}],templateUrl:o.templateUrl("Grid"),replace:!0}}]),angular.module("LayoutEditor").directive("orcLayoutRow",["$compile","scopeConfigurator","environment",function(e,t,o){return{restrict:"E",scope:{element:"="},controller:["$scope","$element",function(e,o){t.configureForElement(e,o),t.configureForContainer(e,o),e.sortableOptions.axis="x",e.sortableOptions["ui-floating"]=!0}],templateUrl:o.templateUrl("Row"),replace:!0}}]),angular.module("LayoutEditor").directive("orcLayoutPopup",[function(){return{restrict:"A",link:function(e,t,o){var n=$(t),l=n.closest(".layout-popup-trigger"),a=n.closest(".layout-element");l.click(function(){n.toggle(),n.is(":visible")&&(n.position({my:o.orcLayoutPopupMy||"left top",at:o.orcLayoutPopupAt||"left bottom+4px",of:l}),n.find("input").first().focus())}),n.click(function(e){e.stopPropagation()}),a.click(function(e){n.hide()}),n.keydown(function(e){e.ctrlKey||e.shiftKey||e.altKey||27!=e.which||n.hide(),e.stopPropagation()}),n.on("cut copy paste",function(e){e.stopPropagation()})}}}]),angular.module("LayoutEditor").directive("orcLayoutToolbox",["$compile","environment",function(e,t){return{restrict:"E",controller:["$scope","$element",function(e,t){e.resetElements=function(){e.gridElements=[LayoutEditor.Grid.from({toolboxIcon:"",toolboxLabel:"Grid",toolboxDescription:"Empty grid.",children:[]})],e.rowElements=[LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (1 column)",toolboxDescription:"Row with 1 column.",children:LayoutEditor.Column.times(1)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (2 columns)",toolboxDescription:"Row with 2 columns.",children:LayoutEditor.Column.times(2)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (3 columns)",toolboxDescription:"Row with 3 columns.",children:LayoutEditor.Column.times(3)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (4 columns)",toolboxDescription:"Row with 4 columns.",children:LayoutEditor.Column.times(4)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (6 columns)",toolboxDescription:"Row with 6 columns.",children:LayoutEditor.Column.times(6)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (12 columns)",toolboxDescription:"Row with 12 columns.",children:LayoutEditor.Column.times(12)}),LayoutEditor.Row.from({toolboxIcon:"",toolboxLabel:"Row (empty)",toolboxDescription:"Empty row.",children:[]})],e.columnElements=[LayoutEditor.Column.from({toolboxIcon:"",toolboxLabel:"Column",toolboxDescription:"Empty column.",width:1,offset:0,children:[]})],e.canvasElements=[LayoutEditor.Canvas.from({toolboxIcon:"",toolboxLabel:"Canvas",toolboxDescription:"Empty canvas.",children:[]})],e.contentElementCategories=_(e.element.config.categories).map(function(e){return{name:e.name,elements:_(e.contentTypes).map(function(e){var t=e.type,o=LayoutEditor.factories[t]||LayoutEditor.factories.Content,n={isTemplated:!1,contentType:e.id,contentTypeLabel:e.label,contentTypeClass:e.typeClass,data:null,hasEditor:e.hasEditor,html:e.html},l=o(n);return l.toolboxIcon=e.icon||"",l.toolboxLabel=e.label,l.toolboxDescription=e.description,l})}})},e.resetElements(),e.getSortableOptions=function(o){var n,l,a=t.closest(".layout-editor").attr("id"),r=!1;switch(o){case"Grid":n=[".layout-canvas",".layout-column",".layout-common-holder"],l="layout-element layout-container layout-grid ui-sortable-placeholder";break;case"Row":n=[".layout-grid"],l="layout-element layout-container layout-row row ui-sortable-placeholder";break;case"Column":n=[".layout-row:not(.layout-row-full)"],l="layout-element layout-container layout-column ui-sortable-placeholder",r=!0;break;case"Content":n=[".layout-canvas",".layout-column",".layout-common-holder"],l="layout-element layout-content ui-sortable-placeholder";break;case"Canvas":n=[".layout-canvas",".layout-column",".layout-common-holder"],l="layout-element layout-container layout-grid ui-sortable-placeholder"}return{cursor:"move",connectWith:_(n).map(function(e){return"#"+a+" "+e+":not(.layout-container-sealed) > .layout-element-wrapper > .layout-children"}).join(", "),placeholder:l,"ui-floating":r,create:function(e,t){e.target.isToolbox=!0},start:function(t,o){e.$apply(function(){e.element.isDragging=!0})},stop:function(t,o){e.$apply(function(){e.element.isDragging=!1,e.resetElements()})},over:function(t,o){e.$apply(function(){e.element.canvas.setIsDropTarget(!1)})}}};var o="layoutToolboxCategory_Layout_IsCollapsed";e.layoutIsCollapsed="true"===$.cookie(o),e.toggleLayoutIsCollapsed=function(t){e.layoutIsCollapsed=!e.layoutIsCollapsed,$.cookie(o,e.layoutIsCollapsed,{expires:365}),t.preventDefault(),t.stopPropagation()}}],templateUrl:t.templateUrl("Toolbox"),replace:!0,link:function(e,t){var o=t.find(".layout-toolbox");$(window).on("resize scroll",function(e){var n=t.parent().find(".layout-canvas"),l=!!n&&n.height()>o.height(),a=$(window).scrollTop();l&&a>t.offset().top+t.height()-o.height()?(o.addClass("sticky-bottom"),o.removeClass("sticky-top")):l&&a>t.offset().top?(o.addClass("sticky-top"),o.removeClass("sticky-bottom")):(o.removeClass("sticky-top"),o.removeClass("sticky-bottom"))})}}}]),angular.module("LayoutEditor").directive("orcLayoutToolboxGroup",["$compile","environment",function(e,t){return{restrict:"E",scope:{category:"="},controller:["$scope","$element",function(e,t){var o="layoutToolboxCategory_"+e.category.name+"_IsCollapsed";e.isCollapsed="true"===$.cookie(o),e.toggleIsCollapsed=function(t){e.isCollapsed=!e.isCollapsed,$.cookie(o,e.isCollapsed,{expires:365}),t.preventDefault(),t.stopPropagation()}}],templateUrl:t.templateUrl("ToolboxGroup"),replace:!0}}]); \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.js b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.js index 877eff69d..87349cbd6 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.js @@ -114,6 +114,7 @@ var LayoutEditor; if (!type) throw new Error("Parameter 'type' is required."); + var self = this; this.type = type; this.data = data; this.htmlId = htmlId; @@ -273,7 +274,9 @@ var LayoutEditor; htmlClass: this.htmlClass, htmlStyle: this.htmlStyle, isTemplated: this.isTemplated, - rule: this.rule + rule: this.rule, + contentType: this.contentType, + hasEditor: this.hasEditor }; }; @@ -281,6 +284,10 @@ var LayoutEditor; return {}; }; + this.toObject = function () { + return self.elementToObject(); + }; + this.copy = function (clipboardData) { var text = this.getInnerText(); clipboardData.setData("text/plain", text); @@ -1001,19 +1008,12 @@ var LayoutEditor; this.htmlUnsafe = html; } + var baseToObject = this.toObject; this.toObject = function () { - return { - "type": "Content" - }; - }; - - this.toObject = function () { - var result = this.elementToObject(); - result.contentType = this.contentType; + var result = baseToObject(); result.contentTypeLabel = this.contentTypeLabel; result.contentTypeClass = this.contentTypeClass; result.html = this.html; - result.hasEditor = hasEditor; return result; }; @@ -1038,4 +1038,4 @@ var LayoutEditor; }; })(LayoutEditor || (LayoutEditor = {})); -//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Models.js","Helpers.js","Editor.js","RecycleBin.js","Element.js","Container.js","Canvas.js","Grid.js","Row.js","Column.js","Content.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA,ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC/MA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC3JA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACl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file":"Models.js","sourcesContent":[null,"var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    Array.prototype.move = function (from, to) {\r\n        this.splice(to, 0, this.splice(from, 1)[0]);\r\n    };\r\n\r\n    LayoutEditor.childrenFrom = function(values) {\r\n        return _(values).map(function(value) {\r\n            return LayoutEditor.elementFrom(value);\r\n        });\r\n    };\r\n\r\n    var registerFactory = LayoutEditor.registerFactory = function(type, factory) {\r\n        var factories = LayoutEditor.factories = LayoutEditor.factories || {};\r\n        factories[type] = factory;\r\n    };\r\n\r\n    registerFactory(\"Canvas\", function (value) { return LayoutEditor.Canvas.from(value); });\r\n    registerFactory(\"Grid\", function(value) { return LayoutEditor.Grid.from(value); });\r\n    registerFactory(\"Row\", function(value) { return LayoutEditor.Row.from(value); });\r\n    registerFactory(\"Column\", function(value) { return LayoutEditor.Column.from(value); });\r\n    registerFactory(\"Content\", function(value) { return LayoutEditor.Content.from(value); });\r\n\r\n    LayoutEditor.elementFrom = function (value) {\r\n        var factory = LayoutEditor.factories[value.type];\r\n\r\n        if (!factory)\r\n            throw new Error(\"No element with type \\\"\" + value.type + \"\\\" was found.\");\r\n\r\n        var element = factory(value);\r\n        return element;\r\n    };\r\n\r\n    LayoutEditor.setModel = function (elementSelector, model) {\r\n        $(elementSelector).scope().element = model;\r\n    };\r\n\r\n    LayoutEditor.getModel = function (elementSelector) {\r\n        return $(elementSelector).scope().element;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Editor = function (config, canvasData) {\r\n        this.config = config;\r\n        this.canvas = LayoutEditor.Canvas.from(canvasData);\r\n        this.initialState = JSON.stringify(this.canvas.toObject());\r\n        this.activeElement = null;\r\n        this.focusedElement = null;\r\n        this.dropTargetElement = null;\r\n        this.isDragging = false;\r\n        this.isResizing = false;\r\n        this.recycleBin = new LayoutEditor.RecycleBin();\r\n\r\n        this.resetToolboxElements = function () {\r\n            this.toolboxElements = [\r\n                LayoutEditor.Row.from({\r\n                    children: []\r\n                })\r\n            ];\r\n        };\r\n\r\n        this.isDirty = function() {\r\n            var currentState = JSON.stringify(this.canvas.toObject());\r\n            return this.initialState != currentState;\r\n        };\r\n\r\n        this.resetToolboxElements();\r\n        this.canvas.setEditor(this);\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));\r\n","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.RecycleBin = function () {\r\n        this.elements = [];\r\n\r\n        this.add = function(element) {\r\n            this.elements.push(element);\r\n        };\r\n\r\n        this.toObject = function () {\r\n            var result = {\r\n                type: \"RecycleBin\",\r\n                children: []\r\n            };\r\n\r\n            for (var i = 0; i < this.elements.length; i++) {\r\n                var element = this.elements[i];\r\n                var dto = element.toObject();\r\n                result.children.push(dto);\r\n            }\r\n\r\n            return result;\r\n        };\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));\r\n","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Element = function (type, data, htmlId, htmlClass, htmlStyle, isTemplated, rule) {\r\n        if (!type)\r\n            throw new Error(\"Parameter 'type' is required.\");\r\n\r\n        this.type = type;\r\n        this.data = data;\r\n        this.htmlId = htmlId;\r\n        this.htmlClass = htmlClass;\r\n        this.htmlStyle = htmlStyle;\r\n        this.isTemplated = isTemplated;\r\n        this.rule = rule;\r\n\r\n        this.templateStyles = {};\r\n        this.editor = null;\r\n        this.parent = null;\r\n        this.setIsFocusedEventHandlers = [];\r\n\r\n        this.setEditor = function (editor) {\r\n            this.editor = editor;\r\n            if (!!this.children && _.isArray(this.children)) {\r\n                _(this.children).each(function (child) {\r\n                    child.setEditor(editor);\r\n                });\r\n            }\r\n        };\r\n\r\n        this.setParent = function(parentElement) {\r\n            this.parent = parentElement;\r\n            this.parent.onChildAdded(this);\r\n\r\n            var currentAncestor = parentElement;\r\n            while (!!currentAncestor) {\r\n                currentAncestor.onDescendantAdded(this, parentElement);\r\n                currentAncestor = currentAncestor.parent;\r\n            }\r\n        };\r\n\r\n        this.setIsTemplated = function (value) {\r\n            this.isTemplated = value;\r\n            if (!!this.children && _.isArray(this.children)) {\r\n                _(this.children).each(function (child) {\r\n                    child.setIsTemplated(value);\r\n                });\r\n            }\r\n        };\r\n\r\n        this.applyElementEditorModel = function() { /* Virtual */ };\r\n\r\n        this.getIsActive = function () {\r\n            if (!this.editor)\r\n                return false;\r\n            return this.editor.activeElement === this && !this.getIsFocused();\r\n        };\r\n\r\n        this.setIsActive = function (value) {\r\n            if (!this.editor)\r\n                return;\r\n            if (this.editor.isDragging || this.editor.isResizing)\r\n                return;\r\n\r\n            if (value)\r\n                this.editor.activeElement = this;\r\n            else\r\n                this.editor.activeElement = this.parent;\r\n        };\r\n\r\n        this.getIsFocused = function () {\r\n            if (!this.editor)\r\n                return false;\r\n            return this.editor.focusedElement === this;\r\n        };\r\n\r\n        this.setIsFocused = function () {\r\n            if (!this.editor)\r\n            \treturn;\r\n            if (!this.children && this.isTemplated)\r\n            \treturn;\r\n            if (this.editor.isDragging || this.editor.isResizing)\r\n                return;\r\n\r\n            this.editor.focusedElement = this;\r\n            _(this.setIsFocusedEventHandlers).each(function (item) {\r\n                try {\r\n                    item();\r\n                }\r\n                catch (ex) {\r\n                    // Ignore.\r\n                }\r\n            });\r\n        };\r\n\r\n        this.getIsSelected = function () {\r\n            if (this.getIsFocused())\r\n                return true;\r\n\r\n            if (!!this.children && _.isArray(this.children)) {\r\n                return _(this.children).any(function(child) {\r\n                    return child.getIsSelected();\r\n                });\r\n            }\r\n\r\n            return false;\r\n        };\r\n\r\n        this.getIsDropTarget = function () {\r\n            if (!this.editor)\r\n                return false;\r\n            return this.editor.dropTargetElement === this;\r\n        }\r\n\r\n        this.setIsDropTarget = function (value) {\r\n            if (!this.editor)\r\n                return;\r\n            if (value)\r\n                this.editor.dropTargetElement = this;\r\n            else\r\n                this.editor.dropTargetElement = null;\r\n        };\r\n\r\n        this.canDelete = function () {\r\n            if (this.isTemplated || !this.parent)\r\n                return false;\r\n            return true;\r\n        };\r\n\r\n        this.delete = function () {\r\n            if (!this.canDelete())\r\n                return;\r\n            this.parent.deleteChild(this);\r\n        };\r\n\r\n        this.canMoveUp = function () {\r\n            if (this.isTemplated || !this.parent)\r\n                return false;\r\n            return this.parent.canMoveChildUp(this);\r\n        };\r\n\r\n        this.moveUp = function () {\r\n            if (!this.canMoveUp())\r\n                return;\r\n            this.parent.moveChildUp(this);\r\n        };\r\n\r\n        this.canMoveDown = function () {\r\n            if (this.isTemplated || !this.parent)\r\n                return false;\r\n            return this.parent.canMoveChildDown(this);\r\n        };\r\n\r\n        this.moveDown = function () {\r\n            if (!this.canMoveDown())\r\n                return;\r\n            this.parent.moveChildDown(this);\r\n        };\r\n\r\n        this.elementToObject = function () {\r\n            return {\r\n                type: this.type,\r\n                data: this.data,\r\n                htmlId: this.htmlId,\r\n                htmlClass: this.htmlClass,\r\n                htmlStyle: this.htmlStyle,\r\n                isTemplated: this.isTemplated,\r\n                rule: this.rule\r\n            };\r\n        };\r\n\r\n        this.getEditorObject = function() {\r\n            return {};\r\n        };\r\n\r\n        this.copy = function (clipboardData) {\r\n            var text = this.getInnerText();\r\n            clipboardData.setData(\"text/plain\", text);\r\n\r\n            var data = this.toObject();\r\n            var json = JSON.stringify(data, null, \"\\t\");\r\n            clipboardData.setData(\"text/json\", json);\r\n        };\r\n\r\n        this.cut = function (clipboardData) {\r\n            if (this.canDelete()) {\r\n                this.copy(clipboardData);\r\n                this.delete();\r\n            }\r\n        };\r\n\r\n        this.paste = function (clipboardData) {\r\n            if (!!this.parent)\r\n                this.parent.paste(clipboardData);\r\n        };\r\n\r\n        this.getTemplateStyles = function () {\r\n            var styles = this.templateStyles || {};\r\n            var css = \"\";\r\n\r\n            for (var property in styles) {\r\n                css += property + \":\" + styles[property] + \";\";\r\n            }\r\n\r\n            return css;\r\n        }\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Container = function (allowedChildTypes, children) {\r\n\r\n        this.allowedChildTypes = allowedChildTypes;\r\n        this.children = children;\r\n        this.isContainer = true;\r\n        this.containerTemplateStyles = {};\r\n\r\n        var self = this;\r\n\r\n        this.onChildAdded = function (element) { /* Virtual */ };\r\n        this.onDescendantAdded = function (element, parentElement) { /* Virtual */ };\r\n\r\n        this.setChildren = function (children) {\r\n            this.children = children;\r\n            _(this.children).each(function (child) {\r\n                child.setParent(self);\r\n            });\r\n        };\r\n\r\n        this.setChildren(children);\r\n\r\n        this.getIsSealed = function () {\r\n            return _(this.children).any(function (child) {\r\n                return child.isTemplated;\r\n            });\r\n        };\r\n\r\n        var _baseSetIsFocused = this.setIsFocused;\r\n        this.setIsFocused = function () {\r\n            if (this.getIsSealed())\r\n                return;\r\n            _baseSetIsFocused.call(this);\r\n        };\r\n\r\n        this.addChild = function (child) {\r\n            if (!_(this.children).contains(child) && (_(this.allowedChildTypes).contains(child.type) || child.isContainable))\r\n                this.children.push(child);\r\n            child.setEditor(this.editor);\r\n            child.setIsTemplated(false);\r\n            child.setParent(this);\r\n        };\r\n\r\n        this.deleteChild = function (child) {\r\n            var index = _(this.children).indexOf(child);\r\n            if (index >= 0) {\r\n                this.children.splice(index, 1);\r\n                this.editor.recycleBin.add(child);\r\n                if (child.getIsActive())\r\n                    this.editor.activeElement = null;\r\n                if (child.getIsFocused()) {\r\n                    // If the deleted child was focused, try to set new focus to the most appropriate sibling or parent.\r\n                    if (this.children.length > index)\r\n                        this.children[index].setIsFocused();\r\n                    else if (index > 0)\r\n                        this.children[index - 1].setIsFocused();\r\n                    else\r\n                        this.setIsFocused();\r\n                }\r\n            }\r\n        };\r\n\r\n        this.moveFocusPrevChild = function (child) {\r\n            if (this.children.length < 2)\r\n                return;\r\n            var index = _(this.children).indexOf(child);\r\n            if (index > 0)\r\n                this.children[index - 1].setIsFocused();\r\n        };\r\n\r\n        this.moveFocusNextChild = function (child) {\r\n            if (this.children.length < 2)\r\n                return;\r\n            var index = _(this.children).indexOf(child);\r\n            if (index < this.children.length - 1)\r\n                this.children[index + 1].setIsFocused();\r\n        };\r\n\r\n        this.insertChild = function (child, afterChild) {\r\n            if (!_(this.children).contains(child)) {\r\n                var index = Math.max(_(this.children).indexOf(afterChild), 0);\r\n                this.children.splice(index + 1, 0, child);\r\n                child.setEditor(this.editor);\r\n                child.parent = this;\r\n            }\r\n        };\r\n\r\n        this.moveChildUp = function (child) {\r\n            if (!this.canMoveChildUp(child))\r\n                return;\r\n            var index = _(this.children).indexOf(child);\r\n            this.children.move(index, index - 1);\r\n        };\r\n\r\n        this.moveChildDown = function (child) {\r\n            if (!this.canMoveChildDown(child))\r\n                return;\r\n            var index = _(this.children).indexOf(child);\r\n            this.children.move(index, index + 1);\r\n        };\r\n\r\n        this.canMoveChildUp = function (child) {\r\n            var index = _(this.children).indexOf(child);\r\n            return index > 0;\r\n        };\r\n\r\n        this.canMoveChildDown = function (child) {\r\n            var index = _(this.children).indexOf(child);\r\n            return index < this.children.length - 1;\r\n        };\r\n\r\n        this.childrenToObject = function () {\r\n            return _(this.children).map(function (child) {\r\n                return child.toObject();\r\n            });\r\n        };\r\n\r\n        this.getInnerText = function () {\r\n            return _(this.children).reduce(function (memo, child) {\r\n                return memo + \"\\n\" + child.getInnerText();\r\n            }, \"\");\r\n        }\r\n\r\n        this.paste = function (clipboardData) {\r\n            var json = clipboardData.getData(\"text/json\");\r\n            if (!!json) {\r\n                var data = JSON.parse(json);\r\n                var child = LayoutEditor.elementFrom(data);\r\n                this.pasteChild(child);\r\n            }\r\n        };\r\n\r\n        this.pasteChild = function (child) {\r\n            if (_(this.allowedChildTypes).contains(child.type) || child.isContainable) {\r\n                this.addChild(child);\r\n                child.setIsFocused();\r\n            }\r\n            else if (!!this.parent)\r\n                this.parent.pasteChild(child);\r\n        }\r\n\r\n        this.getContainerTemplateStyles = function () {\r\n            var styles = this.containerTemplateStyles || {};\r\n            var css = \"\";\r\n\r\n            for (var property in styles) {\r\n                css += property + \":\" + styles[property] + \";\";\r\n            }\r\n\r\n            return css;\r\n        }\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Canvas = function (data, htmlId, htmlClass, htmlStyle, isTemplated, rule, children) {\r\n        LayoutEditor.Element.call(this, \"Canvas\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n        LayoutEditor.Container.call(this, [\"Canvas\", \"Grid\", \"Content\"], children);\r\n\r\n        this.isContainable = true;\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.children = this.childrenToObject();\r\n            return result;\r\n        };\r\n    };\r\n\r\n    LayoutEditor.Canvas.from = function (value) {\r\n        var result = new LayoutEditor.Canvas(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.rule,\r\n            LayoutEditor.childrenFrom(value.children));\r\n\r\n        result.toolboxIcon = value.toolboxIcon;\r\n        result.toolboxLabel = value.toolboxLabel;\r\n        result.toolboxDescription = value.toolboxDescription;\r\n\r\n        return result;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));\r\n","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Grid = function (data, htmlId, htmlClass, htmlStyle, isTemplated, rule, children) {\r\n        LayoutEditor.Element.call(this, \"Grid\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n        LayoutEditor.Container.call(this, [\"Row\"], children);\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.children = this.childrenToObject();\r\n            return result;\r\n        };\r\n    };\r\n\r\n    LayoutEditor.Grid.from = function (value) {\r\n        var result = new LayoutEditor.Grid(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.rule,\r\n            LayoutEditor.childrenFrom(value.children));\r\n        result.toolboxIcon = value.toolboxIcon;\r\n        result.toolboxLabel = value.toolboxLabel;\r\n        result.toolboxDescription = value.toolboxDescription;\r\n        return result;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Row = function (data, htmlId, htmlClass, htmlStyle, isTemplated, rule, children) {\r\n        LayoutEditor.Element.call(this, \"Row\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n        LayoutEditor.Container.call(this, [\"Column\"], children);\r\n\r\n        var _self = this;\r\n\r\n        function _getTotalColumnsWidth() {\r\n            return _(_self.children).reduce(function (memo, child) {\r\n                return memo + child.offset + child.width;\r\n            }, 0);\r\n        }\r\n\r\n        // Implements a simple algorithm to distribute space (either positive or negative)\r\n        // between the child columns of the row. Negative space is distributed when making\r\n        // room for a new column (e.c. clipboard paste or dropping from the toolbox) while\r\n        // positive space is distributed when filling the grap of a removed column.\r\n        function _distributeSpace(space) {\r\n            if (space == 0)\r\n                return true;\r\n             \r\n            var undistributedSpace = space;\r\n\r\n            if (undistributedSpace < 0) {\r\n                var vacantSpace = 12 - _getTotalColumnsWidth();\r\n                undistributedSpace += vacantSpace;\r\n                if (undistributedSpace > 0)\r\n                    undistributedSpace = 0;\r\n            }\r\n\r\n            // If space is negative, try to decrease offsets first.\r\n            while (undistributedSpace < 0 && _(_self.children).any(function (column) { return column.offset > 0; })) { // While there is still offset left to remove.\r\n                for (i = 0; i < _self.children.length && undistributedSpace < 0; i++) {\r\n                    var column = _self.children[i];\r\n                    if (column.offset > 0) {\r\n                        column.offset--;\r\n                        undistributedSpace++;\r\n                    }\r\n                }\r\n            }\r\n\r\n            function hasWidth(column) {\r\n                if (undistributedSpace > 0)\r\n                    return column.width < 12;\r\n                else if (undistributedSpace < 0)\r\n                    return column.width > 1;\r\n                return false;\r\n            }\r\n\r\n            // Try to distribute remaining space (could be negative or positive) using widths.\r\n            while (undistributedSpace != 0) {\r\n                // Any more column width available for distribution?\r\n                if (!_(_self.children).any(hasWidth))\r\n                    break;\r\n                for (i = 0; i < _self.children.length && undistributedSpace != 0; i++) {\r\n                    var column = _self.children[i % _self.children.length];\r\n                    if (hasWidth(column)) {\r\n                        var delta = undistributedSpace / Math.abs(undistributedSpace);\r\n                        column.width += delta;\r\n                        undistributedSpace -= delta;\r\n                    }\r\n                }                \r\n            }\r\n\r\n            return undistributedSpace == 0;\r\n        }\r\n\r\n        var _isAddingColumn = false;\r\n\r\n        this.canAddColumn = function () {\r\n            return this.children.length < 12;\r\n        };\r\n\r\n        this.beginAddColumn = function (newColumnWidth) {\r\n            if (!!_isAddingColumn)\r\n                throw new Error(\"Column add operation is already in progress.\")\r\n            _(this.children).each(function (column) {\r\n                column.beginChange();\r\n            });\r\n            if (_distributeSpace(-newColumnWidth)) {\r\n                _isAddingColumn = true;\r\n                return true;\r\n            }\r\n            _(this.children).each(function (column) {\r\n                column.rollbackChange();\r\n            });\r\n            return false;\r\n        };\r\n\r\n        this.commitAddColumn = function () {\r\n            if (!_isAddingColumn)\r\n                throw new Error(\"No column add operation in progress.\")\r\n            _(this.children).each(function (column) {\r\n                column.commitChange();\r\n            });\r\n            _isAddingColumn = false;\r\n        };\r\n\r\n        this.rollbackAddColumn = function () {\r\n            if (!_isAddingColumn)\r\n                throw new Error(\"No column add operation in progress.\")\r\n            _(this.children).each(function (column) {\r\n                column.rollbackChange();\r\n            });\r\n            _isAddingColumn = false;\r\n        };\r\n\r\n        var _baseDeleteChild = this.deleteChild;\r\n        this.deleteChild = function (column) { \r\n            var width = column.width;\r\n            _baseDeleteChild.call(this, column);\r\n            _distributeSpace(width);\r\n        };\r\n\r\n        this.canContractColumnRight = function (column, connectAdjacent) {\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0)\r\n                return column.width > 1;\r\n            return false;\r\n        };\r\n\r\n        this.contractColumnRight = function (column, connectAdjacent) {\r\n            if (!this.canContractColumnRight(column, connectAdjacent))\r\n                return;\r\n\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (column.width > 1) {\r\n                    column.width--;\r\n                    if (this.children.length > index + 1) {\r\n                        var nextColumn = this.children[index + 1];\r\n                        if (connectAdjacent && nextColumn.offset == 0)\r\n                            nextColumn.width++;\r\n                        else\r\n                            nextColumn.offset++;\r\n                    }\r\n                }\r\n            }\r\n        };\r\n\r\n        this.canExpandColumnRight = function (column, connectAdjacent) {\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (column.width >= 12)\r\n                    return false;\r\n                if (this.children.length > index + 1) {\r\n                    var nextColumn = this.children[index + 1];\r\n                    if (connectAdjacent && nextColumn.offset == 0)\r\n                        return nextColumn.width > 1;\r\n                    else\r\n                        return nextColumn.offset > 0;\r\n                }\r\n                return _getTotalColumnsWidth() < 12;\r\n            }\r\n            return false;\r\n        };\r\n\r\n        this.expandColumnRight = function (column, connectAdjacent) {\r\n            if (!this.canExpandColumnRight(column, connectAdjacent))\r\n                return;\r\n\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (this.children.length > index + 1) {\r\n                    var nextColumn = this.children[index + 1];\r\n                    if (connectAdjacent && nextColumn.offset == 0)\r\n                        nextColumn.width--;\r\n                    else\r\n                        nextColumn.offset--;\r\n                }\r\n                column.width++;\r\n            }\r\n        };\r\n\r\n        this.canExpandColumnLeft = function (column, connectAdjacent) {\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (column.width >= 12)\r\n                    return false;\r\n                if (index > 0) {\r\n                    var prevColumn = this.children[index - 1];\r\n                    if (connectAdjacent && column.offset == 0)\r\n                        return prevColumn.width > 1;\r\n                }\r\n                return column.offset > 0;\r\n            }\r\n            return false;\r\n        };\r\n\r\n        this.expandColumnLeft = function (column, connectAdjacent) {\r\n            if (!this.canExpandColumnLeft(column, connectAdjacent))\r\n                return;\r\n\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (index > 0) {\r\n                    var prevColumn = this.children[index - 1];\r\n                    if (connectAdjacent && column.offset == 0)\r\n                        prevColumn.width--;\r\n                    else\r\n                        column.offset--;\r\n                }\r\n                else\r\n                    column.offset--;\r\n                column.width++;\r\n            }\r\n        };\r\n\r\n        this.canContractColumnLeft = function (column, connectAdjacent) {\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0)\r\n                return column.width > 1;\r\n            return false;\r\n        };\r\n\r\n        this.contractColumnLeft = function (column, connectAdjacent) {\r\n            if (!this.canContractColumnLeft(column, connectAdjacent))\r\n                return;\r\n\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (index > 0) {\r\n                    var prevColumn = this.children[index - 1];\r\n                    if (connectAdjacent && column.offset == 0)\r\n                        prevColumn.width++;\r\n                    else\r\n                        column.offset++;\r\n                }\r\n                else\r\n                    column.offset++;\r\n                column.width--;\r\n            }\r\n        };\r\n\r\n        this.evenColumns = function () {\r\n            if (this.children.length == 0)\r\n                return;\r\n\r\n            var evenWidth = Math.floor(12 / this.children.length);\r\n            _(this.children).each(function (column) {\r\n                column.width = evenWidth;\r\n                column.offset = 0;\r\n            });\r\n\r\n            var rest = 12 % this.children.length;\r\n            if (rest > 0)\r\n                _distributeSpace(rest);\r\n        };\r\n\r\n        var _basePasteChild = this.pasteChild;\r\n        this.pasteChild = function (child) {\r\n            if (child.type == \"Column\") {\r\n                if (this.beginAddColumn(child.width)) {\r\n                    this.commitAddColumn();\r\n                    _basePasteChild.call(this, child)\r\n                }\r\n            }\r\n            else if (!!this.parent)\r\n                this.parent.pasteChild(child);\r\n        }\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.children = this.childrenToObject();\r\n            return result;\r\n        };\r\n    };\r\n\r\n    LayoutEditor.Row.from = function (value) {\r\n        var result = new LayoutEditor.Row(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.rule,\r\n            LayoutEditor.childrenFrom(value.children));\r\n        result.toolboxIcon = value.toolboxIcon;\r\n        result.toolboxLabel = value.toolboxLabel;\r\n        result.toolboxDescription = value.toolboxDescription;\r\n        return result;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n    LayoutEditor.Column = function (data, htmlId, htmlClass, htmlStyle, isTemplated, width, offset, collapsible, rule, children) {\r\n        LayoutEditor.Element.call(this, \"Column\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n        LayoutEditor.Container.call(this, [\"Grid\", \"Content\"], children);\r\n\r\n        this.width = width;\r\n        this.offset = offset;\r\n        this.collapsible = collapsible;\r\n\r\n        var _hasPendingChange = false;\r\n        var _origWidth = 0;\r\n        var _origOffset = 0;\r\n\r\n        this.beginChange = function () {\r\n            if (!!_hasPendingChange)\r\n                throw new Error(\"Column already has a pending change.\");\r\n            _hasPendingChange = true;\r\n            _origWidth = this.width;\r\n            _origOffset = this.offset;\r\n        };\r\n\r\n        this.commitChange = function () {\r\n            if (!_hasPendingChange)\r\n                throw new Error(\"Column has no pending change.\");\r\n            _origWidth = 0;\r\n            _origOffset = 0;\r\n            _hasPendingChange = false;\r\n        };\r\n\r\n        this.rollbackChange = function () {\r\n            if (!_hasPendingChange)\r\n                throw new Error(\"Column has no pending change.\");\r\n            this.width = _origWidth;\r\n            this.offset = _origOffset;\r\n            _origWidth = 0;\r\n            _origOffset = 0;\r\n            _hasPendingChange = false;\r\n        };\r\n\r\n        this.canSplit = function () {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.width > 1;\r\n        };\r\n\r\n        this.split = function () {\r\n            if (!this.canSplit())\r\n                return;\r\n\r\n            var newColumnWidth = Math.floor(this.width / 2);\r\n            var newColumn = LayoutEditor.Column.from({\r\n                data: null,\r\n                htmlId: null,\r\n                htmlClass: null,\r\n                htmlStyle: null,\r\n                width: newColumnWidth,\r\n                offset: 0,\r\n                children: []\r\n            });\r\n\r\n            this.width = this.width - newColumnWidth;\r\n            this.parent.insertChild(newColumn, this);\r\n            newColumn.setIsFocused();\r\n        };\r\n\r\n        this.canContractRight = function (connectAdjacent) {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.parent.canContractColumnRight(this, connectAdjacent);\r\n        };\r\n\r\n        this.contractRight = function (connectAdjacent) {\r\n            if (!this.canContractRight(connectAdjacent))\r\n                return;\r\n            this.parent.contractColumnRight(this, connectAdjacent);\r\n        };\r\n\r\n        this.canExpandRight = function (connectAdjacent) {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.parent.canExpandColumnRight(this, connectAdjacent);\r\n        };\r\n\r\n        this.expandRight = function (connectAdjacent) {\r\n            if (!this.canExpandRight(connectAdjacent))\r\n                return;\r\n            this.parent.expandColumnRight(this, connectAdjacent);\r\n        };\r\n\r\n        this.canExpandLeft = function (connectAdjacent) {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.parent.canExpandColumnLeft(this, connectAdjacent);\r\n        };\r\n\r\n        this.expandLeft = function (connectAdjacent) {\r\n            if (!this.canExpandLeft(connectAdjacent))\r\n                return;\r\n            this.parent.expandColumnLeft(this, connectAdjacent);\r\n        };\r\n\r\n        this.canContractLeft = function (connectAdjacent) {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.parent.canContractColumnLeft(this, connectAdjacent);\r\n        };\r\n\r\n        this.contractLeft = function (connectAdjacent) {\r\n            if (!this.canContractLeft(connectAdjacent))\r\n                return;\r\n            this.parent.contractColumnLeft(this, connectAdjacent);\r\n        };\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.width = this.width;\r\n            result.offset = this.offset;\r\n            result.collapsible = this.collapsible;\r\n            result.children = this.childrenToObject();\r\n            return result;\r\n        };\r\n    };\r\n\r\n    LayoutEditor.Column.from = function (value) {\r\n        var result = new LayoutEditor.Column(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.width,\r\n            value.offset,\r\n            value.collapsible,\r\n            value.rule,\r\n            LayoutEditor.childrenFrom(value.children));\r\n        result.toolboxIcon = value.toolboxIcon;\r\n        result.toolboxLabel = value.toolboxLabel;\r\n        result.toolboxDescription = value.toolboxDescription;\r\n        return result;\r\n    };\r\n\r\n    LayoutEditor.Column.times = function (value) {\r\n        return _.times(value, function (n) {\r\n            return LayoutEditor.Column.from({\r\n                data: null,\r\n                htmlId: null,\r\n                htmlClass: null,\r\n                isTemplated: false,\r\n                width: 12 / value,\r\n                offset: 0,\r\n                collapsible: null,\r\n                children: []\r\n            });\r\n        });\r\n    };\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Content = function (data, htmlId, htmlClass, htmlStyle, isTemplated, contentType, contentTypeLabel, contentTypeClass, html, hasEditor, rule) {\r\n        LayoutEditor.Element.call(this, \"Content\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n\r\n        this.contentType = contentType;\r\n        this.contentTypeLabel = contentTypeLabel;\r\n        this.contentTypeClass = contentTypeClass;\r\n        this.html = html;\r\n        this.hasEditor = hasEditor;\r\n\r\n        this.getInnerText = function () {\r\n            return $($.parseHTML(\"<div>\" + this.html + \"</div>\")).text();\r\n        };\r\n\r\n        // This function will be overwritten by the Content directive.\r\n        this.setHtml = function (html) {\r\n            this.html = html;\r\n            this.htmlUnsafe = html;\r\n        }\r\n\r\n        this.toObject = function () {\r\n            return {\r\n                \"type\": \"Content\"\r\n            };\r\n        };\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.contentType = this.contentType;\r\n            result.contentTypeLabel = this.contentTypeLabel;\r\n            result.contentTypeClass = this.contentTypeClass;\r\n            result.html = this.html;\r\n            result.hasEditor = hasEditor;\r\n            return result;\r\n        };\r\n\r\n        this.setHtml(html);\r\n    };\r\n\r\n    LayoutEditor.Content.from = function (value) {\r\n        var result = new LayoutEditor.Content(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.contentType,\r\n            value.contentTypeLabel,\r\n            value.contentTypeClass,\r\n            value.html,\r\n            value.hasEditor,\r\n            value.rule);\r\n\r\n        return result;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));"],"sourceRoot":"/source/"} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Models.js","Helpers.js","Editor.js","RecycleBin.js","Element.js","Container.js","Canvas.js","Grid.js","Row.js","Column.js","Content.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA,ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACtNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC3JA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACl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file":"Models.js","sourcesContent":[null,"var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    Array.prototype.move = function (from, to) {\r\n        this.splice(to, 0, this.splice(from, 1)[0]);\r\n    };\r\n\r\n    LayoutEditor.childrenFrom = function(values) {\r\n        return _(values).map(function(value) {\r\n            return LayoutEditor.elementFrom(value);\r\n        });\r\n    };\r\n\r\n    var registerFactory = LayoutEditor.registerFactory = function(type, factory) {\r\n        var factories = LayoutEditor.factories = LayoutEditor.factories || {};\r\n        factories[type] = factory;\r\n    };\r\n\r\n    registerFactory(\"Canvas\", function (value) { return LayoutEditor.Canvas.from(value); });\r\n    registerFactory(\"Grid\", function(value) { return LayoutEditor.Grid.from(value); });\r\n    registerFactory(\"Row\", function(value) { return LayoutEditor.Row.from(value); });\r\n    registerFactory(\"Column\", function(value) { return LayoutEditor.Column.from(value); });\r\n    registerFactory(\"Content\", function(value) { return LayoutEditor.Content.from(value); });\r\n\r\n    LayoutEditor.elementFrom = function (value) {\r\n        var factory = LayoutEditor.factories[value.type];\r\n\r\n        if (!factory)\r\n            throw new Error(\"No element with type \\\"\" + value.type + \"\\\" was found.\");\r\n\r\n        var element = factory(value);\r\n        return element;\r\n    };\r\n\r\n    LayoutEditor.setModel = function (elementSelector, model) {\r\n        $(elementSelector).scope().element = model;\r\n    };\r\n\r\n    LayoutEditor.getModel = function (elementSelector) {\r\n        return $(elementSelector).scope().element;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Editor = function (config, canvasData) {\r\n        this.config = config;\r\n        this.canvas = LayoutEditor.Canvas.from(canvasData);\r\n        this.initialState = JSON.stringify(this.canvas.toObject());\r\n        this.activeElement = null;\r\n        this.focusedElement = null;\r\n        this.dropTargetElement = null;\r\n        this.isDragging = false;\r\n        this.isResizing = false;\r\n        this.recycleBin = new LayoutEditor.RecycleBin();\r\n\r\n        this.resetToolboxElements = function () {\r\n            this.toolboxElements = [\r\n                LayoutEditor.Row.from({\r\n                    children: []\r\n                })\r\n            ];\r\n        };\r\n\r\n        this.isDirty = function() {\r\n            var currentState = JSON.stringify(this.canvas.toObject());\r\n            return this.initialState != currentState;\r\n        };\r\n\r\n        this.resetToolboxElements();\r\n        this.canvas.setEditor(this);\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));\r\n","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.RecycleBin = function () {\r\n        this.elements = [];\r\n\r\n        this.add = function(element) {\r\n            this.elements.push(element);\r\n        };\r\n\r\n        this.toObject = function () {\r\n            var result = {\r\n                type: \"RecycleBin\",\r\n                children: []\r\n            };\r\n\r\n            for (var i = 0; i < this.elements.length; i++) {\r\n                var element = this.elements[i];\r\n                var dto = element.toObject();\r\n                result.children.push(dto);\r\n            }\r\n\r\n            return result;\r\n        };\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));\r\n","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Element = function (type, data, htmlId, htmlClass, htmlStyle, isTemplated, rule) {\r\n        if (!type)\r\n            throw new Error(\"Parameter 'type' is required.\");\r\n\r\n        var self = this;\r\n        this.type = type;\r\n        this.data = data;\r\n        this.htmlId = htmlId;\r\n        this.htmlClass = htmlClass;\r\n        this.htmlStyle = htmlStyle;\r\n        this.isTemplated = isTemplated;\r\n        this.rule = rule;\r\n\r\n        this.templateStyles = {};\r\n        this.editor = null;\r\n        this.parent = null;\r\n        this.setIsFocusedEventHandlers = [];\r\n\r\n        this.setEditor = function (editor) {\r\n            this.editor = editor;\r\n            if (!!this.children && _.isArray(this.children)) {\r\n                _(this.children).each(function (child) {\r\n                    child.setEditor(editor);\r\n                });\r\n            }\r\n        };\r\n\r\n        this.setParent = function(parentElement) {\r\n            this.parent = parentElement;\r\n            this.parent.onChildAdded(this);\r\n\r\n            var currentAncestor = parentElement;\r\n            while (!!currentAncestor) {\r\n                currentAncestor.onDescendantAdded(this, parentElement);\r\n                currentAncestor = currentAncestor.parent;\r\n            }\r\n        };\r\n\r\n        this.setIsTemplated = function (value) {\r\n            this.isTemplated = value;\r\n            if (!!this.children && _.isArray(this.children)) {\r\n                _(this.children).each(function (child) {\r\n                    child.setIsTemplated(value);\r\n                });\r\n            }\r\n        };\r\n\r\n        this.applyElementEditorModel = function() { /* Virtual */ };\r\n\r\n        this.getIsActive = function () {\r\n            if (!this.editor)\r\n                return false;\r\n            return this.editor.activeElement === this && !this.getIsFocused();\r\n        };\r\n\r\n        this.setIsActive = function (value) {\r\n            if (!this.editor)\r\n                return;\r\n            if (this.editor.isDragging || this.editor.isResizing)\r\n                return;\r\n\r\n            if (value)\r\n                this.editor.activeElement = this;\r\n            else\r\n                this.editor.activeElement = this.parent;\r\n        };\r\n\r\n        this.getIsFocused = function () {\r\n            if (!this.editor)\r\n                return false;\r\n            return this.editor.focusedElement === this;\r\n        };\r\n\r\n        this.setIsFocused = function () {\r\n            if (!this.editor)\r\n            \treturn;\r\n            if (!this.children && this.isTemplated)\r\n            \treturn;\r\n            if (this.editor.isDragging || this.editor.isResizing)\r\n                return;\r\n\r\n            this.editor.focusedElement = this;\r\n            _(this.setIsFocusedEventHandlers).each(function (item) {\r\n                try {\r\n                    item();\r\n                }\r\n                catch (ex) {\r\n                    // Ignore.\r\n                }\r\n            });\r\n        };\r\n\r\n        this.getIsSelected = function () {\r\n            if (this.getIsFocused())\r\n                return true;\r\n\r\n            if (!!this.children && _.isArray(this.children)) {\r\n                return _(this.children).any(function(child) {\r\n                    return child.getIsSelected();\r\n                });\r\n            }\r\n\r\n            return false;\r\n        };\r\n\r\n        this.getIsDropTarget = function () {\r\n            if (!this.editor)\r\n                return false;\r\n            return this.editor.dropTargetElement === this;\r\n        }\r\n\r\n        this.setIsDropTarget = function (value) {\r\n            if (!this.editor)\r\n                return;\r\n            if (value)\r\n                this.editor.dropTargetElement = this;\r\n            else\r\n                this.editor.dropTargetElement = null;\r\n        };\r\n\r\n        this.canDelete = function () {\r\n            if (this.isTemplated || !this.parent)\r\n                return false;\r\n            return true;\r\n        };\r\n\r\n        this.delete = function () {\r\n            if (!this.canDelete())\r\n                return;\r\n            this.parent.deleteChild(this);\r\n        };\r\n\r\n        this.canMoveUp = function () {\r\n            if (this.isTemplated || !this.parent)\r\n                return false;\r\n            return this.parent.canMoveChildUp(this);\r\n        };\r\n\r\n        this.moveUp = function () {\r\n            if (!this.canMoveUp())\r\n                return;\r\n            this.parent.moveChildUp(this);\r\n        };\r\n\r\n        this.canMoveDown = function () {\r\n            if (this.isTemplated || !this.parent)\r\n                return false;\r\n            return this.parent.canMoveChildDown(this);\r\n        };\r\n\r\n        this.moveDown = function () {\r\n            if (!this.canMoveDown())\r\n                return;\r\n            this.parent.moveChildDown(this);\r\n        };\r\n\r\n        this.elementToObject = function () {\r\n            return {\r\n                type: this.type,\r\n                data: this.data,\r\n                htmlId: this.htmlId,\r\n                htmlClass: this.htmlClass,\r\n                htmlStyle: this.htmlStyle,\r\n                isTemplated: this.isTemplated,\r\n                rule: this.rule,\r\n                contentType: this.contentType,\r\n                hasEditor: this.hasEditor\r\n            };\r\n        };\r\n\r\n        this.getEditorObject = function() {\r\n            return {};\r\n        };\r\n\r\n        this.toObject = function () {\r\n            return self.elementToObject();\r\n        };\r\n\r\n        this.copy = function (clipboardData) {\r\n            var text = this.getInnerText();\r\n            clipboardData.setData(\"text/plain\", text);\r\n\r\n            var data = this.toObject();\r\n            var json = JSON.stringify(data, null, \"\\t\");\r\n            clipboardData.setData(\"text/json\", json);\r\n        };\r\n\r\n        this.cut = function (clipboardData) {\r\n            if (this.canDelete()) {\r\n                this.copy(clipboardData);\r\n                this.delete();\r\n            }\r\n        };\r\n\r\n        this.paste = function (clipboardData) {\r\n            if (!!this.parent)\r\n                this.parent.paste(clipboardData);\r\n        };\r\n\r\n        this.getTemplateStyles = function () {\r\n            var styles = this.templateStyles || {};\r\n            var css = \"\";\r\n\r\n            for (var property in styles) {\r\n                css += property + \":\" + styles[property] + \";\";\r\n            }\r\n\r\n            return css;\r\n        }\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Container = function (allowedChildTypes, children) {\r\n\r\n        this.allowedChildTypes = allowedChildTypes;\r\n        this.children = children;\r\n        this.isContainer = true;\r\n        this.containerTemplateStyles = {};\r\n\r\n        var self = this;\r\n\r\n        this.onChildAdded = function (element) { /* Virtual */ };\r\n        this.onDescendantAdded = function (element, parentElement) { /* Virtual */ };\r\n\r\n        this.setChildren = function (children) {\r\n            this.children = children;\r\n            _(this.children).each(function (child) {\r\n                child.setParent(self);\r\n            });\r\n        };\r\n\r\n        this.setChildren(children);\r\n\r\n        this.getIsSealed = function () {\r\n            return _(this.children).any(function (child) {\r\n                return child.isTemplated;\r\n            });\r\n        };\r\n\r\n        var _baseSetIsFocused = this.setIsFocused;\r\n        this.setIsFocused = function () {\r\n            if (this.getIsSealed())\r\n                return;\r\n            _baseSetIsFocused.call(this);\r\n        };\r\n\r\n        this.addChild = function (child) {\r\n            if (!_(this.children).contains(child) && (_(this.allowedChildTypes).contains(child.type) || child.isContainable))\r\n                this.children.push(child);\r\n            child.setEditor(this.editor);\r\n            child.setIsTemplated(false);\r\n            child.setParent(this);\r\n        };\r\n\r\n        this.deleteChild = function (child) {\r\n            var index = _(this.children).indexOf(child);\r\n            if (index >= 0) {\r\n                this.children.splice(index, 1);\r\n                this.editor.recycleBin.add(child);\r\n                if (child.getIsActive())\r\n                    this.editor.activeElement = null;\r\n                if (child.getIsFocused()) {\r\n                    // If the deleted child was focused, try to set new focus to the most appropriate sibling or parent.\r\n                    if (this.children.length > index)\r\n                        this.children[index].setIsFocused();\r\n                    else if (index > 0)\r\n                        this.children[index - 1].setIsFocused();\r\n                    else\r\n                        this.setIsFocused();\r\n                }\r\n            }\r\n        };\r\n\r\n        this.moveFocusPrevChild = function (child) {\r\n            if (this.children.length < 2)\r\n                return;\r\n            var index = _(this.children).indexOf(child);\r\n            if (index > 0)\r\n                this.children[index - 1].setIsFocused();\r\n        };\r\n\r\n        this.moveFocusNextChild = function (child) {\r\n            if (this.children.length < 2)\r\n                return;\r\n            var index = _(this.children).indexOf(child);\r\n            if (index < this.children.length - 1)\r\n                this.children[index + 1].setIsFocused();\r\n        };\r\n\r\n        this.insertChild = function (child, afterChild) {\r\n            if (!_(this.children).contains(child)) {\r\n                var index = Math.max(_(this.children).indexOf(afterChild), 0);\r\n                this.children.splice(index + 1, 0, child);\r\n                child.setEditor(this.editor);\r\n                child.parent = this;\r\n            }\r\n        };\r\n\r\n        this.moveChildUp = function (child) {\r\n            if (!this.canMoveChildUp(child))\r\n                return;\r\n            var index = _(this.children).indexOf(child);\r\n            this.children.move(index, index - 1);\r\n        };\r\n\r\n        this.moveChildDown = function (child) {\r\n            if (!this.canMoveChildDown(child))\r\n                return;\r\n            var index = _(this.children).indexOf(child);\r\n            this.children.move(index, index + 1);\r\n        };\r\n\r\n        this.canMoveChildUp = function (child) {\r\n            var index = _(this.children).indexOf(child);\r\n            return index > 0;\r\n        };\r\n\r\n        this.canMoveChildDown = function (child) {\r\n            var index = _(this.children).indexOf(child);\r\n            return index < this.children.length - 1;\r\n        };\r\n\r\n        this.childrenToObject = function () {\r\n            return _(this.children).map(function (child) {\r\n                return child.toObject();\r\n            });\r\n        };\r\n\r\n        this.getInnerText = function () {\r\n            return _(this.children).reduce(function (memo, child) {\r\n                return memo + \"\\n\" + child.getInnerText();\r\n            }, \"\");\r\n        }\r\n\r\n        this.paste = function (clipboardData) {\r\n            var json = clipboardData.getData(\"text/json\");\r\n            if (!!json) {\r\n                var data = JSON.parse(json);\r\n                var child = LayoutEditor.elementFrom(data);\r\n                this.pasteChild(child);\r\n            }\r\n        };\r\n\r\n        this.pasteChild = function (child) {\r\n            if (_(this.allowedChildTypes).contains(child.type) || child.isContainable) {\r\n                this.addChild(child);\r\n                child.setIsFocused();\r\n            }\r\n            else if (!!this.parent)\r\n                this.parent.pasteChild(child);\r\n        }\r\n\r\n        this.getContainerTemplateStyles = function () {\r\n            var styles = this.containerTemplateStyles || {};\r\n            var css = \"\";\r\n\r\n            for (var property in styles) {\r\n                css += property + \":\" + styles[property] + \";\";\r\n            }\r\n\r\n            return css;\r\n        }\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Canvas = function (data, htmlId, htmlClass, htmlStyle, isTemplated, rule, children) {\r\n        LayoutEditor.Element.call(this, \"Canvas\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n        LayoutEditor.Container.call(this, [\"Canvas\", \"Grid\", \"Content\"], children);\r\n\r\n        this.isContainable = true;\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.children = this.childrenToObject();\r\n            return result;\r\n        };\r\n    };\r\n\r\n    LayoutEditor.Canvas.from = function (value) {\r\n        var result = new LayoutEditor.Canvas(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.rule,\r\n            LayoutEditor.childrenFrom(value.children));\r\n\r\n        result.toolboxIcon = value.toolboxIcon;\r\n        result.toolboxLabel = value.toolboxLabel;\r\n        result.toolboxDescription = value.toolboxDescription;\r\n\r\n        return result;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));\r\n","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Grid = function (data, htmlId, htmlClass, htmlStyle, isTemplated, rule, children) {\r\n        LayoutEditor.Element.call(this, \"Grid\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n        LayoutEditor.Container.call(this, [\"Row\"], children);\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.children = this.childrenToObject();\r\n            return result;\r\n        };\r\n    };\r\n\r\n    LayoutEditor.Grid.from = function (value) {\r\n        var result = new LayoutEditor.Grid(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.rule,\r\n            LayoutEditor.childrenFrom(value.children));\r\n        result.toolboxIcon = value.toolboxIcon;\r\n        result.toolboxLabel = value.toolboxLabel;\r\n        result.toolboxDescription = value.toolboxDescription;\r\n        return result;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Row = function (data, htmlId, htmlClass, htmlStyle, isTemplated, rule, children) {\r\n        LayoutEditor.Element.call(this, \"Row\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n        LayoutEditor.Container.call(this, [\"Column\"], children);\r\n\r\n        var _self = this;\r\n\r\n        function _getTotalColumnsWidth() {\r\n            return _(_self.children).reduce(function (memo, child) {\r\n                return memo + child.offset + child.width;\r\n            }, 0);\r\n        }\r\n\r\n        // Implements a simple algorithm to distribute space (either positive or negative)\r\n        // between the child columns of the row. Negative space is distributed when making\r\n        // room for a new column (e.c. clipboard paste or dropping from the toolbox) while\r\n        // positive space is distributed when filling the grap of a removed column.\r\n        function _distributeSpace(space) {\r\n            if (space == 0)\r\n                return true;\r\n             \r\n            var undistributedSpace = space;\r\n\r\n            if (undistributedSpace < 0) {\r\n                var vacantSpace = 12 - _getTotalColumnsWidth();\r\n                undistributedSpace += vacantSpace;\r\n                if (undistributedSpace > 0)\r\n                    undistributedSpace = 0;\r\n            }\r\n\r\n            // If space is negative, try to decrease offsets first.\r\n            while (undistributedSpace < 0 && _(_self.children).any(function (column) { return column.offset > 0; })) { // While there is still offset left to remove.\r\n                for (i = 0; i < _self.children.length && undistributedSpace < 0; i++) {\r\n                    var column = _self.children[i];\r\n                    if (column.offset > 0) {\r\n                        column.offset--;\r\n                        undistributedSpace++;\r\n                    }\r\n                }\r\n            }\r\n\r\n            function hasWidth(column) {\r\n                if (undistributedSpace > 0)\r\n                    return column.width < 12;\r\n                else if (undistributedSpace < 0)\r\n                    return column.width > 1;\r\n                return false;\r\n            }\r\n\r\n            // Try to distribute remaining space (could be negative or positive) using widths.\r\n            while (undistributedSpace != 0) {\r\n                // Any more column width available for distribution?\r\n                if (!_(_self.children).any(hasWidth))\r\n                    break;\r\n                for (i = 0; i < _self.children.length && undistributedSpace != 0; i++) {\r\n                    var column = _self.children[i % _self.children.length];\r\n                    if (hasWidth(column)) {\r\n                        var delta = undistributedSpace / Math.abs(undistributedSpace);\r\n                        column.width += delta;\r\n                        undistributedSpace -= delta;\r\n                    }\r\n                }                \r\n            }\r\n\r\n            return undistributedSpace == 0;\r\n        }\r\n\r\n        var _isAddingColumn = false;\r\n\r\n        this.canAddColumn = function () {\r\n            return this.children.length < 12;\r\n        };\r\n\r\n        this.beginAddColumn = function (newColumnWidth) {\r\n            if (!!_isAddingColumn)\r\n                throw new Error(\"Column add operation is already in progress.\")\r\n            _(this.children).each(function (column) {\r\n                column.beginChange();\r\n            });\r\n            if (_distributeSpace(-newColumnWidth)) {\r\n                _isAddingColumn = true;\r\n                return true;\r\n            }\r\n            _(this.children).each(function (column) {\r\n                column.rollbackChange();\r\n            });\r\n            return false;\r\n        };\r\n\r\n        this.commitAddColumn = function () {\r\n            if (!_isAddingColumn)\r\n                throw new Error(\"No column add operation in progress.\")\r\n            _(this.children).each(function (column) {\r\n                column.commitChange();\r\n            });\r\n            _isAddingColumn = false;\r\n        };\r\n\r\n        this.rollbackAddColumn = function () {\r\n            if (!_isAddingColumn)\r\n                throw new Error(\"No column add operation in progress.\")\r\n            _(this.children).each(function (column) {\r\n                column.rollbackChange();\r\n            });\r\n            _isAddingColumn = false;\r\n        };\r\n\r\n        var _baseDeleteChild = this.deleteChild;\r\n        this.deleteChild = function (column) { \r\n            var width = column.width;\r\n            _baseDeleteChild.call(this, column);\r\n            _distributeSpace(width);\r\n        };\r\n\r\n        this.canContractColumnRight = function (column, connectAdjacent) {\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0)\r\n                return column.width > 1;\r\n            return false;\r\n        };\r\n\r\n        this.contractColumnRight = function (column, connectAdjacent) {\r\n            if (!this.canContractColumnRight(column, connectAdjacent))\r\n                return;\r\n\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (column.width > 1) {\r\n                    column.width--;\r\n                    if (this.children.length > index + 1) {\r\n                        var nextColumn = this.children[index + 1];\r\n                        if (connectAdjacent && nextColumn.offset == 0)\r\n                            nextColumn.width++;\r\n                        else\r\n                            nextColumn.offset++;\r\n                    }\r\n                }\r\n            }\r\n        };\r\n\r\n        this.canExpandColumnRight = function (column, connectAdjacent) {\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (column.width >= 12)\r\n                    return false;\r\n                if (this.children.length > index + 1) {\r\n                    var nextColumn = this.children[index + 1];\r\n                    if (connectAdjacent && nextColumn.offset == 0)\r\n                        return nextColumn.width > 1;\r\n                    else\r\n                        return nextColumn.offset > 0;\r\n                }\r\n                return _getTotalColumnsWidth() < 12;\r\n            }\r\n            return false;\r\n        };\r\n\r\n        this.expandColumnRight = function (column, connectAdjacent) {\r\n            if (!this.canExpandColumnRight(column, connectAdjacent))\r\n                return;\r\n\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (this.children.length > index + 1) {\r\n                    var nextColumn = this.children[index + 1];\r\n                    if (connectAdjacent && nextColumn.offset == 0)\r\n                        nextColumn.width--;\r\n                    else\r\n                        nextColumn.offset--;\r\n                }\r\n                column.width++;\r\n            }\r\n        };\r\n\r\n        this.canExpandColumnLeft = function (column, connectAdjacent) {\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (column.width >= 12)\r\n                    return false;\r\n                if (index > 0) {\r\n                    var prevColumn = this.children[index - 1];\r\n                    if (connectAdjacent && column.offset == 0)\r\n                        return prevColumn.width > 1;\r\n                }\r\n                return column.offset > 0;\r\n            }\r\n            return false;\r\n        };\r\n\r\n        this.expandColumnLeft = function (column, connectAdjacent) {\r\n            if (!this.canExpandColumnLeft(column, connectAdjacent))\r\n                return;\r\n\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (index > 0) {\r\n                    var prevColumn = this.children[index - 1];\r\n                    if (connectAdjacent && column.offset == 0)\r\n                        prevColumn.width--;\r\n                    else\r\n                        column.offset--;\r\n                }\r\n                else\r\n                    column.offset--;\r\n                column.width++;\r\n            }\r\n        };\r\n\r\n        this.canContractColumnLeft = function (column, connectAdjacent) {\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0)\r\n                return column.width > 1;\r\n            return false;\r\n        };\r\n\r\n        this.contractColumnLeft = function (column, connectAdjacent) {\r\n            if (!this.canContractColumnLeft(column, connectAdjacent))\r\n                return;\r\n\r\n            var index = _(this.children).indexOf(column);\r\n            if (index >= 0) {\r\n                if (index > 0) {\r\n                    var prevColumn = this.children[index - 1];\r\n                    if (connectAdjacent && column.offset == 0)\r\n                        prevColumn.width++;\r\n                    else\r\n                        column.offset++;\r\n                }\r\n                else\r\n                    column.offset++;\r\n                column.width--;\r\n            }\r\n        };\r\n\r\n        this.evenColumns = function () {\r\n            if (this.children.length == 0)\r\n                return;\r\n\r\n            var evenWidth = Math.floor(12 / this.children.length);\r\n            _(this.children).each(function (column) {\r\n                column.width = evenWidth;\r\n                column.offset = 0;\r\n            });\r\n\r\n            var rest = 12 % this.children.length;\r\n            if (rest > 0)\r\n                _distributeSpace(rest);\r\n        };\r\n\r\n        var _basePasteChild = this.pasteChild;\r\n        this.pasteChild = function (child) {\r\n            if (child.type == \"Column\") {\r\n                if (this.beginAddColumn(child.width)) {\r\n                    this.commitAddColumn();\r\n                    _basePasteChild.call(this, child)\r\n                }\r\n            }\r\n            else if (!!this.parent)\r\n                this.parent.pasteChild(child);\r\n        }\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.children = this.childrenToObject();\r\n            return result;\r\n        };\r\n    };\r\n\r\n    LayoutEditor.Row.from = function (value) {\r\n        var result = new LayoutEditor.Row(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.rule,\r\n            LayoutEditor.childrenFrom(value.children));\r\n        result.toolboxIcon = value.toolboxIcon;\r\n        result.toolboxLabel = value.toolboxLabel;\r\n        result.toolboxDescription = value.toolboxDescription;\r\n        return result;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n    LayoutEditor.Column = function (data, htmlId, htmlClass, htmlStyle, isTemplated, width, offset, collapsible, rule, children) {\r\n        LayoutEditor.Element.call(this, \"Column\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n        LayoutEditor.Container.call(this, [\"Grid\", \"Content\"], children);\r\n\r\n        this.width = width;\r\n        this.offset = offset;\r\n        this.collapsible = collapsible;\r\n\r\n        var _hasPendingChange = false;\r\n        var _origWidth = 0;\r\n        var _origOffset = 0;\r\n\r\n        this.beginChange = function () {\r\n            if (!!_hasPendingChange)\r\n                throw new Error(\"Column already has a pending change.\");\r\n            _hasPendingChange = true;\r\n            _origWidth = this.width;\r\n            _origOffset = this.offset;\r\n        };\r\n\r\n        this.commitChange = function () {\r\n            if (!_hasPendingChange)\r\n                throw new Error(\"Column has no pending change.\");\r\n            _origWidth = 0;\r\n            _origOffset = 0;\r\n            _hasPendingChange = false;\r\n        };\r\n\r\n        this.rollbackChange = function () {\r\n            if (!_hasPendingChange)\r\n                throw new Error(\"Column has no pending change.\");\r\n            this.width = _origWidth;\r\n            this.offset = _origOffset;\r\n            _origWidth = 0;\r\n            _origOffset = 0;\r\n            _hasPendingChange = false;\r\n        };\r\n\r\n        this.canSplit = function () {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.width > 1;\r\n        };\r\n\r\n        this.split = function () {\r\n            if (!this.canSplit())\r\n                return;\r\n\r\n            var newColumnWidth = Math.floor(this.width / 2);\r\n            var newColumn = LayoutEditor.Column.from({\r\n                data: null,\r\n                htmlId: null,\r\n                htmlClass: null,\r\n                htmlStyle: null,\r\n                width: newColumnWidth,\r\n                offset: 0,\r\n                children: []\r\n            });\r\n\r\n            this.width = this.width - newColumnWidth;\r\n            this.parent.insertChild(newColumn, this);\r\n            newColumn.setIsFocused();\r\n        };\r\n\r\n        this.canContractRight = function (connectAdjacent) {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.parent.canContractColumnRight(this, connectAdjacent);\r\n        };\r\n\r\n        this.contractRight = function (connectAdjacent) {\r\n            if (!this.canContractRight(connectAdjacent))\r\n                return;\r\n            this.parent.contractColumnRight(this, connectAdjacent);\r\n        };\r\n\r\n        this.canExpandRight = function (connectAdjacent) {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.parent.canExpandColumnRight(this, connectAdjacent);\r\n        };\r\n\r\n        this.expandRight = function (connectAdjacent) {\r\n            if (!this.canExpandRight(connectAdjacent))\r\n                return;\r\n            this.parent.expandColumnRight(this, connectAdjacent);\r\n        };\r\n\r\n        this.canExpandLeft = function (connectAdjacent) {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.parent.canExpandColumnLeft(this, connectAdjacent);\r\n        };\r\n\r\n        this.expandLeft = function (connectAdjacent) {\r\n            if (!this.canExpandLeft(connectAdjacent))\r\n                return;\r\n            this.parent.expandColumnLeft(this, connectAdjacent);\r\n        };\r\n\r\n        this.canContractLeft = function (connectAdjacent) {\r\n            if (this.isTemplated)\r\n                return false;\r\n            return this.parent.canContractColumnLeft(this, connectAdjacent);\r\n        };\r\n\r\n        this.contractLeft = function (connectAdjacent) {\r\n            if (!this.canContractLeft(connectAdjacent))\r\n                return;\r\n            this.parent.contractColumnLeft(this, connectAdjacent);\r\n        };\r\n\r\n        this.toObject = function () {\r\n            var result = this.elementToObject();\r\n            result.width = this.width;\r\n            result.offset = this.offset;\r\n            result.collapsible = this.collapsible;\r\n            result.children = this.childrenToObject();\r\n            return result;\r\n        };\r\n    };\r\n\r\n    LayoutEditor.Column.from = function (value) {\r\n        var result = new LayoutEditor.Column(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.width,\r\n            value.offset,\r\n            value.collapsible,\r\n            value.rule,\r\n            LayoutEditor.childrenFrom(value.children));\r\n        result.toolboxIcon = value.toolboxIcon;\r\n        result.toolboxLabel = value.toolboxLabel;\r\n        result.toolboxDescription = value.toolboxDescription;\r\n        return result;\r\n    };\r\n\r\n    LayoutEditor.Column.times = function (value) {\r\n        return _.times(value, function (n) {\r\n            return LayoutEditor.Column.from({\r\n                data: null,\r\n                htmlId: null,\r\n                htmlClass: null,\r\n                isTemplated: false,\r\n                width: 12 / value,\r\n                offset: 0,\r\n                collapsible: null,\r\n                children: []\r\n            });\r\n        });\r\n    };\r\n})(LayoutEditor || (LayoutEditor = {}));","var LayoutEditor;\r\n(function (LayoutEditor) {\r\n\r\n    LayoutEditor.Content = function (data, htmlId, htmlClass, htmlStyle, isTemplated, contentType, contentTypeLabel, contentTypeClass, html, hasEditor, rule) {\r\n        LayoutEditor.Element.call(this, \"Content\", data, htmlId, htmlClass, htmlStyle, isTemplated, rule);\r\n\r\n        this.contentType = contentType;\r\n        this.contentTypeLabel = contentTypeLabel;\r\n        this.contentTypeClass = contentTypeClass;\r\n        this.html = html;\r\n        this.hasEditor = hasEditor;\r\n\r\n        this.getInnerText = function () {\r\n            return $($.parseHTML(\"<div>\" + this.html + \"</div>\")).text();\r\n        };\r\n\r\n        // This function will be overwritten by the Content directive.\r\n        this.setHtml = function (html) {\r\n            this.html = html;\r\n            this.htmlUnsafe = html;\r\n        }\r\n\r\n        var baseToObject = this.toObject;\r\n        this.toObject = function () {\r\n            var result = baseToObject();\r\n            result.contentTypeLabel = this.contentTypeLabel;\r\n            result.contentTypeClass = this.contentTypeClass;\r\n            result.html = this.html;\r\n            return result;\r\n        };\r\n\r\n        this.setHtml(html);\r\n    };\r\n\r\n    LayoutEditor.Content.from = function (value) {\r\n        var result = new LayoutEditor.Content(\r\n            value.data,\r\n            value.htmlId,\r\n            value.htmlClass,\r\n            value.htmlStyle,\r\n            value.isTemplated,\r\n            value.contentType,\r\n            value.contentTypeLabel,\r\n            value.contentTypeClass,\r\n            value.html,\r\n            value.hasEditor,\r\n            value.rule);\r\n\r\n        return result;\r\n    };\r\n\r\n})(LayoutEditor || (LayoutEditor = {}));"],"sourceRoot":"/source/"} diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.min.js b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.min.js index 70a52d0b1..019cab2b3 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.min.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.min.js @@ -1 +1 @@ -var LayoutEditor;!function(t){Array.prototype.move=function(t,i){this.splice(i,0,this.splice(t,1)[0])},t.childrenFrom=function(i){return _(i).map(function(i){return t.elementFrom(i)})};var i=t.registerFactory=function(i,n){var e=t.factories=t.factories||{};e[i]=n};i("Canvas",function(i){return t.Canvas.from(i)}),i("Grid",function(i){return t.Grid.from(i)}),i("Row",function(i){return t.Row.from(i)}),i("Column",function(i){return t.Column.from(i)}),i("Content",function(i){return t.Content.from(i)}),t.elementFrom=function(i){var n=t.factories[i.type];if(!n)throw new Error('No element with type "'+i.type+'" was found.');var e=n(i);return e},t.setModel=function(t,i){$(t).scope().element=i},t.getModel=function(t){return $(t).scope().element}}(LayoutEditor||(LayoutEditor={}));var LayoutEditor;!function(t){t.Editor=function(i,n){this.config=i,this.canvas=t.Canvas.from(n),this.initialState=JSON.stringify(this.canvas.toObject()),this.activeElement=null,this.focusedElement=null,this.dropTargetElement=null,this.isDragging=!1,this.isResizing=!1,this.recycleBin=new t.RecycleBin,this.resetToolboxElements=function(){this.toolboxElements=[t.Row.from({children:[]})]},this.isDirty=function(){var t=JSON.stringify(this.canvas.toObject());return this.initialState!=t},this.resetToolboxElements(),this.canvas.setEditor(this)}}(LayoutEditor||(LayoutEditor={}));var LayoutEditor;!function(t){t.RecycleBin=function(){this.elements=[],this.add=function(t){this.elements.push(t)},this.toObject=function(){for(var t={type:"RecycleBin",children:[]},i=0;i=0&&(this.children.splice(i,1),this.editor.recycleBin.add(t),t.getIsActive()&&(this.editor.activeElement=null),t.getIsFocused()&&(this.children.length>i?this.children[i].setIsFocused():i>0?this.children[i-1].setIsFocused():this.setIsFocused()))},this.moveFocusPrevChild=function(t){if(!(this.children.length<2)){var i=_(this.children).indexOf(t);i>0&&this.children[i-1].setIsFocused()}},this.moveFocusNextChild=function(t){if(!(this.children.length<2)){var i=_(this.children).indexOf(t);i0},this.canMoveChildDown=function(t){var i=_(this.children).indexOf(t);return i0?t.width<12:0>e?t.width>1:!1}if(0==t)return!0;var e=t;if(0>e){var o=12-c();e+=o,e>0&&(e=0)}for(;0>e&&_(d.children).any(function(t){return t.offset>0});)for(i=0;ie;i++){var s=d.children[i];s.offset>0&&(s.offset--,e++)}for(;0!=e&&_(d.children).any(n);)for(i=0;i=0?t.width>1:!1},this.contractColumnRight=function(t,i){if(this.canContractColumnRight(t,i)){var n=_(this.children).indexOf(t);if(n>=0&&t.width>1&&(t.width--,this.children.length>n+1)){var e=this.children[n+1];i&&0==e.offset?e.width++:e.offset++}}},this.canExpandColumnRight=function(t,i){var n=_(this.children).indexOf(t);if(n>=0){if(t.width>=12)return!1;if(this.children.length>n+1){var e=this.children[n+1];return i&&0==e.offset?e.width>1:e.offset>0}return c()<12}return!1},this.expandColumnRight=function(t,i){if(this.canExpandColumnRight(t,i)){var n=_(this.children).indexOf(t);if(n>=0){if(this.children.length>n+1){var e=this.children[n+1];i&&0==e.offset?e.width--:e.offset--}t.width++}}},this.canExpandColumnLeft=function(t,i){var n=_(this.children).indexOf(t);if(n>=0){if(t.width>=12)return!1;if(n>0){var e=this.children[n-1];if(i&&0==t.offset)return e.width>1}return t.offset>0}return!1},this.expandColumnLeft=function(t,i){if(this.canExpandColumnLeft(t,i)){var n=_(this.children).indexOf(t);if(n>=0){if(n>0){var e=this.children[n-1];i&&0==t.offset?e.width--:t.offset--}else t.offset--;t.width++}}},this.canContractColumnLeft=function(t,i){var n=_(this.children).indexOf(t);return n>=0?t.width>1:!1},this.contractColumnLeft=function(t,i){if(this.canContractColumnLeft(t,i)){var n=_(this.children).indexOf(t);if(n>=0){if(n>0){var e=this.children[n-1];i&&0==t.offset?e.width++:t.offset++}else t.offset++;t.width--}}},this.evenColumns=function(){if(0!=this.children.length){var t=Math.floor(12/this.children.length);_(this.children).each(function(i){i.width=t,i.offset=0});var i=12%this.children.length;i>0&&a(i)}};var m=this.pasteChild;this.pasteChild=function(t){"Column"==t.type?this.beginAddColumn(t.width)&&(this.commitAddColumn(),m.call(this,t)):this.parent&&this.parent.pasteChild(t)},this.toObject=function(){var t=this.elementToObject();return t.children=this.childrenToObject(),t}},t.Row.from=function(i){var n=new t.Row(i.data,i.htmlId,i.htmlClass,i.htmlStyle,i.isTemplated,i.rule,t.childrenFrom(i.children));return n.toolboxIcon=i.toolboxIcon,n.toolboxLabel=i.toolboxLabel,n.toolboxDescription=i.toolboxDescription,n}}(LayoutEditor||(LayoutEditor={}));var LayoutEditor;!function(t){t.Column=function(i,n,e,o,s,h,r,l,c,a){t.Element.call(this,"Column",i,n,e,o,s,c),t.Container.call(this,["Grid","Content"],a),this.width=h,this.offset=r,this.collapsible=l;var d=!1,u=0,f=0;this.beginChange=function(){if(d)throw new Error("Column already has a pending change.");d=!0,u=this.width,f=this.offset},this.commitChange=function(){if(!d)throw new Error("Column has no pending change.");u=0,f=0,d=!1},this.rollbackChange=function(){if(!d)throw new Error("Column has no pending change.");this.width=u,this.offset=f,u=0,f=0,d=!1},this.canSplit=function(){return this.isTemplated?!1:this.width>1},this.split=function(){if(this.canSplit()){var i=Math.floor(this.width/2),n=t.Column.from({data:null,htmlId:null,htmlClass:null,htmlStyle:null,width:i,offset:0,children:[]});this.width=this.width-i,this.parent.insertChild(n,this),n.setIsFocused()}},this.canContractRight=function(t){return this.isTemplated?!1:this.parent.canContractColumnRight(this,t)},this.contractRight=function(t){this.canContractRight(t)&&this.parent.contractColumnRight(this,t)},this.canExpandRight=function(t){return this.isTemplated?!1:this.parent.canExpandColumnRight(this,t)},this.expandRight=function(t){this.canExpandRight(t)&&this.parent.expandColumnRight(this,t)},this.canExpandLeft=function(t){return this.isTemplated?!1:this.parent.canExpandColumnLeft(this,t)},this.expandLeft=function(t){this.canExpandLeft(t)&&this.parent.expandColumnLeft(this,t)},this.canContractLeft=function(t){return this.isTemplated?!1:this.parent.canContractColumnLeft(this,t)},this.contractLeft=function(t){this.canContractLeft(t)&&this.parent.contractColumnLeft(this,t)},this.toObject=function(){var t=this.elementToObject();return t.width=this.width,t.offset=this.offset,t.collapsible=this.collapsible,t.children=this.childrenToObject(),t}},t.Column.from=function(i){var n=new t.Column(i.data,i.htmlId,i.htmlClass,i.htmlStyle,i.isTemplated,i.width,i.offset,i.collapsible,i.rule,t.childrenFrom(i.children));return n.toolboxIcon=i.toolboxIcon,n.toolboxLabel=i.toolboxLabel,n.toolboxDescription=i.toolboxDescription,n},t.Column.times=function(i){return _.times(i,function(n){return t.Column.from({data:null,htmlId:null,htmlClass:null,isTemplated:!1,width:12/i,offset:0,collapsible:null,children:[]})})}}(LayoutEditor||(LayoutEditor={}));var LayoutEditor;!function(t){t.Content=function(i,n,e,o,s,h,r,l,c,a,d){t.Element.call(this,"Content",i,n,e,o,s,d),this.contentType=h,this.contentTypeLabel=r,this.contentTypeClass=l,this.html=c,this.hasEditor=a,this.getInnerText=function(){return $($.parseHTML("
    "+this.html+"
    ")).text()},this.setHtml=function(t){this.html=t,this.htmlUnsafe=t},this.toObject=function(){return{type:"Content"}},this.toObject=function(){var t=this.elementToObject();return t.contentType=this.contentType,t.contentTypeLabel=this.contentTypeLabel,t.contentTypeClass=this.contentTypeClass,t.html=this.html,t.hasEditor=a,t},this.setHtml(c)},t.Content.from=function(i){var n=new t.Content(i.data,i.htmlId,i.htmlClass,i.htmlStyle,i.isTemplated,i.contentType,i.contentTypeLabel,i.contentTypeClass,i.html,i.hasEditor,i.rule);return n}}(LayoutEditor||(LayoutEditor={})); \ No newline at end of file +var LayoutEditor;!function(t){Array.prototype.move=function(t,i){this.splice(i,0,this.splice(t,1)[0])},t.childrenFrom=function(i){return _(i).map(function(i){return t.elementFrom(i)})};var i=t.registerFactory=function(i,n){var e=t.factories=t.factories||{};e[i]=n};i("Canvas",function(i){return t.Canvas.from(i)}),i("Grid",function(i){return t.Grid.from(i)}),i("Row",function(i){return t.Row.from(i)}),i("Column",function(i){return t.Column.from(i)}),i("Content",function(i){return t.Content.from(i)}),t.elementFrom=function(i){var n=t.factories[i.type];if(!n)throw new Error('No element with type "'+i.type+'" was found.');var e=n(i);return e},t.setModel=function(t,i){$(t).scope().element=i},t.getModel=function(t){return $(t).scope().element}}(LayoutEditor||(LayoutEditor={}));var LayoutEditor;!function(t){t.Editor=function(i,n){this.config=i,this.canvas=t.Canvas.from(n),this.initialState=JSON.stringify(this.canvas.toObject()),this.activeElement=null,this.focusedElement=null,this.dropTargetElement=null,this.isDragging=!1,this.isResizing=!1,this.recycleBin=new t.RecycleBin,this.resetToolboxElements=function(){this.toolboxElements=[t.Row.from({children:[]})]},this.isDirty=function(){var t=JSON.stringify(this.canvas.toObject());return this.initialState!=t},this.resetToolboxElements(),this.canvas.setEditor(this)}}(LayoutEditor||(LayoutEditor={}));var LayoutEditor;!function(t){t.RecycleBin=function(){this.elements=[],this.add=function(t){this.elements.push(t)},this.toObject=function(){for(var t={type:"RecycleBin",children:[]},i=0;i=0&&(this.children.splice(i,1),this.editor.recycleBin.add(t),t.getIsActive()&&(this.editor.activeElement=null),t.getIsFocused()&&(this.children.length>i?this.children[i].setIsFocused():i>0?this.children[i-1].setIsFocused():this.setIsFocused()))},this.moveFocusPrevChild=function(t){if(!(this.children.length<2)){var i=_(this.children).indexOf(t);i>0&&this.children[i-1].setIsFocused()}},this.moveFocusNextChild=function(t){if(!(this.children.length<2)){var i=_(this.children).indexOf(t);i0},this.canMoveChildDown=function(t){var i=_(this.children).indexOf(t);return i0?t.width<12:0>e?t.width>1:!1}if(0==t)return!0;var e=t;if(0>e){var o=12-a();e+=o,e>0&&(e=0)}for(;0>e&&_(d.children).any(function(t){return t.offset>0});)for(i=0;ie;i++){var s=d.children[i];s.offset>0&&(s.offset--,e++)}for(;0!=e&&_(d.children).any(n);)for(i=0;i=0?t.width>1:!1},this.contractColumnRight=function(t,i){if(this.canContractColumnRight(t,i)){var n=_(this.children).indexOf(t);if(n>=0&&t.width>1&&(t.width--,this.children.length>n+1)){var e=this.children[n+1];i&&0==e.offset?e.width++:e.offset++}}},this.canExpandColumnRight=function(t,i){var n=_(this.children).indexOf(t);if(n>=0){if(t.width>=12)return!1;if(this.children.length>n+1){var e=this.children[n+1];return i&&0==e.offset?e.width>1:e.offset>0}return a()<12}return!1},this.expandColumnRight=function(t,i){if(this.canExpandColumnRight(t,i)){var n=_(this.children).indexOf(t);if(n>=0){if(this.children.length>n+1){var e=this.children[n+1];i&&0==e.offset?e.width--:e.offset--}t.width++}}},this.canExpandColumnLeft=function(t,i){var n=_(this.children).indexOf(t);if(n>=0){if(t.width>=12)return!1;if(n>0){var e=this.children[n-1];if(i&&0==t.offset)return e.width>1}return t.offset>0}return!1},this.expandColumnLeft=function(t,i){if(this.canExpandColumnLeft(t,i)){var n=_(this.children).indexOf(t);if(n>=0){if(n>0){var e=this.children[n-1];i&&0==t.offset?e.width--:t.offset--}else t.offset--;t.width++}}},this.canContractColumnLeft=function(t,i){var n=_(this.children).indexOf(t);return n>=0?t.width>1:!1},this.contractColumnLeft=function(t,i){if(this.canContractColumnLeft(t,i)){var n=_(this.children).indexOf(t);if(n>=0){if(n>0){var e=this.children[n-1];i&&0==t.offset?e.width++:t.offset++}else t.offset++;t.width--}}},this.evenColumns=function(){if(0!=this.children.length){var t=Math.floor(12/this.children.length);_(this.children).each(function(i){i.width=t,i.offset=0});var i=12%this.children.length;i>0&&c(i)}};var m=this.pasteChild;this.pasteChild=function(t){"Column"==t.type?this.beginAddColumn(t.width)&&(this.commitAddColumn(),m.call(this,t)):this.parent&&this.parent.pasteChild(t)},this.toObject=function(){var t=this.elementToObject();return t.children=this.childrenToObject(),t}},t.Row.from=function(i){var n=new t.Row(i.data,i.htmlId,i.htmlClass,i.htmlStyle,i.isTemplated,i.rule,t.childrenFrom(i.children));return n.toolboxIcon=i.toolboxIcon,n.toolboxLabel=i.toolboxLabel,n.toolboxDescription=i.toolboxDescription,n}}(LayoutEditor||(LayoutEditor={}));var LayoutEditor;!function(t){t.Column=function(i,n,e,o,s,h,r,l,a,c){t.Element.call(this,"Column",i,n,e,o,s,a),t.Container.call(this,["Grid","Content"],c),this.width=h,this.offset=r,this.collapsible=l;var d=!1,u=0,f=0;this.beginChange=function(){if(d)throw new Error("Column already has a pending change.");d=!0,u=this.width,f=this.offset},this.commitChange=function(){if(!d)throw new Error("Column has no pending change.");u=0,f=0,d=!1},this.rollbackChange=function(){if(!d)throw new Error("Column has no pending change.");this.width=u,this.offset=f,u=0,f=0,d=!1},this.canSplit=function(){return this.isTemplated?!1:this.width>1},this.split=function(){if(this.canSplit()){var i=Math.floor(this.width/2),n=t.Column.from({data:null,htmlId:null,htmlClass:null,htmlStyle:null,width:i,offset:0,children:[]});this.width=this.width-i,this.parent.insertChild(n,this),n.setIsFocused()}},this.canContractRight=function(t){return this.isTemplated?!1:this.parent.canContractColumnRight(this,t)},this.contractRight=function(t){this.canContractRight(t)&&this.parent.contractColumnRight(this,t)},this.canExpandRight=function(t){return this.isTemplated?!1:this.parent.canExpandColumnRight(this,t)},this.expandRight=function(t){this.canExpandRight(t)&&this.parent.expandColumnRight(this,t)},this.canExpandLeft=function(t){return this.isTemplated?!1:this.parent.canExpandColumnLeft(this,t)},this.expandLeft=function(t){this.canExpandLeft(t)&&this.parent.expandColumnLeft(this,t)},this.canContractLeft=function(t){return this.isTemplated?!1:this.parent.canContractColumnLeft(this,t)},this.contractLeft=function(t){this.canContractLeft(t)&&this.parent.contractColumnLeft(this,t)},this.toObject=function(){var t=this.elementToObject();return t.width=this.width,t.offset=this.offset,t.collapsible=this.collapsible,t.children=this.childrenToObject(),t}},t.Column.from=function(i){var n=new t.Column(i.data,i.htmlId,i.htmlClass,i.htmlStyle,i.isTemplated,i.width,i.offset,i.collapsible,i.rule,t.childrenFrom(i.children));return n.toolboxIcon=i.toolboxIcon,n.toolboxLabel=i.toolboxLabel,n.toolboxDescription=i.toolboxDescription,n},t.Column.times=function(i){return _.times(i,function(n){return t.Column.from({data:null,htmlId:null,htmlClass:null,isTemplated:!1,width:12/i,offset:0,collapsible:null,children:[]})})}}(LayoutEditor||(LayoutEditor={}));var LayoutEditor;!function(t){t.Content=function(i,n,e,o,s,h,r,l,a,c,d){t.Element.call(this,"Content",i,n,e,o,s,d),this.contentType=h,this.contentTypeLabel=r,this.contentTypeClass=l,this.html=a,this.hasEditor=c,this.getInnerText=function(){return $($.parseHTML("
    "+this.html+"
    ")).text()},this.setHtml=function(t){this.html=t,this.htmlUnsafe=t};var u=this.toObject;this.toObject=function(){var t=u();return t.contentTypeLabel=this.contentTypeLabel,t.contentTypeClass=this.contentTypeClass,t.html=this.html,t},this.setHtml(a)},t.Content.from=function(i){var n=new t.Content(i.data,i.htmlId,i.htmlClass,i.htmlStyle,i.isTemplated,i.contentType,i.contentTypeLabel,i.contentTypeClass,i.html,i.hasEditor,i.rule);return n}}(LayoutEditor||(LayoutEditor={})); \ No newline at end of file