implab/implabjs-djx Commit - r38:5c6c7e16919c

Fixes in WidgetContex, added _Container.addChild support

cin -

r38:5c6c7e16919c v1.0.0-rc18 default

parent child

Context file:

r38:5c6c7e16919c

Collapse all files

src/main/ts/dom-inject.ts +2 -2

              class DomInject {
                  injectionPoint?: HTMLElement;
-                 injectBefore?: HTMLElement;
+                 injectAfter?: HTMLElement;
                  _map: MapOf<Promise<NodeLoadResult>> = {};
                          mixin(node, attr);
                          const _injectionPoint = this.injectionPoint || document.head;
-                         const _injectBefore = this.injectBefore || _injectionPoint.firstChild;
+                         const _injectBefore = this.injectAfter ? this.injectAfter.nextSibling : null;
                          _injectionPoint.insertBefore(node, _injectBefore);
                      });

src/main/ts/tsx/BuildContextBase.ts +16 -4

              import { isPlainObject, isNode, isBuildContext, DojoNodePosition, BuildContext } from "./traits";
              import dom = require("dojo/dom-construct");
+             import registry = require("dijit/registry");
              export abstract class BuildContextBase<TNode extends Node> implements BuildContext<TNode> {
                  private _attrs = {};
                      }
                  }
-                 abstract _getDomNode(): TNode;
                  ensureCreated() {
                      if (!this._created) {
                          this._create(this._attrs, this._children);
                      }
                  }
-                 /** @deprecated use getDomNode() */
+                 /** @deprecated will be removed in 1.0.0, use getDomNode() */
                  getDomElement() {
                      return this.getDomNode();
                  }
+                 /** Creates DOM node if not created. No additional actions are taken. */
                  getDomNode() {
                      this.ensureCreated();
                      return this._getDomNode();
                  }
+                 /** Creates DOM node if not created, places it to the specified position
+                  * and calls startup() method for all widgets contained by this node.
+                  *
+                  * @param {string | Node} refNode The reference node where the created
+                  *   DOM should be placed.
+                  * @param {DojoNodePosition} position Optional parameter, specifies the
+                  *   position relative to refNode. Default is "last" (i.e. last child).
+                  */
                  placeAt(refNode: string | Node, position?: DojoNodePosition) {
-                     dom.place(this.getDomNode(), refNode, position);
+                     const domNode = this.getDomNode();
+                     dom.place(domNode, refNode, position);
+                     registry.findWidgets(domNode).forEach(w => w.startup());
                  }
                  abstract _create(attrs: object, children: any[]): void;
+                 abstract _getDomNode(): TNode;
              }

src/main/ts/tsx/DjxFragment.ts +2 -9

              /** Special widget used to create a document fragment */
              export class DjxFragment implements _Widget {
-                 @prototype()
                  domNode: Node;
                  containerNode?: Node;
                  constructor() {
                      this.domNode = this.containerNode = document.createDocumentFragment();
                  }
-                 get(attr: string) {
-                     return undefined;
+                 }
-                 set(attr: string, value: any): void;
-                 set(attrs: MapOf<any>): void;
-                 set() {
-                     /* do nothing */
+                 buildRendering() {
+                     // this function marks this class as _Widget
                  }
              }
  No newline at end of file

src/main/ts/tsx/WidgetContext.ts +53 -9

              import dom = require("dojo/dom-construct");
              import { argumentNotNull } from "@implab/core-amd/safe";
              import { BuildContextBase } from "./BuildContextBase";
-             import { MapOf } from "@implab/core-amd/interfaces";
+             import { DojoNodePosition, isWidget } from "./traits";
              // tslint:disable-next-line: class-name
              export interface _Widget {
                  domNode: Node;
-                 get(attr: string): any;
+                 containerNode?: Node;
-                 set(attr: string, value: any): void;
-                 set(attrs: MapOf<any>): void;
+                 placeAt?(refNode: string | Node, position?: DojoNodePosition): void;
+                 startup?(): void;
-                 containerNode?: Node
+                 addChild?(widget: any, index?: number): void;
              }
              export type _WidgetCtor = new (attrs: any, srcNode?: string | Node) => _Widget;
              export class WidgetContext extends BuildContextBase<Node> {
-                 widgetClass: _WidgetCtor;
+                 readonly widgetClass: _WidgetCtor;
                  _instance: _Widget | undefined;
                  }
                  _addChild(child: any): void {
-                     if (!this._instance || !this._instance.containerNode)
-                         throw new Error("Widget doesn't support adding children");
+                     const instance = this._getInstance();
-                     dom.place(this.getChildDom(child), this._instance.containerNode);
+                     if (instance.addChild) {
+                         if (child instanceof WidgetContext)
+                             // layout containers add custom logic to addChild methods
+                             instance.addChild(child.getWidgetInstance());
+                         else if (isWidget(child))
+                             instance.addChild(child);
+                         else
+                             instance.addChild(this.getChildDom(child));
+                     } else {
+                         if (!instance.containerNode)
+                             throw new Error("The widget doesn't have neither addChild nor containerNode");
+                         // the current widget isn't started, it's children shouldn't start too
+                         dom.place(this.getChildDom(child), instance.containerNode);
+                     }
                  }
                  _create(attrs: object, children: any[]) {
                          children.forEach(x => this._addChild(x));
                  }
+                 private _getInstance() {
+                     if (!this._instance)
+                         throw new Error("The instance of the widget isn't created");
+                     return this._instance;
+                 }
                  _getDomNode() {
                      if (!this._instance)
                          throw new Error("The instance of the widget isn't created");
                      return this._instance.domNode;
                  }
+                 /** Overrides default placeAt implementation. Calls placeAt of the
+                  * widget and then starts it.
+                  *
+                  * @param refNode A node or id of the node where the widget should be placed.
+                  * @param position A position relative to refNode.
+                  */
+                 placeAt(refNode: string | Node, position?: DojoNodePosition) {
+                     this.ensureCreated();
+                     const instance = this._getInstance();
+                     if (typeof instance.placeAt === "function") {
+                         instance.placeAt(refNode, position);
+                         // do we need to force widget startup?
+                         if (typeof instance.startup === "function")
+                             instance.startup();
+                     } else {
+                         super.placeAt(refNode, position);
              }
+                 }
+                 getWidgetInstance() {
+                     this.ensureCreated();
+                     return this._getInstance();
+                 }
+             }

src/main/ts/tsx/traits.ts +4 -1

              }
              export function isWidgetConstructor(v: any): v is _WidgetBaseConstructor {
-                 return typeof v === "function" && v.prototype && "domNode" in v.prototype;
+                 return typeof v === "function" && v.prototype && (
+                     "domNode" in v.prototype ||
+                     "buildRendering" in v.prototype
+                 );
              }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages