public HashMap<StyleExtensionMapEntry> getExtensionsForFragment(HtmlElement element)
{
var hashmap = new HashMap<StyleExtensionMapEntry>();
//We need to loop over all of the relevant entries in the map that define some behavior
var allEntries = map.getAllRandoriSelectorEntries();
for ( var i=0; i<allEntries.length; i++) {
JsArray<HtmlElement> implementingNodes = findChildNodesForCompoundSelector(element, allEntries[i]);
//For each of those entries, we need to see if we have any elements in this DOM fragment that implement any of those classes
for ( var j=0; j<implementingNodes.length; j++) {
var implementingElement = implementingNodes[ j ];
var value = hashmap.get( implementingElement );
if ( value == null ) {
//Get the needed entry
var extensionEntry = map.getExtensionEntry(allEntries[i]);
//give us a copy so we can screw with it at will
hashmap.put(implementingElement, extensionEntry.clone());
} else {
//We already have data for this node, so we need to merge the new data into the existing one
var extensionEntry = map.getExtensionEntry(allEntries[i]);
extensionEntry.mergeTo( (StyleExtensionMapEntry)value );
}
}
}
//return the hashmap which can be queried and applied to the Dom
return hashmap;
}
public void AddClass(HtmlElement elem, string className)
{
string thisClass = elem.className;
if (!thisClass.Contains(className))
{
thisClass += " " + className;
}
elem.className = thisClass;
}
public InjectionClassBuilder buildChildClassBuilder(InjectionClassBuilder classBuilder, HtmlElement element, JsString contextClassName)
{
var module = (GuiceModule)classBuilder.buildClass(contextClassName);
var injector = (ChildInjector)classBuilder.buildClass("guice.ChildInjector");
var guiceJs = new GuiceJs();
guiceJs.configureInjector(injector, module);
//Setup a new InjectionClassBuilder
return (InjectionClassBuilder)injector.getInstance(typeof(InjectionClassBuilder));
}
protected override IScoreRenderer CreateScoreRenderer(Settings settings, object rawSettings, HtmlElement canvasElement)
{
var renderer = new WorkerScoreRenderer(this, rawSettings);
renderer.PostRenderFinished += () =>
{
Element.className = Element.className.replace(" loading", "")
.replace(" rendering", "");
};
return renderer;
}
public void resolveContent(HtmlElement element)
{
var content = element.getAttribute("data-content");
//Clean up any of our properties embedded in the DOM
element.removeAttribute("data-content");
if (content == null) {
//content = map.getExtensionValue("content");
}
//load the content
}
private void investigateDomElement(HtmlElement element, AbstractBehavior parentBehavior)
{
var currentBehavior = parentBehavior;
var domWalker = this;
var id = element.getAttribute("id");
if (id != null) {
//we have a reference to the element now, so remove the id so we dont have to deal with conflicts and clashes
element.removeAttribute("id");
}
var elementDescriptor = elementDescriptorFactory.describeElement(element, extensionsToBeApplied);
if (elementDescriptor.context != null) {
//change the class builder for everything under this point in the DOM
classBuilder = domExtensionFactory.buildChildClassBuilder(classBuilder, element, elementDescriptor.context);
//change the domWalker for everything under this point in the DOM
domWalker = (DomWalker)classBuilder.buildClass("randori.dom.DomWalker");
}
if (elementDescriptor.behavior != null) {
//build a context for this behavior IF it turns out that this particular element defines one
currentBehavior = domExtensionFactory.buildBehavior( classBuilder, element, elementDescriptor.behavior );
//we have a new behavior, this effectively causes us to use a new context for the nodes below it
//Make sure we add ourselves to our parent though
if (parentBehavior != null) {
parentBehavior.injectPotentialNode(id, currentBehavior);
}
} else {
if (id != null && currentBehavior != null) {
currentBehavior.injectPotentialNode(id, jQueryContext.J(element));
}
}
if (elementDescriptor.fragment != null) {
//build a context for this behavior IF it turns out that this particular element defines one
domExtensionFactory.buildNewContent(element, elementDescriptor.fragment);
//change the domWalker for everything under this point in the DOM
domWalker = (DomWalker)classBuilder.buildClass("randori.dom.DomWalker");
}
domWalker.walkChildren(element, currentBehavior);
//Now that we have figured out all of the items under this dom element, setup the behavior
if (currentBehavior != null && currentBehavior != parentBehavior) {
currentBehavior.verifyAndRegister();
}
}
public AbstractBehavior buildBehavior(InjectionClassBuilder classBuilder, HtmlElement element, JsString behaviorClassName )
{
AbstractBehavior behavior = null;
var resolution = classResolver.resolveClassName(behaviorClassName);
if ( resolution.builtIn ) {
/** If we have a type which was not created via Randori, we send it out to get created. In this way
* we dont worry about injection data and we allow for any crazy creation mechanism the client can
* consider **/
behavior = externalBehaviorFactory.createExternalBehavior(element, behaviorClassName, resolution.type);
} else {
behavior = (AbstractBehavior)classBuilder.buildClass(behaviorClassName);
behavior.provideDecoratedElement(element);
}
return behavior;
}
public void Open()
{
_id = Id + NextId;
_swfId = _id + "swf";
Lookup[_id] = this;
NextId++;
_swfContainer = document.createElement("div").As<HtmlElement>();
_swfContainer.className = Id;
_swfContainer.setAttribute("id", _id);
document.body.appendChild(_swfContainer);
var swf = JsCode("swfobject");
var embedSwf = swf.Member("embedSWF").As<Action<string, string, string, string, string, string, object, object, object>>();
embedSwf(
_asRoot + "AlphaSynth.FlashOutput.swf",
_id, "1px", "1px", "9.0.0",
_swfObjectRoot + "expressInstall.swf",
new { id = _id, sampleRate = PreferredSampleRate }, new { allowScriptAccess = "always" }, new { id = _swfId }
);
}
public ElementDescriptor describeElement(HtmlElement element )
{
//This is purely an efficiency gain. By making a merged map for this one element, we stop everyone from cycling through
//every class on an element to pull out their own piece of data
var entry = styleExtensionManager.getMergedEntryForElement(element);
var descriptor = new ElementDescriptor {
context = element.getAttribute("data-context"),
behavior = element.hasAttribute("data-mediator") ? element.getAttribute("data-mediator") : element.getAttribute("data-behavior"),
fragment = element.getAttribute("data-fragment"),
formatter = element.getAttribute( "data-formatter" ),
validator = element.getAttribute( "data-validator" )
};
if ( entry != null ) {
if (descriptor.context == null) {
descriptor.context = entry.getExtensionClass("module");
}
if (descriptor.behavior == null) {
//mediator and behavior are really the same thing and hence mutually exclusive
descriptor.behavior = entry.hasExtensionType("mediator")?entry.getExtensionClass("mediator"):entry.getExtensionClass("behavior");
}
if (descriptor.fragment == null) {
descriptor.fragment = entry.getExtensionClass("fragment");
}
if (descriptor.formatter == null) {
descriptor.formatter = entry.getExtensionClass("formatter");
}
if (descriptor.validator == null) {
descriptor.validator = entry.getExtensionClass("validator");
}
}
return descriptor;
}
public void tree(HtmlElement element) { }
/// <summary>
/// Internal function, which may be overridden through the options parameter on creation
/// </summary>
/// <param name="element"></param>
/// <param name="dropon"></param>
/// <param name="overlap"></param>
public void findElements(HtmlElement element, object dropon, object overlap) { }
public void destroy(HtmlElement element) { }
public SwitchOff(HtmlElement el, EffectOptions options)
: base(el, options)
{
}
public Squish(HtmlElement el, EffectOptions options)
: base(el, options)
{
}
public SlideUp(HtmlElement el, BlindOptions options)
: base(el, options)
{
}
public Shrink(HtmlElement el)
: base(el, null)
{
}
public Shrink(HtmlElement el, GrowOptions options)
: base(el, options)
{
}
public Fold(HtmlElement el)
: base(el, null)
{
}
public Squish(HtmlElement el)
: base(el, null)
{
}
public Fold(HtmlElement el, EffectOptions options)
: base(el, options)
{
}
public SwitchOff(HtmlElement el)
: base(el, null)
{
}
public Grow(HtmlElement el)
: base(el, null)
{
}
public void options(HtmlElement element) { }
public Grow(HtmlElement el, GrowOptions options)
: base(el, options)
{
}
public void create(HtmlElement element, SortableCreateOptions options) { }
public Pulsate(HtmlElement el, EffectOptions options)
: base(el, options)
{
}
//TODO: ?
public void onEmptyHover(HtmlElement element, object dropon, object overlap) { }
public Shake(HtmlElement el)
: base(el, null)
{
}
public JsWorkerApi(HtmlElement element, object options)
: base(element, options)
{
}
public Shake(HtmlElement el, ShakeOptions options)
: base(el, options)
{
}
