[OPEN] [#1870] Stateful grid with cell editing - reconfiguration causes the cell editor to be destroyed

**NewLink** · Jan 08, 2022, 2:09 PM

Hello support team,
after applying saved component state, I use the reconfigure method to restore the original grid configuration. However, after this step, rendering of the cell editor crashes on the missing field definition. In the following code, the editor for the first column is activated until the Reset Layout button is clicked:

@using Ext.Net;
@using Ext.Net.MVC;

@{
    Layout = null;

    var X = Html.X();

    var Model = new object[]
        {
            new object[] { "Alcoa Inc", 29.01, 0.42, 1.47, "9/1 12:00am" },
            new object[] { "Altria Group Inc", 83.81, 0.28, 0.34, "9/1 12:00am" },
            new object[] { "Boeing Co.", 75.43, 0.53, 0.71, "9/1 12:00am" },
            new object[] { "Wal-Mart Stores, Inc.", 45.45, 0.73, 1.63, "9/1 12:00am" }
        };
}

<!DOCTYPE html>

<html>
<head>
    <title>Ext.NET MVC Test Case: Stateful Grid Cell Editing</title>

    <script type="text/javascript">
        var resetLayout = function (grid) {
            grid.reconfigure(grid.getStore(), grid.initialConfig.columns.items);
        }
    </script>
</head>

<body>
    @(X.ResourceManager())

    @X.DisplayField().ID("version").ReadOnly(true).Margin(10).Width(200)

    @(X.Window().ID("window").Layout(LayoutType.Fit).Width(650).Height(325).X(50).Y(50)
        .Items(
            X.FormPanel().Border(false).BodyPadding(10)
                .LayoutConfig(new VBoxLayoutConfig { Align = VBoxAlign.Stretch })
                .Items(
                    X.GridPanel()
                        .Margin(10)
                        .HeightSpec("100%")
                        .TopBar(X.Toolbar()
                            .Items(
                                X.Button().ID("btnReset").Text("Reset Layout").Icon(Icon.ArrowRotateAnticlockwise).OnClientClick("resetLayout(this.up('grid'))")
                            )
                        )
                        .Store(X.Store()
                            .Model(X.Model()
                                .Fields(
                                    new ModelField("company"),
                                    new ModelField("price", ModelFieldType.Float),
                                    new ModelField("change", ModelFieldType.Float),
                                    new ModelField("pctChange", ModelFieldType.Float),
                                    new ModelField("lastChange", ModelFieldType.Date, "M/d hh:mmtt")
                                )
                            )
                            .DataSource(Model)
                        )
                        .ColumnModel(
                            X.Column().Text("Company").DataIndex("company").Flex(1)
                                .Editor(
                                    X.TextField().AllowBlank(false)
                                ),
                            X.Column().Text("Price").DataIndex("price").Renderer(RendererFormat.UsMoney),
                            X.Column().Text("Change").DataIndex("change"),
                            X.Column().Text("Change").DataIndex("pctChange"),
                            X.DateColumn().Text("Last Updated").DataIndex("lastChange")
                        )
                        .Plugins(X.CellEditing().ClicksToEdit(2))
                        .Stateful(true)
                )
        )
    )
</body>
</html>

<script type="text/javascript">
    Ext.onReady(function () {
        Ext.getCmp("version").setValue("Ext JS " + Ext.getVersion().version + " / " + "Ext.NET " + Ext.net.Version);
    });
</script>

After reconfiguring the grid and activating the cell editor, an error occurs in getColumnField method because field.field is null:

columnHeader.activeEditorId = field instanceof Ext.grid.CellEditor ? field.field.getItemId() : field.getItemId();

Can you please help me with the correct reinitialization of the component after reconfiguring the grid? Will this method destroy only the cell editors or are there other parts of the grid configuration that need to be properly restored? Maybe I need to perform more steps than just rebuild cell editors.

Ext JS 7.1.0.46 / Ext.NET 5.1.0

Kind regards,
Dan

**fabricio.murta** · Jan 11, 2022, 6:32 AM

Hello Dan!

This issue is happening because you're relying on grid.initialConfig. While it makes sense, the initial config's children are not deeply untied from the actual instance of the grid. This means down to columns.items[0].editor, when the grid is initialized its value is changed from the simple "config" definitions into the instance of the Ext JS editor class.

What you can do to avoid that and reuse the columns is replace to every column you got an editor with its own initialConfig instance.

Beware though this may be introducing a memory leak with every reconfigure, as the instance of the editor may not be properly destroyed. This is a simplified solution but we recommend you watch for memory leaks and, if they are substantial in the production app, you can just store a copy of the editor reference before the reassignment, then free it up it after its initialConfig is placed in the new list of columns. You may want to make a deep copy of the editor.initialConfig in case destroy() wipes it off the new assignment as well.

Here's how your function should look like to avoid the issue:

var resetLayout = function (grid) {
    var firstCol = grid.initialConfig.columns.items[0];

    firstCol.editor = firstCol.editor.initialConfig;
    grid.reconfigure(grid.getStore(), grid.initialConfig.columns.items);
}

It should be enough to just "back up" firstCol.editor to another variable before reassigning it; then when initialConfig is safe in its new place (firstCol.editor), properly clean it up to free resources.

Another way to avoid this issue would be to call reconfigure from code behind, where you can ensure the passed list of columns is a proper config object instead of a full actual client-side instance of the column objects. There's a WebForms example showcasing this: GridPanel > Column Model > Reconfigure.

In the example above, its code behind call just issues GridPanel.Reconfigure() after modifying the column. Ext.NET WebForms "remembers" the initial grid config in markup and fills up its initial config in the response. For MVC this may not be actual, yet it is still possible to reuse the columns definition with a model code and base on it to call reconfigure from code behind.

One way or another, what's important here is, you need to pass to the client side reconfigure() function the column config definitions, without actual instanced members. This means other column features might fail by just referencing the client-side code, even if that's through initialConfig due to shallow copies in the structure.

Hope this helps!

**NewLink** · Jan 12, 2022, 7:03 PM

Hallo Fabrício,
thank you for explaining and outlining a possible solution.

However, the modified resetLayout function only works for simple editors. When using editors that work with objects (combobox, date...), such editors return incorrect values after grid.reconfigure and cell editing.

I also tried to back up the initial grid configuration directly in its constructor, but it results in the same errors as mentioned in the introductory post:

@using Ext.Net;
@using Ext.Net.MVC;

@{
    Layout = null;

    var X = Html.X();

    var Model = new object[]
        {
            new object[] { "Alcoa Inc", 29.01, 0.42, 1.47, "9/1 12:00am" },
            new object[] { "Altria Group Inc", 83.81, 0.28, 0.34, "9/1 12:00am" },
            new object[] { "Boeing Co.", 75.43, 0.53, 0.71, "9/1 12:00am" },
            new object[] { "Wal-Mart Stores, Inc.", 45.45, 0.73, 1.63, "9/1 12:00am" }
        };
}

<!DOCTYPE html>

<html>
<head>
    <title>Ext.NET MVC Test Case: Stateful Grid Cell Editing</title>

    <script type="text/javascript">
        var _initialConfig1,
            _initialConfig2;

        Ext.define("My.GridPanel", {
            override: "Ext.grid.Panel",
            constructor: function (config) {
                _initialConfig1 = new Object(config);
                this.callParent(arguments);
                _initialConfig2 = { ...this.initialConfig };
            }
        },
        function () {
            console.log("=> My.GridPanel", arguments);
        });

        var resetLayout1 = function (grid) {

            Ext.each(grid.initialConfig.columns.items, function (column, i) {
                if (column.editor) {
                    var initialConfig = JSON.stringify(column.editor.initialConfig);
                    column.editor = JSON.parse(initialConfig);
                    column.editor.initialConfig = {};
                    column.editor.initialConfig = JSON.parse(initialConfig);
                }
            });

            grid.reconfigure(grid.getStore(), grid.initialConfig.columns.items);
        }

        var resetLayout2 = function (grid) {
            grid.reconfigure(grid.getStore(), _initialConfig1.columns.items);
        }

        var resetLayout3 = function (grid) {
            grid.reconfigure(grid.getStore(), _initialConfig2.columns.items);
        }
    </script>
</head>

<body>
    @(X.ResourceManager())

    @X.DisplayField().ID("version").ReadOnly(true).Margin(10).Width(200)

    @(X.Window().ID("window").Layout(LayoutType.Fit).Width(650).Height(325).X(50).Y(50)
        .Items(
            X.FormPanel().Border(false).BodyPadding(10)
                .LayoutConfig(new VBoxLayoutConfig { Align = VBoxAlign.Stretch })
                .Items(
                    X.GridPanel()
                        .Margin(10)
                        .HeightSpec("100%")
                        .TopBar(X.Toolbar()
                            .Items(
                                X.Button().Text("Reset Layout 1").Icon(Icon.ArrowRotateAnticlockwise).OnClientClick("resetLayout1(this.up('grid'))"),
                                X.Button().Text("Reset Layout 2").Icon(Icon.ArrowRotateAnticlockwise).OnClientClick("resetLayout2(this.up('grid'))"),
                                X.Button().Text("Reset Layout 3").Icon(Icon.ArrowRotateAnticlockwise).OnClientClick("resetLayout3(this.up('grid'))"),
                                X.Button().Text("List <b>initialConfig</b>").Icon(Icon.ApplicationViewList).OnClientClick("console.log('initalConfig', this.up('grid').initialConfig)")
                            )
                        )
                        .Store(X.Store()
                            .Model(X.Model()
                                .Fields(
                                    new ModelField("company"),
                                    new ModelField("price", ModelFieldType.Float),
                                    new ModelField("change", ModelFieldType.Float),
                                    new ModelField("pctChange", ModelFieldType.Float),
                                    new ModelField("lastChange", ModelFieldType.Date, "M/d hh:mmtt")
                                )
                            )
                            .DataSource(Model)
                        )
                        .ColumnModel(
                            X.Column().Text("Company").DataIndex("company").Flex(1)
                                .Editor(X.TextField().AllowBlank(false)),
                            X.Column().Text("Price").DataIndex("price").Renderer(RendererFormat.UsMoney)
                                .Editor(X.NumberField().AllowBlank(false)),
                            X.Column().Text("Change").DataIndex("change"),
                            X.Column().Text("Change %").DataIndex("pctChange"),
                            X.DateColumn().Text("Last Updated").DataIndex("lastChange")
                                .Editor(X.DateField().AllowBlank(false))
                        )
                        .Plugins(X.CellEditing().ClicksToEdit(2))
                        .Stateful(true)
                )
        )
    )
</body>
</html>

<script type="text/javascript">
    Ext.onReady(function () {
        Ext.getCmp("version").setValue("Ext JS " + Ext.getVersion().version + " / " + "Ext.NET " + Ext.net.Version);
    });
</script>

I'm not sure if my intention is easy to achieve at all. If you don't have a "simple" solution, please don't waste time on this issue. After clearing saved component state, I will instruct user to reopen the entire application so that the grid is rendered in its original layout.

Thank you for your assistance.

Kind regards
Dan

**fabricio.murta** · Jan 12, 2022, 8:19 PM

Hello again Dan!

What maybe is wrong here is that you are reconfiguring the grid panel but you want it with the same configuration. Isn't it the case you just reload or refresh data of the grid without the need to redefine columns? Reconfigure is usually useful to re-draw the grid with different columns or columns with different editors, titles... well, its configuration.

The issue here is that the columns must receive the configuration as "config objects" instead of "config instances", and recursively, initialConfig is not honoring the actual config elements (because of all that shallow copy thing explained in the previous post).

Well, the combo box issue might be related to the instanced store it makes which, then would need to be reverted to its "initialConfig" or erased... or just use an external static store and point the combo box to that store. But again, there may be other aspects of components that will be missing after the reconfigure() call simply because they were not in their "configuration" format.

For instance here ([URL=https://examples5.ext.net/#/Kitchen_Sink/GridPanels/Reconfigure_GridPanel/]Kitchen Sink > Grid Panels > Reconfigure Grid Panel[/url), sorry WebForms format) see how the grids are redefined as a whole every time they are reconfigured. It means you cannot pass an existing grid as parameter to reconfigure a grid, exactly because the idea behind reconfigure() is apply a new configuration with different columns and editors, everything afresh.

If all you want is to reload data, you should be fiddling with the grid store, something similar to this MVC example: Grid Panel > Arrayh Grid, Array with Paging. Here, there's no reason editors shall break.

But of course my thoughts may not be actual as you've simplified your example to illustrate the case. The problem is that however we deepen and "deep-copy" the components so that they will be properly reconfigured, more cases should arise, simply because we are trying to use an already instanced and functional grid as parameters to recreate the grid.

I hope this sheds some light to your test case -- maybe thinking outside the box is what we need in order to have your scenario answered.

With that, I mean, in your real case are you defining new columns? Are you changing the editors in the grid dynamically? If that's not the case chances are, you don't need reconfigure() at all...

Let us know how we may best follow-up with your inquire from here.

**NewLink** · Jan 12, 2022, 10:41 PM

Hello Fabrício,
thank you for a quick response. Well, maybe the approach I've chosen isn't the best for my scenario:

The grid is configured as stateful with cell editors. User can hide visible columns and make previously hidden columns visible, can change their position along with their initial width and sorting ... To maintain the persistence of these adjustments, I wrote HttpStateProvider, which saves all changes to the database and restores and applies them, as soon as an application with the grid of the relevant StateId is open. So far so good, everything works.

But then the user decides to go back to the initial grid configuration. So I clear the component state for the grid and I want to return the original grid layout. So, hide the originally hidden columns again, make the initially visible ones visible, restore their order, width, sorting ...

Of course, I can only clear the stored state and let the user reopen an application. But I wanted to offer more comfort and reinitialize the grid to its original state on the fly after clicking on the button rendered as part of the stateful grid toolbar. To do this, I thought that the reconfigure method might serve best.

But maybe I'm wrong ...

Thank you for your opinion and possible help.

Kind regards,
Dan

**fabricio.murta** · Jan 13, 2022, 12:06 AM

I see, it really makes sense the reconfigure. But just making sense doesn't help the problem at hand. The thing is that, in order to reconfigure it you need its "pristine" config object.

In the "easy" approach, you can have the click reload the page after clearing the state. That's the obvious answer, except that you don't really need to ask the user to do the refresh. The same way they'd click to reset the grid to default will allow you to actually send a full postback and receive the whole page afresh with the columns back in place without "leaving the task to the user".

But there are other alternatives to both use Ext.NET power and avoid full page reload (the reconfigure() client side code is deeply dependant in client-side code, so you'd have, for instance, to figure out data structures and counter instanced classes as we already discussed).

Partial views

This is specific to Ext.NET MVC and may be the thing you want: you define the component as a partial view so you can request it afresh anytime you want or need it. As good as a "server-side reconfigure()".

ComponentLoader

Likewise, there's the component loader. It is similar to Partial Views but is not as well integrated with MVC Razor, although it should do just fine if you're up to build the grid from C# code. This is worth mentioning, but if you are in MVC, perhaps your best bet would be Partial views

Both options provide means to return just the grid component at any time so you can mask the view (place a "loading" shade), remove the old one and create a new one afresh. The drawback of the options is exactly its advantage: while it allows you to rely the design in C# and Razor (or WebForms) features, it will require server-side calls to complete, so not as smooth as a 100% client-side approach.

But unfortunately, the 100% client side mode will force you to "sync" between Ext.NET and client-side driven grid.

Back to reconfigure

The reason I'm not going further deep in the reconfigure() dillema is actually because its behavior with editors in the way you wanted to use is so old in Ext JS that I'm safe to say it doesn't work for this scenario by design. That is, you need to pass a pristine fresh config object to it, and reusing an existing grid's structure is not supported at all.

It should work then, provided you really defined the grid 100% with client-side code, so no "guesswork" would be needed to map between Ext.NET init script (which is everything in the "config objects structure" and may simply change due to the smallest change server-side).

Which by the way, brings to the second post you made to this thread, in particular at:

Originally Posted by NewLink

I also tried to back up the initial grid configuration directly in its constructor, but it results in the same errors

Then in your code I see two possible mistakes:
1. You're doing the "backup" in grid constructor (good) without a deep clone (bad). This invalidates all three attempts to reconfigure later
2. In resetLayout1() you actually do a deep clone by JSON manipulation... but well, that's just too late for that.

Furthermore it seems there's a nice (and hopefully performatic) structuredClone() but we cannot guarantee it works, and we're going really overboard in extensions. It may just work now, and then suddenly fail in future releases, it's beyond our reach. In a sense, partial views and component loaders are there to fill this gap we have here so maybe it's worth the time investigating.

Let me make a little summary of the options because this ended up pretty extensive:

Alternative 1: Be pragmatic. Clear the state and reload the page. You don't need the customer to manually reload the page at least. :)
Alternative 2: Use Partial views. It is more extensively supported in Ext.NET MVC, but may involve a steep learning curve.
Alternative 3: Use ComponentLoader. This is more intrinsically supported in Ext.NET WebForms but if you're happy with grid 100% written in C# might be a feasible alternative even in MVC, with perhaps softer learning curve.
Alternative 4: Deep clone and enjoy 100% client-side performance. You're already in a reasonable track by tampering with the constructor, just need to apply deep cloning of the structure at the right time and it should work! But we're going way overboard Ext.NET and ExtJS and as your override suggests, building your very own solution for the problem (which is actually fine, especially if you master extensions in Ext JS -- but that's another topic... summary already too long!)

Well, hope this helps and gives you good guides towards the challenge you have at hand!

**NewLink** · Jan 14, 2022, 2:31 PM

Hi Fabrício,
thank you for your suggestions. Because the server-side solution, not only thanks to MVC, I found too "heavy" and "expensive", I focused on the client-side solution. Unfortunately, none of the tested concepts brought success:

1. I implemented deep object copy and cloned the initial configuration as suggested. The result was the same - all grid editors turned into simple text fields.

2. Then I tried to remove the CellEditing plugin and add it again. This has not been successful, as the plugin seems to be not easily destroyable once attached to the grid.

3. To make sure it makes sense to look for the right way to properly remove the plugin, I deleted line #107 in my last sample code and added a CellEditing after grid reconfiguration. This led to a situation similar to point 1 - editors were added as simple text fields regardless of the columns type.

Conclusion: For grids without CellEditing, reconfigure method seems to work well. Once this plugin is used, it looks tricky to initialize the grid to its original configuration, editors are incorrectly assigned to columns according to their type.

Thank you for your help and effort, the thread may be closed.

Kind regards
Dan

**fabricio.murta** · Jan 14, 2022, 10:16 PM

Hello again, Dan!

The problem about (1) (deep object copy) after further checking is that Ext.NET's emitted code has the editors, instead of simple objects, initializers for the editors. So at the point the constructor is run, it is already too late, sorry I overlooked this detail.

In other words, here's how the code for your example looks like:

columns: {
    items: [{
        flex: 1,
        dataIndex: "company",
        editor: new Ext.grid.CellEditor(Ext.apply({
            field: {
                xtype: "textfield",
                validateOnFocusLeave: true,
                allowBlank: false
            }
        }, {})),
        text: "Company"
    }, {
        dataIndex: "price",
        editor: new Ext.grid.CellEditor(Ext.apply({
            field: {
                xtype: "numberfield",
                validateOnFocusLeave: true,
                allowBlank: false,
                decimalSeparator: "."
            }
        }, {})),
        renderer: Ext.util.Format.usMoney,
        text: "Price"
    }, {
        dataIndex: "change",
        text: "Change"
    }, {
        dataIndex: "pctChange",
        text: "Change %"
    }, {
        xtype: "datecolumn",
        dataIndex: "lastChange",
        editor: new Ext.grid.CellEditor(Ext.apply({
            field: {
                xtype: "datefield",
                allowBlank: false,
                ariaFormat: "n/j/Y",
                format: "n/j/Y",
                submitFormat: "n/j/Y"
            }
        }, {})),
        text: "Last Updated"
    }]
}

With those Ext.grid.CellEditor() lines, the Editor config gets the instanced very early, being already done as the config is passed to the grid's constructor. Ext.NET usually has the LazyMode setting that forces the output as simple objects as we needed here -- but this particular setting does not implement the feature.

In order to output the editor lines as simple objects we can define the components in code behind and assign them to the columns via CustomConfigs, so in the end not even deep cloning becomes necessary.

Basically, the example below "tricks" Ext.NET into rendering the editors as simple config objects instead of instancing. It really looks like we didn't foresee this scenario so LazyMode was never implemented for editors. For the tests I ran here, the components works fine.

Of course, if you're on with dropboxes or combos -- components with a store -- it might be a good idea to have a static store defined outside of the grid, then just referenced by the editor component via the StoreID config, so the store itself doesn't need to be destroyed and recreated every time. If it is a combo with a small number of options though, it might not really hurt to rewrite it.

@using Ext.Net;
@using Ext.Net.MVC;

@{
    Layout = null;

    var X = Html.X();

    var Model = new object[]
    {
        new object[] { "Alcoa Inc", 29.01, 0.42, 1.47, "9/1 12:00am" },
        new object[] { "Altria Group Inc", 83.81, 0.28, 0.34, "9/1 12:00am" },
        new object[] { "Boeing Co.", 75.43, 0.53, 0.71, "9/1 12:00am" },
        new object[] { "Wal-Mart Stores, Inc.", 45.45, 0.73, 1.63, "9/1 12:00am" }
    };

    var TextFieldEditor = new TextField()
    {
        AllowBlank = false
    };

    var NumberFieldEditor = new NumberField()
    {
        AllowBlank = false
    };

    var DateFieldEditor = new DateField()
    {
        AllowBlank = false
    };


}

<!DOCTYPE html>

<html>
<head>
    <title>Ext.NET MVC Test Case: Stateful Grid Cell Editing</title>

    <script type="text/javascript">
        var resetLayout = function (grid) {
            grid.reconfigure(grid.getStore(), grid.initialConfig.columns.items);
        }
    </script>
</head>

<body>
    @(X.ResourceManager())

    @X.DisplayField().ID("version").ReadOnly(true).Margin(10).Width(200)

    @(X.Window().ID("window").Layout(LayoutType.Fit).Width(650).Height(325).X(50).Y(50)
        .Items(
            X.FormPanel().Border(false).BodyPadding(10)
                .LayoutConfig(new VBoxLayoutConfig { Align = VBoxAlign.Stretch })
                .LazyMode(LazyMode.Config)
                .Items(
                    X.GridPanel()
                        .Margin(10)
                        .HeightSpec("100%")
                        .TopBar(X.Toolbar()
                            .Items(
                                X.Button().Text("Simple Reset Layout").Icon(Icon.ArrowRotateAnticlockwise).OnClientClick("resetLayout(this.up('grid'))"),
                            )
                        )
                        .Store(X.Store()
                            .Model(X.Model()
                                .Fields(
                                    new ModelField("company"),
                                    new ModelField("price", ModelFieldType.Float),
                                    new ModelField("change", ModelFieldType.Float),
                                    new ModelField("pctChange", ModelFieldType.Float),
                                    new ModelField("lastChange", ModelFieldType.Date, "M/d hh:mmtt")
                                )
                            )
                            .DataSource(Model)
                        )
                        .ColumnModel(
                            X.Column().Text("Company").DataIndex("company").Flex(1)
                                .CustomConfig(c => c.Add(
                                    new ConfigItem("editor", TextFieldEditor.ToConfig(), ParameterMode.Raw))
                                ),
                            X.Column().Text("Price").DataIndex("price").Renderer(RendererFormat.UsMoney)
                                .CustomConfig(c => c.Add(
                                    new ConfigItem("editor", NumberFieldEditor.ToConfig(), ParameterMode.Raw))
                                ),
                            X.Column().Text("Change").DataIndex("change"),
                            X.Column().Text("Change %").DataIndex("pctChange"),
                            X.DateColumn().Text("Last Updated").DataIndex("lastChange")
                                .CustomConfig(c => c.Add(
                                    new ConfigItem("editor", DateFieldEditor.ToConfig(), ParameterMode.Raw))
                                )
                        )
                        .Plugins(X.CellEditing().ClicksToEdit(2))
                        .Stateful(true)
                )
        )
    )
</body>
</html>

<script type="text/javascript">
    Ext.onReady(function () {
        Ext.getCmp("version").setValue("Ext JS " + Ext.getVersion().version + " / " + "Ext.NET " + Ext.net.Version);
    });
</script>

We have logged the missing LazyMode support under #1870.

Hope this helps!

**NewLink** · Jan 17, 2022, 3:37 PM

Hi Fabrício,
thanks for the great sample code. I also checked the generated client-side code for the columns, but I didn't see any connection to our matter. But when you put it this way, it's suddenly clear. There is always something to learn ...

Thank you for a nice piece of code that clearly shows where the problem is. When you come up with a solution to issue #1870, I'll test it again.

Kind regards
Dan

Thread: [OPEN] [#1870] Stateful grid with cell editing - reconfiguration causes the cell editor to be destroyed

Thread Tools

Search Thread

Display

[OPEN] [#1870] Stateful grid with cell editing - reconfiguration causes the cell editor to be destroyed

Similar Threads

On cell editing Cell display the default value.

Editing grid panel cell to modify other.

[CLOSED] Disabling cell editing based on cell value in Ext.Net 2.1

[CLOSED] Cell editing with complex editor

[CLOSED] How to make the Editable cell Empty if the cell contain a Zero '0' value when editing??

Tags for this Thread

Posting Permissions

Sitemap

Downloads

Resources

Thread: [OPEN] [#1870] Stateful grid with cell editing - reconfiguration causes the cell editor to be destroyed

[OPEN] [#1870] Stateful grid with cell editing - reconfiguration causes the cell editor to be destroyed

Similar Threads

Tags for this Thread

Posting Permissions

Sitemap

Downloads

Resources

Stay connected with us