ExtJS笔记 Tree

时间  2019-11-29
标签 extjs 笔记 tree 繁體版
原文   原文链接

The Tree Panel Component is one of the most versatile Components in Ext JS and is an excellent tool for displaying heirarchical data in an application. Tree Panel extends from the same class as Grid Panel, so all of the benefits of Grid Panels - features, extensions, and plugins can also be used on Tree Panels. Things like columns, column resizing, dragging and dropping, renderers, sorting and filtering can be expected to work similarly for both components.css

树面板组件是在 ExtJS 里面最多彩缤纷的组件之一，用于显示层次状明显的数据来讲十分适合。树面板跟 Grid 都是来自同一个基类的，之因此这样的设计，是为了那些扩展或者插件通通均可以复用一致的功能。好比多列、尺寸控制、拖放、渲染和筛选这些功能都是二者共性的内容。html

Let's start by creating a very simple Tree.node

让咱们开始建立一个颗很是简单的树。ios

Ext.create('Ext.tree.Panel', {
    renderTo: Ext.getBody(),
    title: 'Simple Tree',
    width: 150,
    height: 150,
    root: {
        text: 'Root',
        expanded: true,
        children: [
            {
                text: 'Child 1',
                leaf: true
            },
            {
                text: 'Child 2',
                leaf: true
            },
            {
                text: 'Child 3',
                expanded: true,
                children: [
                    {
                        text: 'Grandchild',
                        leaf: true
                    }
                ]
            }
        ]
    }
});

 

This Tree Panel renders itself to the document body. We defined a root node that is expanded by default. The root node has three children, the first two of which are leaf nodes which means they cannot have any children. The third node is not a leaf node and has has one child leaf node. The text property is used as the node's text label. See Simple Tree for a live demo.git

此树面板渲染到 document.body 元素上。咱们把定义的根节点（The Root Node）自动扩张开来，这是默认的状况。根节点有三个子节点 ，其中前两个是 leaf 节点，表示他们下面没有任何子节点（children）了（终结了）。第三个节点是一个叶子节点，已经有一个 child 的叶节点（one child leaf node）。 text 属性是节点的显示的文本。可打开例子看看效果如何。ajax

Internally a Tree Panel stores its data in a TreeStore. The above example uses the root config as a shortcut for configuring a store. If we were to configure the store separately, the code would look something like this:编程

树面板的数据存储在 TreeStore。上面的例子看不见 Store 配置的地方不是没有 Store，而是使用内部缺省的。若是咱们要另外配置不一样的 Store，应该看起来像这样：json

var store = Ext.create('Ext.data.TreeStore', {
    root: {
        text: 'Root',
        expanded: true,
        children: [
            {
                text: 'Child 1',
                leaf: true
            },
            {
                text: 'Child 2',
                leaf: true
            },
            ...
        ]
    }
});

Ext.create('Ext.tree.Panel', {
    title: 'Simple Tree',
    store: store,
    ...
});

 

For more on Stores see the Data Guide.api

参阅《DataGuide》以了解更多 Store 内容。数组

The Node Interface

In the above examples we set a couple of different properties on tree nodes. But what are nodes exactly? As mentioned before, the Tree Panel is bound to a TreeStore. A Store in Ext JS manages a collection of Model instances. Tree nodes are simply Model instances that are decorated with a NodeInterface. Decorating a Model with a NodeInterface gives the Model the fields, methods and properties that are required for it to be used in a tree. The following is a screenshot that shows the structure of a node in the developer tools.

从上面的例子咱们能够看到关于树节点其下的许多属性。那么真正的节点究竟为什么物？前面已提到过，树面板绑定到 TreeStore。而 ExtJS 中的 Store 是负责管理 Model 实例的集合。树节点只是 Model  实例经过 NodeInterface 的装饰接口。用 NodeInterface 装饰 Model 的好处是赋予了 Model  在树控件的状态下，有新的方法与属性。如下的截图显示了在开发工具节点其结构如何。

 

A model instance decorated with the NodeInterface

 

In order to see the full set of fields, methods and properties available on nodes, see the API documentation for the NodeInterface class.

要全面了解一下节点的属性、方法、事件，应参阅 API 文档。

Visually changing your tree

Let's try something simple. When you set the useArrows configuration to true, the Tree Panel hides the lines and uses arrows as expand and collapse icons.

让咱们试试简单的。在你设置 useArrows 配置项为 true 的时候，树面板会隐藏旁边的线条，而采用图标箭头表示展开和折叠。

 

Arrows

 

Setting the rootVisible property to false visually removes the root node. By doing this, the root node will automatically be expanded. The following image shows the same tree with rootVisible set to false and lines set to false.

设置根节点的 rootVisible 可决定根节点显示与否。经过这样作的话，通常就是根节点会自动扩大。下面的图片显示，rootVisible 设置为 false，并设置 lines 为 false 的时候看不见线的树。

 

Root not visible and no lines

 

Multiple columns

Since Tree Panel extends from the same base class as Grid Panel adding more columns is very easy to do.

鉴于树面板跟 Grid 面板来自同一个基类，因此构成多列是很是轻松的。

var tree = Ext.create('Ext.tree.Panel', {
    renderTo: Ext.getBody(),
    title: 'TreeGrid',
    width: 300,
    height: 150,
    fields: ['name', 'description'],
    columns: [{
        xtype: 'treecolumn',
        text: 'Name',
        dataIndex: 'name',
        width: 150,
        sortable: true
    }, {
        text: 'Description',
        dataIndex: 'description',
        flex: 1,
        sortable: true
    }],
    root: {
        name: 'Root',
        description: 'Root description',
        expanded: true,
        children: [{
            name: 'Child 1',
            description: 'Description 1',
            leaf: true
        }, {
            name: 'Child 2',
            description: 'Description 2',
            leaf: true
        }]
    }
});

 

The columns configuration expects an array of Ext.grid.column.Column configurations just like a Grid Panel would have. The only difference is that a Tree Panel requires at least one column with an xtype of 'treecolumn'. This type of column has tree-specific visual effects like depth, lines and expand and collapse icons. A typical Tree Panel would have only one 'treecolumn'.

和 Grid 面板那样子配置 Ext.grid.column.Column，Tree 面板也是经过 columns 数组进行配置。惟一区别在于 Tree 面板至少得要一个 xtype 是“treecolumn”的列。该类型的列根据树而设计的，拥有深度（depth）、线条（lines）、展开与闭合图标等的特性。典型的 Tree 面板即是一个单独的“treecolumn”。

The fields configuration is passed on to the Model that the internally created Store uses (See the Data Guide for more information on Models). Notice how the dataIndex configurations on the columns map to the fields we specified - name and description.

配置项 fields 会由内部的 Store 被复制到 Model 上（该方面可参阅《Data Guide》的 Model 部分）。请注意列其 dataIndex 配置项就是映射到 field 的。

It is also worth noting that when columns are not defined, the tree will automatically create one single treecolumn with a dataIndex set to 'text'. It also hides the headers on the tree. To show this header when using only a single column set the hideHeaders configuration to 'false'.

应该提出，当未定义列的时候，树会自动建立一个单独的 treecolumn，带有“text” 的 dataIndex。还会隐藏树的头部。要显示的话，可设置配置项 hideHeaders 为 false。

Adding nodes to the tree

The root node for the Tree Panel does not have to be specified in the initial configuration. We can always add it later:

不必定要在配置的时候将全部的节点添加到树上，及后再加也能够的。

var tree = Ext.create('Ext.tree.Panel');
tree.setRootNode({
    text: 'Root',
    expanded: true,
    children: [{
        text: 'Child 1',
        leaf: true
    }, {
        text: 'Child 2',
        leaf: true
    }]
});

 

Although this is useful for very small trees with only a few static nodes, most Tree Panels will contain many more nodes. So let's take a look at how we can programmatically add new nodes to the tree.

这样子在一棵静态的树上加上几个节点毫无问题，可是通常而言树面板仍是会动态地加入许多节点。这样咱们就来看看如何经过编程来添加新的节点树。

var root = tree.getRootNode();

var parent = root.appendChild({
    text: 'Parent 1'
});

parent.appendChild({
    text: 'Child 3',
    leaf: true
});

parent.expand();

 

Every node that is not a leaf node has an appendChild method which accepts a Node, or a config object for a Node as its first parameter, and returns the Node that was appended. The above example also calls the expand method to expand the newly created parent.

只要不是 leaf 节点，它都有 appendChild 的方法，送入一个节点的实例，或者节点的配置项对象做为参数，该方法就是返回新建立的节点。上一例调用了新建立节点其 expand 的方法。

 

Appending to the tree

 

Also useful is the ability to define children inline when creating the new parent nodes. The following code gives us the same result.

另外你能够经过内联的写法建立父节点。下一例与上例的做用同样。

var parent = root.appendChild({
    text: 'Parent 1',
    expanded: true,
    children: [{
        text: 'Child 3',
        leaf: true
    }]
});

 

Sometimes we want to insert a node into a specific location in the tree instead of appending it. Besides the appendChild method, Ext.data.NodeInterfacealso provides insertBefore and insertChild methods.

有些时候咱们想将节点插入到某个固定的位置。这样的话，就须要 insertBefore 或 insertChild 方法，都由 Ext.data.NodeInterface 提供。

var child = parent.insertChild(0, {
    text: 'Child 2.5',
    leaf: true
});

parent.insertBefore({
    text: 'Child 2.75',
    leaf: true
}, child.nextSibling);

 

The insertChild method expects an index at which the child will be inserted. The insertBefore method expects a reference node. The new node will be inserted before the reference node.

insertChild 方法须要一个 child 将被插入索引。 insertBefore 方法预计的参考节点。将参考节点以前插入新的节点。

 

Inserting children into the tree

 

NodeInterface also provides several more properties on nodes that can be used to reference other nodes.

NodeInterface 还提供了如下几个属性，供其余节点做“引用”时之用。

Loading and Saving Tree Data using a Proxy

Loading and saving Tree data is somewhat more complex than dealing with flat data because of all the fields that are required to represent the hierarchical structure of the tree. This section will explain the intricacies of working with tree data.

加载和保存tree数据要比处理平面数据复杂，由于数据表明了树形层次结构。本小节说明操做树形数据的复杂工做。

NodeInterface Fields

The first and most important thing to understand when working with tree data is how the NodeInterface class' fields work. Every node in a Tree is simply aModel instance decorated with the NodeInterface's fields and methods. Assume for a moment that an application has a Model called Person. A Person only has two fields - id and name:

理解tree数据如何工做的首要事情是知道NodeInterface类如何工做。树中的每一个节点都是一个model实例，并被修饰了NodeInterface的自动和方法。假设一个app具备一个model叫作person，有两个字段id和name：

Ext.define('Person', {
    extend: 'Ext.data.Model',
    fields: [
        { name: 'id', type: 'int' },
        { name: 'name', type: 'string' }
    ]
});

 

At this point Person is just a plain vanilla Model. If an instance is created, it can easily be verified that it only has two fields by looking at its fieldscollection

这是person仅是一个平面数据。若是一个实例被建立，能够很容易验证它只有两个字段：

console.log(Person.prototype.fields.getCount()); // outputs '2'

 

When the Person model is used in a TreeStore, something interesting happens. Notice the field count now:

当一个personmodel用在了TreeStore中，一些有趣的事情发生了。注意下面的字段数统计：

var store = Ext.create('Ext.data.TreeStore', {
    model: 'Person',
    root: {
        name: 'Phil'
    }
});

console.log(Person.prototype.fields.getCount()); // outputs '24'

 

The Person model's prototype got 22 extra fields added to it just by using it in a TreeStore. All of these extra fields are defined on the NodeInterface class and are added to the Model's prototype the first time an instance of that Model is used in a TreeStore (by setting it as the root node).

person模型的prototype得到了22个额外添加的字段，仅仅是在treestore中使用它。全部这些额外的字段是在 NodeInterface类中定义的，而且在第一次在treestore中使用的时候（经过设置它为root 节点）被加入model的prototype。

So what exactly are these 22 extra fields, and what do they do? A quick look at the NodeInterface source code reveals that it decorates the Model with the following fields. These fields are used internally to store information relating to the tree's structure and state:

{name: 'parentId',   type: idType,    defaultValue: null},
{name: 'index',      type: 'int',     defaultValue: null, persist: false},
{name: 'depth',      type: 'int',     defaultValue: 0, persist: false},
{name: 'expanded',   type: 'bool',    defaultValue: false, persist: false},
{name: 'expandable', type: 'bool',    defaultValue: true, persist: false},
{name: 'checked',    type: 'auto',    defaultValue: null, persist: false},
{name: 'leaf',       type: 'bool',    defaultValue: false},
{name: 'cls',        type: 'string',  defaultValue: null, persist: false},
{name: 'iconCls',    type: 'string',  defaultValue: null, persist: false},
{name: 'icon',       type: 'string',  defaultValue: null, persist: false},
{name: 'root',       type: 'boolean', defaultValue: false, persist: false},
{name: 'isLast',     type: 'boolean', defaultValue: false, persist: false},
{name: 'isFirst',    type: 'boolean', defaultValue: false, persist: false},
{name: 'allowDrop',  type: 'boolean', defaultValue: true, persist: false},
{name: 'allowDrag',  type: 'boolean', defaultValue: true, persist: false},
{name: 'loaded',     type: 'boolean', defaultValue: false, persist: false},
{name: 'loading',    type: 'boolean', defaultValue: false, persist: false},
{name: 'href',       type: 'string',  defaultValue: null, persist: false},
{name: 'hrefTarget', type: 'string',  defaultValue: null, persist: false},
{name: 'qtip',       type: 'string',  defaultValue: null, persist: false},
{name: 'qtitle',     type: 'string',  defaultValue: null, persist: false},
{name: 'children',   type: 'auto',   defaultValue: null, persist: false}

 

NodeInterface Fields are Reserved Names   NodeInterface 字段与保留字

It is important to note that all of the above field names should be treated as "reserved" names. For example, it is not allowed to have a field called "parentId" in a Model, if that Model is intended to be used in a Tree, since the Model's field will override the NodeInterface field. The exception to this rule is when there is a legitimate need to override the persistence of a field.

很重要的一点是，上面这些字段名称要被当作 "reserved" 名称。例如，在model中不容许具备一个叫作 "parentId" 的字段，若是model将被用于tree，model的字段将覆盖NodeInterface字段。这个规则的例外是，若是覆盖这些字段是正当的。

Persistent Fields vs Non-persistent Fields and Overriding the Persistence of Fields  持久字段vs非持久化字段和覆盖持久化字段

Most of NodeInterface's fields default to persist: false. This means they are non-persistent fields by default. Non-persistent fields will not be saved via the Proxy when calling the TreeStore's sync method or calling save() on the Model. In most cases, the majority of these fields can be left at their default persistence setting, but there are cases where it is necessary to override the persistence of some fields. The following example demonstrates how to override the persistence of a NodeInterface field. When overriding a NodeInterface field it is important to only change the persist property. name,type, and defaultValue should never be changed.

多数NodeInterface's 字段具备缺省值persist: false，这意味着它们缺省是非持久化字段。当调用TreeStore的sync()或save()方法时，非持久化字段不会经过Proxy保存。在多数状况下，这些字段不须要持久化，可是有些状况下须要。下面的示例演示了如何覆盖NodeInterface 的持久化设置。当覆盖一个NodeInterface 字段，重要的一点是修改persist 属性。 name,type, 和defaultValue属性不要修改。

 

// overriding the persistence of NodeInterface fields in a Model definition
Ext.define('Person', {
    extend: 'Ext.data.Model',
    fields: [
        // Person fields
        { name: 'id', type: 'int' },
        { name: 'name', type: 'string' }

        // override a non-persistent NodeInterface field to make it persistent
        { name: 'iconCls', type: 'string',  defaultValue: null, persist: true },
    ]
});

 

Let's take a more in-depth look at each NodeInterface field and the scenarios in which it might be necessary to override its persist property. In each example below it is assumed that a Server Proxy is being used unless otherwise noted.

咱们来看看一个关于NodeInterface 字段更深刻的例子和须要覆盖persist 属性的场景。下面的每一个例子都假定使用了Server Proxy ，除非特别说明。

Persistent by default:

缺省持久化：

  • parentId - used to store the id of a node's parent node. This field should always be persistent, and should not be overridden.用于保存父节点，不可覆盖。
  • leaf - used to indicate that the node is a leaf node, and therefore cannot have children appended to it. This field should not normally need to be overridden.用于指示是否叶子节点，叶子节点不能被添加子节点。这个字段一般不须要覆盖。

Non-persistent by default:

缺省非持久化：

  • index - used to store the order of nodes within their parent. When a node is inserted or removed, all of its sibling nodes after the insertion or removal point will have their indexes updated. If desired, the application can use this field to persist the ordering of nodes. However, if the server uses a different method of storing order, it may be more appropriate to leave the index field as non-persistent. When using a WebStorage Proxy if storing order is required, this field must be overridden to be persistent. Also if client-side sorting is being used it is recommended for the index field to be left as non-persistent, since sorting updates the indexes of all the sorted nodes, which would cause them to be persisted on next sync or save if the persist property is true.用来存储在父节点中的属性。当一个节点被 inserted or removed，全部在插入或移除点后的节点都要更新其索引。必要时，app可使用此节点来持久化节点顺序。然而，若是服务器使用其余不一样的方法来保存顺序，将index字段设为非持久化会更合适。当使用WebStorage Proxy，若是须要保存顺序，这个字段必须被覆盖以持久化。而且，若是使用客户端排序，推荐将index字段保持为非持久化，由于排序会更新全部已排序字段的index，若是persist为true，这会致使在下次调用sync()或save()方法时持久化它们。
  • depth - used to store the depth of a node in the tree hierarchy. Override this field to turn on persistence if the server needs to store the depth field. When using a WebStorage Proxy it is recommended to not override the persistence of the depth field since it is not needed to properly store the tree structure and will just take up extra space.用于存储节点在树层次中的深度。若是服务端须要保存depth字段，则覆盖这个属性。当使用WebStorage Proxy，建议不要存储这个属性，由于保存树结构不须要它，从而仅仅是浪费空间。
  • checked - this field should be overridden to be persistent if the tree is using the checkbox feature   若是树须要checkbox，则须要覆盖此属性
  • expanded - used to store the expanded/collapsed state of a node. This field should not normally need to be overridden. 保存展开/收缩状态，通常不须要覆盖
  • expandable - used internally to indicate that this node is expandable. Do not override the persistence of this field.  内部使用，用来判断节点是否可展开。不要覆盖此属性。
  • cls - used to apply a css class to the node when it is rendered in a TreePanel. Override this field to be persistent if desired.  节点的css样式类。根据须要覆盖此属性。
  • iconCls - used to apply a css class to the node's icon when it is rendered in a TreePanel. Override this field to be persistent if desired.节点图标样式。根据须要覆盖。
  • icon - used to apply a cutom icon to the node node when it is rendered in a TreePanel. Override this field to be persistent if desired.节点图标。根据须要覆盖。
  • root - used to indicate that this node is the root node. This field should not be overridden.用于指明是否根节点，不要覆盖。
  • isLast - used to indicate that this node is the last of its siblings. This field should not normally need to be overridden.兄弟中的最后一个接待，不要覆盖。
  • isFirst - used to indicate that this node is the first of its siblings. This field should not normally need to be overridden.兄弟中第一个节点，不要覆盖。
  • allowDrop - used internally to deny dropping on the node. Do not override the persistence of this field.内部使用，是否拒绝拖放到此节点，不要覆盖。
  • allowDrag - used internally to deny dragging the node. Do not override the persistence of this field.内部使用，是否可拖动此节点，不要覆盖。
  • loaded - used internally to indicate that the node's children have been loaded. Do not override the persistence of this field.内部使用，节点的孩子是否已加载。不要覆盖。
  • loading - used internally to indicate that the proxy is in the process of loading the node's children. Do not override the persistence of this field.内部使用，节点是否真正加载孩子。不要覆盖。
  • href - used to specify a url that the node should be a link to. Override to be persistent if desired.节点连接，根据须要覆盖。
  • hrefTarget - used to specify the target for the href. Override to be persistent if desired.     href的target属性，根据须要覆盖。
  • qtip - used to add a tooltip text to the node. Override to be persistent if desired.   用于添加提示文本到节点，根据须要覆盖。
  • qtitle - used to specify the title for the tooltip. Override to be persistent if desired.  tooltip的title，根据须要覆盖。
  • children - used internally when loading a node and its children all in one request. Do not override the persistence of this field.  内部使用，用于一次加载节点及其孩子，不要覆盖。

Loading Data    加载数据

There are two ways to load tree data. The first is to for the proxy to fetch the entire tree all at once. For larger trees where loading everything at once is not ideal, it may be preferable to use the second method - dynamically loading the children for each node when it is expanded.

有两种方式加载树数据。第一种是一次加载整棵树。对于大的树，使用第二种方法--在节点展开的时候动态加载。

Loading the Entire Tree    加载整棵树

Internally the tree only loads data in response to a node being expanded. However the entire hierarchy can be loaded if the proxy retrieves a nested object containing the whole tree structure. To accomplish this, initialize the TreeStore's root node to expanded:

在内部，tree只在节点展开的时候加载数据。然而，若是proxy获取了一次获取了包含整棵树的嵌套数据，树能够一次加载完成。要作到这点，初始化时将TreeStore的root设为expanded：

Ext.define('Person', {
    extend: 'Ext.data.Model',
    fields: [
        { name: 'id', type: 'int' },
        { name: 'name', type: 'string' }
    ],
    proxy: {
        type: 'ajax',
        api: {
            create: 'createPersons',
            read: 'readPersons',
            update: 'updatePersons',
            destroy: 'destroyPersons'
        }
    }

});

var store = Ext.create('Ext.data.TreeStore', {
    model: 'Person',
    root: {
        name: 'People',
        expanded: true
    }
});

Ext.create('Ext.tree.Panel', {
    renderTo: Ext.getBody(),
    width: 300,
    height: 200,
    title: 'People',
    store: store,
    columns: [
        { xtype: 'treecolumn', header: 'Name', dataIndex: 'name', flex: 1 }
    ]
});

 

Assume that the readPersons url returns the following json object

假设readPersons url返回下面的json对象

{
    "success": true,
    "children": [
        { "id": 1, "name": "Phil", "leaf": true },
        { "id": 2, "name": "Nico", "expanded": true, "children": [
            { "id": 3, "name": "Mitchell", "leaf": true }
        ]},
        { "id": 4, "name": "Sue", "loaded": true }
    ]
}

 

That's all that's needed to load the entire tree.

那些就是加载整棵树所需的所有。

 

Tree with Bulk Loaded Data

 

Important items to note:须要注意的要点：

  • For all non-leaf nodes that do not have children (for example, Person with name Sue above), the server response MUST set the loaded property to true. Otherwise the proxy will attempt to load children for these nodes when they are expanded.对于全部没有孩子的非叶子节点（例如，名为Sue的Person），服务器响应必须设置loaded 属性为true。不然，当它们被展开的时候，proxy会视图去获取其子节点。
  • The question then arises - if the server is allowed to set the loaded property on a node in the JSON response can it set any of the other non-persistent fields? The answer is yes - sometimes. In the example above the node with name "Nico" has is expanded field set to true so that it will be initially displayed as expanded in the Tree Panel. Caution should be exercised as there are cases where this is not appropriate and could cause serious problems, like setting the root property on a node that is not the root node for example. In general loaded and expanded are the only cases where it is recommended for the server to set a non-persistent field in the JSON response.问题来了--若是服务器被容许设置loaded 属性，它能够设置其它非持久化字段吗？答案是 yes --有时候。上例中，"Nico "节点是被展开的节点，所以在tree panel中初始是展开的。须要注意的是，有些属性设置会引发严重的问题，例如对非root节点设置root属性。一般，loaded 和expanded 是仅有的两个推荐在服务器端设置的非持久化属性。

Dynamically Loading Children When a Node is Expanded    当节点展开时的动态加载

For larger trees it may be desirable to only load parts of the tree by loading child nodes only when their parent node is expanded. Suppose in the above example, that the node with name "Sue" does not have its loaded field set to true by the server response. The Tree would display an expander icon next to the node. When the node is expanded the proxy will make another request to the readPersons url that looks something like this:

对于较大的树，指望的作法是开始只加载部分节点，而后当父节点展开的时候，才加载孩子节点。假设在上面的例子中，“sue节点的loaded属性没有被服务器设置为true。树会在节点的旁边显示一个expander 图标。当节点被展开，proxy会发起另一个请求到readPersons 连接，如：

/readPersons?node=4

 

This tells the server to retrieve the child nodes for the node with an id of 4. The data should be returned in the same format as the data that was used to load the root node:

这告诉服务器去获取id为4的节点的孩子节点。数据将以与加载根节点同样的格式返回：

{
    "success": true,
    "children": [
        { "id": 5, "name": "Evan", "leaf": true }
    ]
}

 

Now the Tree looks something like this:

 如今，树节点看起来是这样：

Tree with Dynamically Loaded Node

 

Saving Data   保存数据

Creating, updating, and deleting nodes is handled automatically and seamlessly by the Proxy.

建立、更新、删除节点会自动处理，并经过proxy无缝衔接。

Creating a New Node   建立新节点

// Create a new node and append it to the tree:
var newPerson = Ext.create('Person', { name: 'Nige', leaf: true });
store.getNodeById(2).appendChild(newPerson);

 

Since the proxy is defined directly on the Model, the Model's save() method can be used to persist the data:

因为直接在model上定义了proxy，model的save()方法能够被用来持久化数据：

newPerson.save();

 

Updating an Existing Node   更新节点

store.getNodeById(1).set('name', 'Philip');

 

Removing a Node   移除节点

store.getRootNode().lastChild.remove();

 

Bulk Operations   批量操做

After creating, updating, and removing several nodes, they can all be persisted in one operation by calling the TreeStore's sync() method:

在建立、更新、删除几个节点后，它们能够调用TreeStore的sync()方法在一个操做中完成持久化。

store.sync();
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程