You will need a few things for it.

1. You will need a TextField whose size depends on the size of its contents.
2. Probably you may want this TextField's UI to not have any border (for it no-bevels? is true in the code below}.
3. You will need a Frame that will either show a TextField or just a label, depending upon whether you are in the editing mode or not.
4. You will need to put the Frame in 3 in a TreeNode.
5. You will need a KeyPress handler in your TreeControl to listen for F2 key press to make the tree node editable.

Here is some code that does it.

 
 
{curl 5.0, 6.0, 7.0 applet}
{curl-file-attributes character-encoding = "windows-latin-1"}
 
{define-class package AutoResizeTextFieldUI {inherits StandardTextFieldUI}
  field private no-bevel?:bool = false
 
  {constructor package {default
                           control:#TextField = null,
                           ...
                       }
    {construct-super control = control, ...}
    set self.control-content-background = FillPattern.transparent
  }
  
  {getter public open {auto-resize-text-filed}:AutoResizeTextField
    {return self.control asa AutoResizeTextField}
  }
 
  {setter public open {control value:Control}:void
    set super.control = value
    set self.no-bevel? = self.auto-resize-text-filed.no-bevel?
    {self.flatten-hierarchy}
  }
  
  {method private {flatten-hierarchy}:void
    {if not self.no-bevel? then {return}}
 
    {self.visit-subtree
        self,
        {proc {g:Graphic}:void
            set g.border-width = 0pt
            set g.margin = 0pt
        }
    }
  }
 
  {method private {visit-subtree 
                      g:Graphic, 
                      action-proc:{proc-type {Graphic}:void}
                  }:void
    {action-proc g}
    {type-switch g
     case b:Box do
        {for child:Graphic in b.graphical-children do
            {self.visit-subtree child, action-proc}
        }
    }
  }
 
 
  || Do not draw any bevels.; squelch context menu
  {method protected open {overdraw-control renderer2d:Renderer2d}:void
    {if not self.no-bevel? then
        {super.overdraw-control renderer2d}
    }
  }
 
  {method public open {get-width-preference lc:LayoutContext}:Dimension
    {return 
        {self.adjust-width-preference 
            {super.get-width-preference lc}, lc
        }
    }
  }
            
  {method public open {constrain-height
                          lc:LayoutContext,
                          ascent:Distance,
                          descent:Distance}:Dimension
    {return
        {self.adjust-width-preference 
            {super.constrain-height lc, ascent, descent}, lc
        }
    }
  }
 
  {method protected open {adjust-width-preference
                             d:Dimension, lc:LayoutContext
                         }:Dimension
    {return
        {if-non-null child = self.child then
            child.cell-width-preference
         else
            d
        }
    }
  }
}
 
 
{define-class package AutoResizeTextField {inherits TextField}
  field private label:EditableText
  field constant public-get no-bevel?:bool
 
  {constructor package {default
                           label:EditableText,
                           no-bevel?:bool = true,
                           ...
                       }
    set self.no-bevel? = no-bevel?
 
    {construct-super 
        ui-object = {AutoResizeTextFieldUI},
        control-appearance-changeable? = true
    }
                                 
    set self.label = label
    {self.add-event-handler
        {on e:ValueFinished do
            {self.maybe-commit}
        }
    }
  }
 
  {method public open {maybe-commit}:void
    let constant val:String = self.value
    {if val.empty? then
        {self.label.revert}
     else
        {self.label.commit val}
    }
  }
  
  {method public open {on-focus-out e:FocusOut}:void
    {super.on-focus-out e}
    {self.maybe-commit}
  }
 
  {method public open {on-key-press e:KeyPress}:void
    {super.on-key-press e}
 
    {if e.value == KeyPressValue.esc then
        set self.value = ""
        {self.label.revert}
     elseif e.value != KeyPressValue.enter then
        {self.request-layout}
    }
  }
}
 
 
{define-class public EditableText {inherits BaseFrame}
  field protected data:String
  field protected old-data:String
  field protected frame:Frame
  field private editing?:bool = false
 
  field constant public no-bevel?:bool
 
  {constructor public {default data:String, no-bevel?:bool = true, ...}
    set self.no-bevel? = no-bevel?
    set self.data = data
    set self.old-data = data
    set self.frame = {Frame data}
    {self.add-internal self.frame}
    set self.opaque-to-events? = true
  }
  
  {method public open {make-editable}:void
    {if not self.editing? then
        set self.editing? = true
        let constant tf:TextField = {self.make-textfield}
        set tf.value = self.data
        set self.old-data = self.data
        {self.request-draw}
        {self.frame.add tf, replace? = true}
        {tf.become-active}
    }
  }
 
  {method public open {commit str:String}:void
    set self.data = str
    {self.frame.add str, replace? = true}
    set self.editing? = false
  }
 
  {method public open {revert}:void
    {self.frame.add self.old-data, replace? = true}
    set self.editing? = false
  }
 
  {method public open {make-textfield}:TextField
    {return
        {AutoResizeTextField
            self,
            no-bevel? = self.no-bevel?,
            {on e:ValueFinished do
                {self.handle-event e}
            }
        }
    }
  }
}
 
 
{define-class public CustomTreeNode {inherits DefaultTreeNode}
  field public constant no-bevel?:bool
  field private editable-text:EditableText
  {constructor public {default node-data:String = "", no-bevel?:bool = true, ...:TreeNode}
    set self.no-bevel? = no-bevel?
    set self.editable-text =
        {EditableText
            node-data,
            no-bevel? = self.no-bevel?,
            {on e:ValueFinished at et:EditableText do
                set self.node-data = {et.get-text}
            }
        }
    {construct-super node-data = node-data, ...}
  }
 
  {getter public open {node-label}:any
    {return self.editable-text}
  }
}
 
 
{TreeControl
    data-model =
        {TreeModel
            root = 
                {CustomTreeNode node-data = "Food",
                    {CustomTreeNode node-data="Fruit",
                        {CustomTreeNode node-data="Apples",
                            {CustomTreeNode node-data="Macintosh"},
                            {CustomTreeNode node-data="Cortland"},
                            {CustomTreeNode node-data="Gala"},
                            {CustomTreeNode node-data="Delicious"}
                        },
                        {CustomTreeNode node-data="Oranges"}
                    },
                    {CustomTreeNode node-data="Vegitables",
                        {CustomTreeNode node-data="Squash"},
                        {CustomTreeNode node-data="Tomatoes"},
                        {CustomTreeNode node-data="Cucumbers"}
                    }
                }
        },
    {on e:KeyPress at tc:TreeControl do
        {if e.value == KeyPressValue.f2 then
            {if-non-null node = tc.current-node then
                {type-switch node.node-label
                 case et:EditableText do
                    {et.make-editable}
                    {e.consume}
                }
            }
        }
    }
}
 
 
 

Message was edited by: Kamal