Example #1
0
        private ColorPicker BuildColorPicker(object data, BuildContext bc)
        {
            ColorPickerProperties properties = DataNodeWrapper.GetNodeAttributes(data).To <ColorPickerProperties>();

            JSObject[] colorNodes = DataNodeWrapper.GetNodeChildren(
                DataNodeWrapper.GetFirstChildNodeWithName(data,
                                                          DataNodeWrapper.Colors));
            int numColors = colorNodes.Length;

            ColorStyle[] colors = new ColorStyle[numColors];
            for (int i = 0; i < numColors; i++)
            {
                ColorStyle color = new ColorStyle();
                JSObject   dict  = DataNodeWrapper.GetNodeAttributes(colorNodes[i]);
                string     title = DataNodeWrapper.GetAttribute(dict, DataNodeWrapper.TITLE);
                color.Title = string.IsNullOrEmpty(title) ?
                              DataNodeWrapper.GetAttribute(dict, DataNodeWrapper.ALT) : title;
                color.Color        = DataNodeWrapper.GetAttribute(dict, DataNodeWrapper.COLOR);
                color.DisplayColor = DataNodeWrapper.GetAttribute(dict, DataNodeWrapper.DISPLAYCOLOR);
                color.Style        = DataNodeWrapper.GetAttribute(dict, DataNodeWrapper.STYLE);
                colors[i]          = color;
            }


            ColorPicker cp = new ColorPicker(Root,
                                             properties.Id,
                                             properties,
                                             colors);

            return(cp);
        }
Example #2
0
        private void OnReturnJewel(DataQueryResult dqr)
        {
            JewelBuildContext jbc = (JewelBuildContext)dqr.ContextData;

            // Apply any extensions to the data.
            dqr.QueryData = ApplyDataExtensions(dqr.QueryData);

            JSObject jewelNode = DataNodeWrapper.GetFirstChildNodeWithName(dqr.QueryData, DataNodeWrapper.JEWEL);

            Jewel = BuildJewelInternal(jewelNode, jbc);
            Jewel.JewelBuilder = this;
            BuildClient.OnComponentCreated(Jewel, Jewel.Id);

            if (JewelBuildOptions.AttachToDOM)
            {
                Jewel.AttachInternal(true);
            }
            else
            {
                Jewel.RefreshInternal();
                Placeholder.AppendChild(Jewel.ElementInternal);
                Utility.EnsureCSSClassOnElement(Placeholder, "loaded");
            }
            OnRootBuilt(Jewel);
            BuildClient.OnComponentBuilt(Jewel, Jewel.Id);
        }
Example #3
0
        private void HandleRow(Row row, JSObject data, DeclarativeTemplateBuildContext bc)
        {
            JSObject[] children = DataNodeWrapper.GetNodeChildren(data);
            for (int i = 0; i < children.Length; i++)
            {
                string    name = DataNodeWrapper.GetNodeName(children[i]);
                Component comp = null;

                if (name == DataNodeWrapper.CONTROL)
                {
                    comp = CreateControlComponentFromData(children[i], bc);
                }
                else if (name == DataNodeWrapper.OVERFLOWAREA)
                {
                    HandleOverflow(children[i], bc, row, i);
                }
                else
                {
                    comp = CreateStripFromData(children[i], bc, row, i);
                }

                if (!CUIUtility.IsNullOrUndefined(comp))
                {
                    row.AddChild(comp);
                }
            }
        }
Example #4
0
        private QAT BuildQATInternal(object data, QATBuildContext qbc)
        {
            if (CUIUtility.IsNullOrUndefined(data))
            {
                throw new ArgumentNullException("No QAT element was present in the data");
            }

            QAT = new QAT(DataNodeWrapper.GetAttribute(data, "Id"),
                          DataNodeWrapper.GetNodeAttributes(data).To <QATProperties>());

            // Handle the controls in the QAT
            // The XML structure looks like <QAT><Controls><Control></Control><Control></Control>...
            JSObject controlsParent = DataNodeWrapper.GetFirstChildNodeWithName(data, DataNodeWrapper.CONTROLS);

            JSObject[] controls = DataNodeWrapper.GetNodeChildren(controlsParent);
            for (int j = 0; j < controls.Length; j++)
            {
                if (!IsNodeTrimmed(controls[j]))
                {
                    Control control = BuildControl(controls[j], qbc);
                    QAT.AddChild(control.CreateComponentForDisplayMode("Small"));
                }
            }

            return(QAT);
        }
Example #5
0
        private GalleryButton BuildGalleryButton(object data, BuildContext bc, string strElmDims)
        {
            GalleryElementDimensions elmDims;

            // If elmDims is null, try to get the value from data
            if (string.IsNullOrEmpty(strElmDims))
            {
                JSObject attrs = DataNodeWrapper.GetNodeAttributes(data);
                strElmDims = DataNodeWrapper.GetAttribute(attrs, DataNodeWrapper.ELEMENTDIMENSIONS);
            }
            // If elmDims is still null (no value defined in data), default to 32x32
            if (string.IsNullOrEmpty(strElmDims))
            {
                elmDims = GalleryElementDimensions.Size32by32;
            }
            else
            {
                elmDims = Gallery.ConvertStringToGalleryElementDimensions(strElmDims);
            }

            GalleryButtonProperties properties =
                DataNodeWrapper.GetNodeAttributes(data).To <GalleryButtonProperties>();
            GalleryButton gb = new GalleryButton(Root,
                                                 properties.Id,
                                                 properties,
                                                 elmDims);

            return(gb);
        }
Example #6
0
        private Strip CreateStripFromData(object data,
                                          DeclarativeTemplateBuildContext bc,
                                          Component parent,
                                          int rowComponentNumber)
        {
            JSObject[] children = DataNodeWrapper.GetNodeChildren(data);
            Strip      strip    = bc.Ribbon.CreateStrip(parent.Id + "-" + rowComponentNumber);

            for (int i = 0; i < children.Length; i++)
            {
                string name = DataNodeWrapper.GetNodeName(children[i]);
                if (name == DataNodeWrapper.CONTROL)
                {
                    ControlComponent comp = CreateControlComponentFromData(children[i], bc);
                    if (!CUIUtility.IsNullOrUndefined(comp))
                    {
                        strip.AddChild(comp);
                    }
                }
                else
                {
                    HandleOverflow(children[i], bc, strip, i);
                }
            }

            // If there are no children in the strip then there is no reason to add it
            // If we ever support dynamically adding and removing components out of the ribbon
            // then this will need to be revisitited.
            if (strip.Children.Count == 0)
            {
                return(null);
            }

            return(strip);
        }
Example #7
0
        public override Group CreateGroup(SPRibbon ribbon,
                                          string id,
                                          GroupProperties properties,
                                          string title,
                                          string description,
                                          string command,
                                          Dictionary <string, List <Control> > controls,
                                          Dictionary <string, string> pars)
        {
            DeclarativeTemplateBuildContext bc = new DeclarativeTemplateBuildContext();

            bc.Ribbon     = ribbon;
            bc.Controls   = controls;
            bc.Parameters = pars;

            Group group = ribbon.CreateGroup(id, properties, title, description, command);

            // Loop through the Layouts for this group and create them.
            JSObject[] children = DataNodeWrapper.GetNodeChildren(_data);
            for (int i = 0; i < children.Length; i++)
            {
                Layout layout = CreateLayoutFromData(children[i], group, bc);
                if (!CUIUtility.IsNullOrUndefined(layout))
                {
                    group.AddChild(layout);
                }
            }
            return(group);
        }
Example #8
0
        internal void AttachAndBuildJewelFromData(object jewelData)
        {
            if (!_hasJewel)
            {
                return;
            }

            _elmJewelPlaceholder.Style.Display = "block";

            JewelBuildContext jbc = new JewelBuildContext();

            jbc.JewelId = DataNodeWrapper.GetAttribute(jewelData, "Id");

            // Build Jewel
            JewelBuildOptions options = new JewelBuildOptions();

            options.TrimmedIds = _builder.Options.TrimmedIds;
            JewelBuilder builder = new JewelBuilder(options,
                                                    _elmJewelPlaceholder,
                                                    _builder.BuildClient);

            builder.BuildJewelFromData(jewelData, jbc);

            this.Jewel = builder.Jewel;
        }
Example #9
0
        private Component DelayInitTab(Component component,
                                       object data,
                                       object buildContext)
        {
            RibbonBuildContext rbc = (RibbonBuildContext)buildContext;
            Tab tab = (Tab)component;

            rbc.InitializedTab = (Tab)component;
            // If the data node does not have children, then it means that this tab
            // was shallowly fetched from the server.  In this case we need to run
            // a query to get the whole node with all of its controls from the server.
            JSObject[] children = DataNodeWrapper.GetNodeChildren(data);
            if (children.Length == 0)
            {
                // TODO: implement this so that the asynchronous part works
                // Find out if we even need to fetch the tabs asynchronously
                // or if we can get away with just initializing them asynchronously
                DataQuery query = new DataQuery();
                query.TabQuery  = true;
                query.Id        = rbc.InitializedTab.Id;
                query.QueryType = DataQueryType.RibbonTab;
                query.Handler   = new DataReturnedEventHandler(this.OnReturnTab);
                query.Data      = rbc;
                DataSource.RunQuery(query);
                return(null);
            }

            FillTab(tab, data, rbc);
            tab.OnDelayedInitFinished(true);
            // TODO(josefl): this should later be an idle task registration instead of a hard call
            Ribbon.Refresh();

            return(tab);
        }
Example #10
0
        internal ButtonDock CreateButtonDock(object data, ToolbarBuildContext buildContext)
        {
            ButtonDockProperties properties =
                DataNodeWrapper.GetNodeAttributes(data).To <ButtonDockProperties>();
            ButtonDock dock = new ButtonDock(Root, properties.Id, properties);

            return(dock);
        }
Example #11
0
        private ToggleButton BuildToggleButton(object data, BuildContext bc)
        {
            ToggleButtonProperties properties =
                DataNodeWrapper.GetNodeAttributes(data).To <ToggleButtonProperties>();
            ToggleButton fsbc = new ToggleButton(Root,
                                                 properties.Id,
                                                 properties);

            return(fsbc);
        }
Example #12
0
        private CheckBox BuildCheckBox(object data, BuildContext bc)
        {
            CheckBoxProperties properties =
                DataNodeWrapper.GetNodeAttributes(data).To <CheckBoxProperties>();
            CheckBox cb = new CheckBox(Root,
                                       properties.Id,
                                       properties);

            return(cb);
        }
Example #13
0
        public void LoadTemplates(object data)
        {
            JSObject templatesNode = DataNodeWrapper.GetFirstChildNodeWithName(data, DataNodeWrapper.RIBBONTEMPLATES);

            JSObject[] children = DataNodeWrapper.GetNodeChildren(templatesNode);
            for (int i = 0; i < children.Length; i++)
            {
                LoadGroupTemplate(children[i]);
            }
        }
Example #14
0
        private InsertTable BuildInsertTable(object data, BuildContext bc)
        {
            InsertTableProperties properties =
                DataNodeWrapper.GetNodeAttributes(data).To <InsertTableProperties>();
            InsertTable fsit = new InsertTable(Root,
                                               properties.Id,
                                               properties);

            return(fsit);
        }
Example #15
0
        private SPButton BuildButton(object data, BuildContext bc)
        {
            ButtonProperties properties =
                DataNodeWrapper.GetNodeAttributes(data).To <ButtonProperties>();
            SPButton fsea = new SPButton(Root,
                                         properties.Id,
                                         properties);

            return(fsea);
        }
Example #16
0
        private Separator BuildSeparator(object data, BuildContext bc)
        {
            SeparatorProperties properties =
                DataNodeWrapper.GetNodeAttributes(data).To <SeparatorProperties>();
            Separator sep = new Separator(Root,
                                          properties.Id,
                                          properties);

            return(sep);
        }
Example #17
0
        private SPLabel BuildLabel(object data, BuildContext bc)
        {
            LabelProperties properties =
                DataNodeWrapper.GetNodeAttributes(data).To <LabelProperties>();
            SPLabel fslb = new SPLabel(Root,
                                       properties.Id,
                                       properties);

            return(fslb);
        }
Example #18
0
        private TextBox BuildTextBox(object data, BuildContext bc)
        {
            TextBoxProperties properties =
                DataNodeWrapper.GetNodeAttributes(data).To <TextBoxProperties>();
            TextBox fstb = new TextBox(Root,
                                       properties.Id,
                                       properties);

            return(fstb);
        }
Example #19
0
        private Spinner BuildSpinner(object data, BuildContext bc)
        {
            SpinnerProperties properties =
                DataNodeWrapper.GetNodeAttributes(data).To <SpinnerProperties>();
            Spinner fssp = new Spinner(Root,
                                       properties.Id,
                                       properties,
                                       BuildUnits(data));

            return(fssp);
        }
Example #20
0
        private string[] BuildUnitAbbreviations(JSObject[] children)
        {
            int l = children.Length;

            string[] abbreviations = new string[l];
            for (int i = 0; i < l; i++)
            {
                abbreviations[i] = DataNodeWrapper.GetAttribute(children[i], DataNodeWrapper.VALUE);
            }

            return(abbreviations);
        }
Example #21
0
        private SPRibbon BuildRibbon(object data, RibbonBuildContext rbc)
        {
            JSObject ribbonElement = DataNodeWrapper.GetFirstChildNodeWithName(data,
                                                                               DataNodeWrapper.RIBBON);

            if (CUIUtility.IsNullOrUndefined(ribbonElement))
            {
                throw new ArgumentNullException("No ribbon element was present in the data");
            }

            Ribbon = new SPRibbon(DataNodeWrapper.GetAttribute(ribbonElement, "Id"),
                                  DataNodeWrapper.GetNodeAttributes(ribbonElement).To <RibbonProperties>());

            //REVIEW(josefl) Should this be configurable?
            Ribbon.UseDataCookie = true;

            // Handle the Tabs
            // The XML structure that we are looking at is <Ribbon><Tabs><Tab/><Tab/>...
            JSObject[] tabChildren = DataNodeWrapper.GetNodeChildren(
                DataNodeWrapper.GetFirstChildNodeWithName(ribbonElement, DataNodeWrapper.TABS));

            AddTabsToRibbon(tabChildren, "", rbc);

            // Handle the Contextual Tab Groups
            // The XML structure that we are looking at is <Ribbon><ContextualTabs><ContextualGroup>...
            object contextualTabs = DataNodeWrapper.GetFirstChildNodeWithName(ribbonElement, DataNodeWrapper.CONTEXTUALTABS);

            if (!CUIUtility.IsNullOrUndefined(contextualTabs))
            {
                JSObject[] cgChildren = DataNodeWrapper.GetNodeChildren(contextualTabs);
                bool       shownContextualGroupsSpecified =
                    !CUIUtility.IsNullOrUndefined(RibbonBuildOptions.ShownContextualGroups);
                for (int j = 0; j < cgChildren.Length; j++)
                {
                    if (shownContextualGroupsSpecified)
                    {
                        // Show the contextual group if it has been explicitly requested/ made available
                        string cgId = DataNodeWrapper.GetAttribute(cgChildren[j], DataNodeWrapper.ID);
                        if (!string.IsNullOrEmpty(cgId))
                        {
                            if (!RibbonBuildOptions.ShownContextualGroups.ContainsKey(cgId) ||
                                CUIUtility.IsNullOrUndefined(RibbonBuildOptions.ShownContextualGroups[cgId]))
                            {
                                continue;
                            }
                        }
                    }
                    AddContextualGroup(cgChildren[j], rbc);
                }
            }

            return(Ribbon);
        }
Example #22
0
        private MenuSection BuildMenuSection(JSObject data, BuildContext bc)
        {
            string displayMode = DataNodeWrapper.GetAttribute(data, DataNodeWrapper.DISPLAYMODE);

            if (CUIUtility.IsNullOrUndefined(displayMode))
            {
                displayMode = "Menu";
            }

            string      id          = DataNodeWrapper.GetAttribute(data, DataNodeWrapper.ID);
            string      title       = DataNodeWrapper.GetAttribute(data, DataNodeWrapper.TITLE);
            string      description = DataNodeWrapper.GetAttribute(data, DataNodeWrapper.DESCRIPTION);
            bool        scrollable  = Utility.IsTrue(DataNodeWrapper.GetAttribute(data, DataNodeWrapper.SCROLLABLE));
            string      maxheight   = DataNodeWrapper.GetAttribute(data, DataNodeWrapper.MAXHEIGHT);
            MenuSection ms          = Root.CreateMenuSection(id,
                                                             title,
                                                             description,
                                                             scrollable,
                                                             maxheight,
                                                             displayMode);

            JSObject[] menuSectionChildren = DataNodeWrapper.GetNodeChildren(data);
            JSObject   msChild             = menuSectionChildren[0];
            string     msChildName         = DataNodeWrapper.GetNodeName(msChild);

            if (msChildName == DataNodeWrapper.CONTROLS)
            {
                // Get the <MenuSection><Controls> node's children
                JSObject[] individualControls = DataNodeWrapper.GetNodeChildren(msChild);
                int        l = individualControls.Length;

                JSObject child = null;
                for (int i = 0; i < l; i++)
                {
                    child = individualControls[i];
                    if (IsNodeTrimmed(child))
                    {
                        continue;
                    }
                    Control control = BuildControl(child, bc);
                    ms.AddChild(control.CreateComponentForDisplayMode(displayMode));
                }
            }
            else if (msChildName == DataNodeWrapper.GALLERY)
            {
                Gallery gallery = BuildGallery(msChild, bc, true);
                ms.AddChild(gallery);
            }

            return(ms);
        }
Example #23
0
        private Tab BuildTab(object data,
                             RibbonBuildContext rbc,
                             string contextualGroupId)
        {
            Tab    tab;
            string id          = DataNodeWrapper.GetAttribute(data, DataNodeWrapper.ID);
            string title       = DataNodeWrapper.GetAttribute(data, DataNodeWrapper.TITLE);
            string description = DataNodeWrapper.GetAttribute(data, DataNodeWrapper.DESCRIPTION);
            string command     = DataNodeWrapper.GetAttribute(data, DataNodeWrapper.COMMAND);
            string cssclass    = DataNodeWrapper.GetAttribute(data, DataNodeWrapper.CSSCLASS);

            if (string.IsNullOrEmpty(contextualGroupId))
            {
                tab = Ribbon.CreateTab(id,
                                       title,
                                       description,
                                       command,
                                       cssclass);
            }
            else
            {
                tab = Ribbon.CreateContextualTab(id,
                                                 title,
                                                 description,
                                                 command,
                                                 contextualGroupId,
                                                 cssclass);
                // Make sure that the tabs that are in the initially shown contextual groups are visible
                if (!CUIUtility.IsNullOrUndefined(RibbonBuildOptions.InitiallyVisibleContextualGroups) &&
                    RibbonBuildOptions.InitiallyVisibleContextualGroups.ContainsKey(contextualGroupId) &&
                    RibbonBuildOptions.InitiallyVisibleContextualGroups[contextualGroupId])
                {
                    tab.VisibleInternal = true;
                }
            }

            // If the Tab is being inited in a shallow way, then we set the callback so that
            // the builder will be called if the Tab is selected.
            // We set up the Tab to be delay initialized and give it its own copy of the build context
            JSObject[] children = DataNodeWrapper.GetNodeChildren(data);
            if (children.Length == 0)
            {
                tab.SetDelayedInitData(new DelayedInitHandler(DelayInitTab), data, rbc.Clone());
            }
            else
            {
                FillTab(tab, data, rbc);
            }

            return(tab);
        }
Example #24
0
        /// <summary>
        /// The toolbar doesn't require scaling code -- it just builds with a static set of display modes,
        /// since it only supports one display mode per control type.
        /// </summary>
        private Component BuildToolbarControlComponent(object data, ToolbarBuildContext buildContext)
        {
            Control control     = null;
            string  name        = DataNodeWrapper.GetNodeName(data);
            string  displayMode = DataNodeWrapper.GetAttribute(data, DataNodeWrapper.DISPLAYMODE);

            switch (name)
            {
            case DataNodeWrapper.Button:
                control = BuildControl(data, buildContext);
                return(control.CreateComponentForDisplayMode(
                           string.IsNullOrEmpty(displayMode) ? "Small" : displayMode));

            case DataNodeWrapper.CheckBox:
                control = BuildControl(data, buildContext);
                return(control.CreateComponentForDisplayMode(
                           string.IsNullOrEmpty(displayMode) ? "Small" : displayMode));

            case DataNodeWrapper.ComboBox:
                control = BuildControl(data, buildContext);
                return(control.CreateComponentForDisplayMode("Medium"));

            case DataNodeWrapper.FlyoutAnchor:
                control = BuildControl(data, buildContext);
                return(control.CreateComponentForDisplayMode(
                           string.IsNullOrEmpty(displayMode) ? "Medium" : displayMode));

            case DataNodeWrapper.Label:
                control = BuildControl(data, buildContext);
                return(control.CreateComponentForDisplayMode(
                           string.IsNullOrEmpty(displayMode) ? "Small" : displayMode));

            case DataNodeWrapper.Separator:
                control = BuildControl(data, buildContext);
                return(control.CreateComponentForDisplayMode("Small"));

            case DataNodeWrapper.TextBox:
                control = BuildControl(data, buildContext);
                return(control.CreateComponentForDisplayMode(
                           string.IsNullOrEmpty(displayMode) ? "Medium" : displayMode));

            case DataNodeWrapper.ToggleButton:
                control = BuildControl(data, buildContext);
                return(control.CreateComponentForDisplayMode(
                           string.IsNullOrEmpty(displayMode) ? "Small" : displayMode));

            default:
                throw new InvalidOperationException("Invalid control type.");
            }
        }
Example #25
0
        private ComboBox BuildComboBox(object data, BuildContext bc)
        {
            ComboBoxProperties properties =
                DataNodeWrapper.GetNodeAttributes(data).To <ComboBoxProperties>();

            JSObject[] children = DataNodeWrapper.GetNodeChildren(data);

            Menu menu = null;

            MenuLauncherControlProperties launcherProperties =
                DataNodeWrapper.GetNodeAttributes(data).To <MenuLauncherControlProperties>();

            Dictionary <string, string> menuItems = null;

            if (!Utility.IsTrue(launcherProperties.PopulateDynamically))
            {
                // Since PopulateDynamically is not true, we pass in "false" for LazyInit
                menu = BuildMenu(children[0], bc, false);

                // Parse XML subtree to build MenuItem list for auto-complete
                menuItems = new Dictionary <string, string>();
                JSObject[] sections = DataNodeWrapper.GetNodeChildren(children[0]);
                int        l        = sections.Length;
                for (int i = 0; i < l; i++)
                {
                    // Get children of the MenuSection node
                    JSObject[] sectionChildren = DataNodeWrapper.GetNodeChildren(sections[i]);
                    // Get children of the Controls node within the MenuSection
                    // There should only be 1 Controls node within the MenuSection subtree
                    JSObject[] items = DataNodeWrapper.GetNodeChildren(sectionChildren[0]);
                    int        m     = items.Length;
                    for (int j = 0; j < m; j++)
                    {
                        string labeltext  = DataNodeWrapper.GetAttribute(items[j], DataNodeWrapper.LABELTEXT);
                        string menuitemid = DataNodeWrapper.GetAttribute(items[j], DataNodeWrapper.MENUITEMID);
                        menuItems[labeltext] = menuitemid;
                    }
                }
            }

            ComboBox fscb = new ComboBox(Root,
                                         properties.Id,
                                         properties,
                                         menu);

            fscb.MenuItems = menuItems;
            return(fscb);
        }
Example #26
0
        private ControlComponent CreateControlComponentFromData(object data, DeclarativeTemplateBuildContext bc)
        {
            string alias       = DataNodeWrapper.GetAttribute(data, DataNodeWrapper.TEMPLATEALIAS);
            string displayMode = DataNodeWrapper.GetAttribute(data, DataNodeWrapper.DISPLAYMODE);

            ControlComponent comp    = null;
            List <Control>   control = bc.Controls.ContainsKey(alias) ? bc.Controls[alias] : null;

            // If there is more than one control that is using the same TemplateAlias and the template
            // slot is a ControlRef, then the slot remains empty so that the problem can be detected and resolved.
            if (!CUIUtility.IsNullOrUndefined(control) && control.Count > 1)
            {
                comp = control[0].CreateComponentForDisplayMode(displayMode);
            }
            return(comp);
        }
Example #27
0
        private void LoadGroupTemplate(object data)
        {
            string id        = DataNodeWrapper.GetAttribute(data, DataNodeWrapper.ID);
            string className = DataNodeWrapper.GetAttribute(data, DataNodeWrapper.CLASSNAME);

            // If the template is already loaded, then we don't load it again
            if (!CUIUtility.IsNullOrUndefined(GetTemplate(id)))
            {
                return;
            }

            if (string.IsNullOrEmpty(className))
            {
                AddTemplate(new DeclarativeTemplate(data), id);
            }
        }
Example #28
0
        public static JSObject GetFirstChildNodeWithName(object data, string name)
        {
            JSObject[] children = DataNodeWrapper.GetNodeChildren(data);

            int l = children.Length;

            for (int i = 0; i < l; i++)
            {
                JSObject child = children[i];
                string   nm    = DataNodeWrapper.GetNodeName(child);
                if (nm == name)
                {
                    return(child);
                }
            }
            return(null);
        }
Example #29
0
        private Jewel BuildJewelInternal(object data, JewelBuildContext jbc)
        {
            if (CUIUtility.IsNullOrUndefined(data))
            {
                throw new ArgumentNullException("No Jewel element was present in the data");
            }

            Jewel = new Jewel(DataNodeWrapper.GetAttribute(data, "Id"),
                              DataNodeWrapper.GetNodeAttributes(data).To <JewelProperties>());

            // Handle the Jewel Menu Launcher control
            JewelMenuLauncher jml = BuildJewelMenuLauncher(data, jbc);

            Jewel.AddChild(jml.CreateComponentForDisplayMode("Default"));
            Jewel.JewelMenuLauncher = jml;

            return(Jewel);
        }
Example #30
0
        private SplitButton BuildSplitButton(object data, BuildContext bc)
        {
            SplitButtonProperties properties =
                DataNodeWrapper.GetNodeAttributes(data).To <SplitButtonProperties>();

            JSObject[] children = DataNodeWrapper.GetNodeChildren(data);
            Menu       menu     = null;

            if (!Utility.IsTrue(properties.PopulateDynamically))
            {
                menu = BuildMenu(children[0], bc, true);
            }

            SplitButton fseo =
                new SplitButton(Root,
                                properties.Id,
                                properties,
                                menu);

            return(fseo);
        }