Important Notice - Forums is archived
To simplify things and help our users to be more productive, we have archived the current forum and focus our efforts on helping developers on Stack Overflow. You can post new questions on Stack Overflow or join our Discord channel.

TUTORIALVaadin lets you build secure, UX-first PWAs entirely in Java.
Vaadin lets you build secure, UX-first PWAs entirely in Java.
Free ebook & tutorial.
Calling javascript synchronously by Enver Haase, 3 weeks ago
Hierarchical Container and TreeTable
Hi all,
i seem to don't get the Hierarchical Container:
I'm trying to implement a simple one just for testing the basics and...it doesn't work.
Here's my code:
The container, implementing Container, Collapsible, Container.Indexed
public class TestHContainer implements Container, Collapsible, Container.Indexed {
private List<SimpleItem> items;
public TestHContainer() {
this.items = new LinkedList<SimpleItem>();
for(int i = 0; i < 55; i++){
items.add(new SimpleItem(i));
}
}
@Override
public Collection<?> getChildren(Object itemId) {
assert itemId instanceof SimpleItem;
Integer index = ((SimpleItem)itemId).getIndex();
assert index != null;
if((index % 10) == 0){
LinkedList<SimpleItem> list = new LinkedList<SimpleItem>();
for(int i = 1; i < 10; i++){
list.add(items.get(index + i));
}
System.out.println("getChildren("+itemId+").size="+list.size());
return list;
}else{
System.out.println("getChildren("+itemId+")= not root");
return new LinkedList<SimpleItem>();
}
}
@Override
public Object getParent(Object itemId) {
assert itemId instanceof SimpleItem;
Integer index = ((SimpleItem)itemId).getIndex();
assert index != null;
index = index - (index % 10);
System.out.println("getParent("+itemId+")="+items.get(index));
return items.get(index);
}
@Override
public Collection<?> rootItemIds() {
throw new UnsupportedOperationException();
}
@Override
public boolean setParent(Object itemId, Object newParentId)
throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public boolean areChildrenAllowed(Object itemId) {
assert itemId instanceof SimpleItem;
Integer index = ((SimpleItem)itemId).getIndex();
assert index != null;
return (index % 10) == 0;
}
@Override
public boolean setChildrenAllowed(Object itemId, boolean areChildrenAllowed)
throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public boolean isRoot(Object itemId) {
assert itemId instanceof SimpleItem;
Integer index = ((SimpleItem)itemId).getIndex();
assert index != null;
return (index % 10) == 0;
}
@Override
public boolean hasChildren(Object itemId) {
assert itemId instanceof SimpleItem;
Integer index = ((SimpleItem)itemId).getIndex();
assert index != null;
System.out.println("hasChildren("+itemId+")="+((index % 10) == 0));
return (index % 10) == 0;
}
@Override
public Object nextItemId(Object itemId) {
assert itemId instanceof SimpleItem;
Integer index = ((SimpleItem)itemId).getIndex();
assert index != null;
return items.get( index +1);
}
@Override
public Object prevItemId(Object itemId) {
assert itemId instanceof SimpleItem;
Integer index = ((SimpleItem)itemId).getIndex();
assert index != null;
return items.get( index -1);
}
@Override
public Object firstItemId() {
return items.get(0);
}
@Override
public Object lastItemId() {
return items.get(items.size()-1);
}
@Override
public boolean isFirstId(Object itemId) {
assert itemId instanceof SimpleItem;
Integer index = ((SimpleItem)itemId).getIndex();
assert index != null;
return index == 0;
}
@Override
public boolean isLastId(Object itemId) {
assert itemId instanceof SimpleItem;
Integer index = ((SimpleItem)itemId).getIndex();
assert index != null;
return index == items.size()-1;
}
@Override
public Object addItemAfter(Object previousItemId)
throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public Item addItemAfter(Object previousItemId, Object newItemId)
throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public int indexOfId(Object itemId) {
assert itemId instanceof SimpleItem;
Integer index = ((SimpleItem)itemId).getIndex();
assert index != null;
return index;
}
@Override
public Object getIdByIndex(int index) {
return items.get(index);
}
@Override
public Object addItemAt(int index) throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public Item addItemAt(int index, Object newItemId)
throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public void setCollapsed(Object itemId, boolean collapsed) {
assert itemId instanceof SimpleItem;
((SimpleItem)itemId).setCollapsed(collapsed);
}
@Override
public boolean isCollapsed(Object itemId) {
assert itemId instanceof SimpleItem;
System.out.println("isCollapsed("+itemId+")=="+((SimpleItem)itemId).isCollapsed());
return ((SimpleItem)itemId).isCollapsed();
}
@Override
public Item getItem(Object itemId) {
assert itemId instanceof SimpleItem;
return ((SimpleItem)itemId);
}
@Override
public Collection<?> getContainerPropertyIds() {
return items.get(0).getItemPropertyIds();
}
@Override
public Collection<?> getItemIds() {
throw new UnsupportedOperationException();
}
@Override
public Property getContainerProperty(Object itemId, Object propertyId) {
assert itemId instanceof SimpleItem;
return ((SimpleItem)itemId).getItemProperty(propertyId);
}
@Override
public Class<?> getType(Object propertyId) {
return items.get(0).getItemProperty(propertyId).getType();
}
@Override
public int size() {
return items.size();
}
@Override
public boolean containsId(Object itemId) {
return items.contains(itemId);
}
@Override
public Item addItem(Object itemId) throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public Object addItem() throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public boolean removeItem(Object itemId)
throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public boolean addContainerProperty(Object propertyId, Class<?> type,
Object defaultValue) throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public boolean removeContainerProperty(Object propertyId)
throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public boolean removeAllItems() throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
}
The item
public class SimpleItem implements Item{
private static LinkedList<String> propertyIds;
private Integer index;
private boolean collapsed = false;
public SimpleItem(Integer index) {
this.index = index;
}
@Override
public Property getItemProperty(Object id) {
if("id".equals(id)){
return new ObjectProperty<Integer>(this.index);
}else if("nome".equals(id)){
return new ObjectProperty<String>("nome "+ this.index);
}else{
throw new InvalidParameterException();
}
}
@Override
public Collection<?> getItemPropertyIds() {
if(propertyIds == null){
propertyIds = new LinkedList<String>();
propertyIds.add("id");
propertyIds.add("nome");
}
return propertyIds;
}
@Override
public boolean addItemProperty(Object id, Property property)
throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
@Override
public boolean removeItemProperty(Object id)
throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
public Integer getIndex() {
return index;
}
public void setIndex(Integer index) {
this.index = index;
}
public boolean isCollapsed() {
return collapsed;
}
public void setCollapsed(boolean collapsed) {
this.collapsed = collapsed;
}
@Override
public String toString() {
return "SimpleItem@"+index;
}
}
The testing component
TreeTable tree = new TreeTable();
tree.setContainerDataSource(new TestHContainer());
addComponent(tree);
the items Hierarchy is simple:
0
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
10
-11
-12
-13
-14
-15
and so on
but i get this:
the Hierarchy seem correct but if i try to expand or collapse a root nothing happens
What am I doing wrong?
Last updated on Jun, 15th 2012
You cannot reply to this thread.