Re: [platform-debug-dev] Behaviour of variable expansion

[sutton@xxxxxxxxxx]

Maintaining the expanded state on thread resume would help, but does not
completely solve the problem.

Suppose the user is stepping into function bar() from function foo(), and
they already have a number of the global variables expanded.  The user
wants to see the global variables still expanded when they stop in bar().
(The same would apply if they are in function foo() and run to a breakpoint
in function bar().)

Maybe the DebugModelPresentation could be responsible for maintaining the
expanded state of each variable.  The Variables view could ask the
DebugModelPresentation for the expansion state for a particular variable,
and tell the DebugModelPresentation about the expansion state for a
variable when it changes.  For example, add the following 2 methods to
IDebugModelPresentation:
     boolean getIsVariableExpanded(IVariable variable);
     void setVariableExpanded(IVariable variable, boolean isExpanded);

Bruce Sutton
-------------------------------------------------------------------------------------------------------------------------------------------------------------

I hestiate to add a method to the "headless" debug model that deals
directly with presentation. Generally, methods/attributes on our model
objects represent
  state that the presentation can take advantage of, but the model objects
themselves do not directly control the presentation.

  We need to look at this problem in more detail. Perhaps it is really
related to the problem that the variable view collapses variables on thread
resumes, when
  it should try to maintain its expanded state.

  Darin





 To:        platform-debug-dev@xxxxxxxxxxx
  cc:
  Subject:        [platform-debug-dev] Behaviour of variable expansion



One of the plugins we are building has a usability problem with collapsed
variables.

Some variables are global and therefore appear in the Variables view for
every selected stackframe.

These globals tend to be complex and to be useful, the user must expand
them.

The problem is that they are always being collapsed because the stackframes
change on step, run etc. forcing the user to expand these globals after
every step, run etc.

We know that the debug core won't be able to remember expansion of
variables because the stackframes are changing ...

so...

we have a suggestion to help with complex variables.   Add the notion of
"autoExpand" to the variable.   This would allow the debug plugins to
dictate to the variables view that it should expand this variable.

Something like:
    boolean IVariable.autoExpand()

    where "true" means that the Variable view should force expansion of
this variable.

Alan Boxall - IBM Distributed Debugger