Eclipse Community Forums: NatTable » Simple Cell Editing

Search

Help

Login

Home » Eclipse Projects » NatTable » Simple Cell Editing

Show: Today's Messages :: Show Polls :: Message Navigator

Switch to threaded view of this topic

Create a new topic

Submit Reply

Simple Cell Editing [message #1053708]

Tue, 07 May 2013 10:43

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Hi,
I'm tinker with this problem since a couple of hours and even if it's so basic, I can't get it working.
So all I need is a simple Text(Cell)Editor for selected cells and maybe a check an input check (so that only numbers can be put in).

This is the code:

dataProvider = new DataProvider();
		final ViewportLayer layer = new ViewportLayer( new DataLayer(dataProvider) );
		
		
		IConfigLabelAccumulator cellLabelAccumulator = new IConfigLabelAccumulator() {
			
			public void accumulateConfigLabels(LabelStack configLabels, int columnPosition, int rowPosition) {
				
					configLabels.addLabel("myCellLabel"); 
					
				} 
			};
		layer.setConfigLabelAccumulator(cellLabelAccumulator);
		
		
		
		

		
		natTable = new NatTable(container, layer, false);
		natTable.addConfiguration(new AbstractRegistryConfiguration() {
			public void configureRegistry(IConfigRegistry configRegistry) {
				TextCellEditor textCellEditor = new TextCellEditor();
				configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITOR, textCellEditor, DisplayMode.EDIT, "myCellLabel");
				//configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
				
				
				
			}
			
			
		});

		
		
		
		natTable.addConfiguration(new DefaultNatTableStyleConfiguration());
		natTable.configure();

Neither of the "configRegistry.registerConfigAttribute(..)" functions work. What did I do wrong?

Report message to a moderator

Re: Simple Cell Editing [message #1053717 is a reply to message #1053708]

Tue, 07 May 2013 11:28

Dirk Fauth is currently offline

Friend

Messages: 2903
Registered: July 2012

Senior Member

The label mechanism is the way to configure things for special cases. What you want to do is to configure that all cells are always editable.

a) you need to enable editing by editing rule. you commented it so there is nothing editable
b) as you are not using the GridLayer, the configuration of the handlers and bindings are missing. You need the configurations as expressed in DefaultEditConfiguration and DefaultEditBindings.
c) you don't need the labels in your case so you can get rid of the IConfigLabelAccumulator

Report message to a moderator

Re: Simple Cell Editing [message #1053718 is a reply to message #1053717]

Tue, 07 May 2013 11:29

Dirk Fauth is currently offline

Friend

Messages: 2903
Registered: July 2012

Senior Member

Oh, you could of course simply add the DefaultEditBindings as configuration to your NatTable, but then you will need to set the region label of the viewport to GridRegion.BODY

Report message to a moderator

Re: Simple Cell Editing [message #1053938 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

http://www.imgbox.de/users/public/images/SYoXmW16e9.jpg

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add

natTable.addConfiguration(new DefaultEditConfiguration());

as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1053939 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

http://www.imgbox.de/users/public/images/SYoXmW16e9.jpg

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add

natTable.addConfiguration(new DefaultEditConfiguration());

as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1053960 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1053961 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1053982 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1053983 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054006 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054007 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054030 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054031 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054033 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

http://www.imgbox.de/users/public/images/SYoXmW16e9.jpg

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add

natTable.addConfiguration(new DefaultEditConfiguration());

as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054059 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054060 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054088 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054089 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054091 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054118 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054119 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054121 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054150 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054151 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054153 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054184 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054185 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054187 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054221 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054222 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054224 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054259 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054260 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054262 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054296 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054297 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054299 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054335 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054336 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054338 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054375 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054376 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054378 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054415 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054416 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054418 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054455 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054456 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054458 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054496 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054497 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054499 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054537 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054538 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054540 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054579 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054580 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054582 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054621 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054622 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054624 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054664 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054665 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054667 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054707 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054708 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054710 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054751 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054752 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054754 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054798 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054799 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054801 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054847 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054848 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054850 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054900 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054901 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054903 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054954 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054955 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1054957 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055010 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055011 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055013 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055068 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055069 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055071 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055130 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055131 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055133 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055191 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055192 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055194 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055254 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055255 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055257 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055319 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055320 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055322 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055386 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055387 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055389 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055453 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055454 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055456 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055523 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055524 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055526 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055593 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055594 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055596 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055666 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055667 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055669 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055739 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055740 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055742 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055812 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055813 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055815 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055891 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055892 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055894 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055969 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055970 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1055972 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056048 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056049 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056051 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056130 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056131 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056133 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056215 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056216 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056218 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056301 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056302 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056304 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056389 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056390 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056392 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056481 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056482 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056484 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056576 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056577 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056579 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056672 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056673 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056675 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056768 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056769 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056771 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056866 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056867 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056869 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056967 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056968 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1056970 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057070 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057071 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057073 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057175 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057176 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057178 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057279 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057280 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057282 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057384 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057385 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057387 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057490 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057491 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057493 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057602 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057603 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057605 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057710 is a reply to message #1053718]

Wed, 08 May 2013 07:36

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057711 is a reply to message #1053718]

Wed, 08 May 2013 07:37

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057713 is a reply to message #1053718]

Wed, 08 May 2013 08:02

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Thank you for the quick answer.
Just in case this changes your advises: This is just to test how editing works at all. What I'm eventually going to do (or what I want to achieve) is that only columns containing certain keywords are allowed to be edited.
For example I have a table with keywords like "measurement" , "time stamp" and "constant" as a keyword in the first row. And only those columns (or rather one cell in the column) with the keyword "constant" should be editable. So it should just be like this with just the red cell editable:

I would like to avoid columnHeaderLayer and rowHeaderLayers, thats why I chose the ViewPortLayer.
Now if I add:

layer.setRegionName(GridRegion.BODY);
configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
natTable.addConfiguration(new DefaultEditBindings());

it still doesn't work.
And if I add
natTable.addConfiguration(new DefaultEditConfiguration());
as well, I get an error saying:
"org.eclipse.nebula.widgets.nattable.NatTable cannot be cast to org.eclipse.nebula.widgets.nattable.layer.AbstractLayer"
(It gets thrown when I call natTable.configure)

Report message to a moderator

Re: Simple Cell Editing [message #1057760 is a reply to message #1054091]

Wed, 08 May 2013 15:25

Dirk Fauth is currently offline

Friend

Messages: 2903
Registered: July 2012

Senior Member

Hm, have you tried to add the configurations to the ViewportLayer instead of adding it to the NatTable instance?

I think there is also a post regarding the same topic in this forum. Maybe that helps too?

Report message to a moderator

Re: Simple Cell Editing [message #1057801 is a reply to message #1057760]

Wed, 08 May 2013 20:46

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Okay. Another two and a half hours without any glimpse of success.
I tried to understand EditableGridExample and failed when I tried to implement a DefaultGridLayer. (But at least I learned sth about Reflection Razz

Razz

).
So.. before I do any more research: Is the GridLayer necessary for editing cells? I can remember that I chose the ViewPortLayer for a certain reason, so I would like to keep it.
I tried to add the configuration to the ViewPortLayer but nothing happens.
Also I tried to find the topic you mentioned, but I couldn't find any other than I found previously.

This is my code now..

final ViewportLayer layer = new ViewportLayer( new DataLayer(dataProvider) );
		
		
		IConfigLabelAccumulator cellLabelAccumulator = new IConfigLabelAccumulator() {
			
			public void accumulateConfigLabels(LabelStack configLabels, int columnPosition, int rowPosition) {
				
					configLabels.addLabel("myCellLabel"); 
					
				} 
			};
		layer.setConfigLabelAccumulator(cellLabelAccumulator);
		layer.setRegionName(GridRegion.BODY);
		
		
		
		layer.addConfiguration(new AbstractRegistryConfiguration() {
			public void configureRegistry(IConfigRegistry configRegistry) {
				TextCellEditor textCellEditor = new TextCellEditor();
				configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITOR, textCellEditor, DisplayMode.EDIT, "myCellLabel");
				configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
				configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE);
				
				
				
			}
			
			
		});
		
		natTable = new NatTable(container, layer, false);
		natTable.addConfiguration(new AbstractRegistryConfiguration() {
			public void configureRegistry(IConfigRegistry configRegistry) {
				TextCellEditor textCellEditor = new TextCellEditor();
				configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITOR, textCellEditor, DisplayMode.EDIT, "myCellLabel");
				configRegistry.registerConfigAttribute( EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE, DisplayMode.EDIT, "myCellLabel");
				configRegistry.registerConfigAttribute(EditConfigAttributes.CELL_EDITABLE_RULE, IEditableRule.ALWAYS_EDITABLE);
				
			}
			
			
		});
		
		natTable.addConfiguration(new DefaultEditConfiguration());
		natTable.addConfiguration(new DefaultEditBindings());
		natTable.addConfiguration(new DefaultNatTableStyleConfiguration());
		natTable.configure();

By the way: I think that its really good how many example classes you provide as an "how to do". But for example the "EditableGridExample ": why does it need to be so big? I would much more appreciate a 4by4 table with as few configurations as possible. But on the other hand you do a great job in the forum Smile

Smile

Thanks

Report message to a moderator

Re: Simple Cell Editing [message #1057803 is a reply to message #1057801]

Wed, 08 May 2013 21:24

Dirk Fauth is currently offline

Friend

Messages: 2903
Registered: July 2012

Senior Member

natTable.addConfiguration(new DefaultEditConfiguration());

as explained before, this should be

layer.addConfiguration(new DefaultEditConfiguration());

That is because DefaultEditConfiguration is an AbstractLayerConfiguration.

Quote:

But for example the "EditableGridExample ": why does it need to be so big?

Several answers to that:
a) it is an example from quite early stages
b) it shows that editing is possible for large grids
c) it shows several functionality in one because we don't want to create thousands of examples for every single functionality Wink

Wink

We will rework the examples in some way, but some of them will be also quite large (see point c). But maybe we should think about adding a small example on how to add editing to a non grid NatTable. That might be helpful. Smile

Smile

Report message to a moderator

Re: Simple Cell Editing [message #1057875 is a reply to message #1057803]

Thu, 09 May 2013 13:41

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Puh okay. I'm nearly finished.It took some time to figure out that I have to add org.apache.commons.logging to the nattable Manifest.mf instead of including it to the build path and there were some other issues as well, but every thing works except for one thing.

My dataProvider has a boolean function that returns whether a cell, belonging to a rowIndex and columnIndex, is editable or not.
But IConfigLabelAccumulator#accumulateConfigLabels(LabelStack configLabels, int columnPosition, int rowPosition)
does not provide the real column-/rowIndex but more like a local index (if my window is so big that it can display 12 columns, the max value of columnPosition will be 12, even if my table contains 15 columns).
I tried a couple of different LabelAccumulators but the behaviour doesn't change. Why is this intented and how can I solve this issue?
Thanks a lot so far!!!

Report message to a moderator

Re: Simple Cell Editing [message #1057923 is a reply to message #1057875]

Thu, 09 May 2013 19:52

Dirk Fauth is currently offline

Friend

Messages: 2903
Registered: July 2012

Senior Member

That's why you usually attach the label provider to the data provider instead of setting it to the viewport. The viewport only deals with visible cells.

Report message to a moderator

Re: Simple Cell Editing [message #1057979 is a reply to message #1057923]

Fri, 10 May 2013 10:07

Aljoscha Steffens is currently offline

Aljoscha Steffens

Friend

Messages: 302
Registered: November 2012

Senior Member

Hmm don't you mean dataLayer? Can't find any way to attach it to the bodyProvider. Anyway, ViewPortLayer provides #localToUnderlyingColumnPosition(localColumnPosition) and #localToUnderlyingRowPosition(localRowPosition)
They convert the position so that it works.
Thank you!

Report message to a moderator

Re: Simple Cell Editing [message #1058040 is a reply to message #1057979]

Fri, 10 May 2013 15:11

Dirk Fauth is currently offline

Friend

Messages: 2903
Registered: July 2012

Senior Member

Yes I meant DataLayer, sorry for that.

Jup, transforming the indexes is also a valid solution.

Report message to a moderator

Switch to threaded view of this topic

Create a new topic

Submit Reply

Previous Topic:	Comobobx cells
Next Topic:	Cell Painter

Goto Forum:

-=] Back to Top [=-

[ Syndicate this forum (XML) ] [

]

Current Time: Mon Dec 30 14:54:36 GMT 2024

Powered by FUDForum. Page generated in 0.48484 seconds

.:: Contact :: Home ::.

Powered by: FUDforum 3.0.2.
Copyright ©2001-2010 FUDforum Bulletin Board Software

Back to the top