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

[sutton@xxxxxxxxxx]

We considered this before but then the user has to have 2 views open to see
all the variables, and has to keep switching back and forth between them.
We could put all the variables (global and local) in a separate view, but
then we have to explain to the users that they should be using some other
view than the variables view to see the value of the variables.  Plus users
will be stepping in and out of Java code from their code and it would be
confusing having to use one view when on a Java stack frame and another
view when on one of their stack frames.

Bruce Sutton



                                                                                                              
                    Darin_Wright@xxxxxxx                                                                      
                    Sent by:                         To:     platform-debug-dev@xxxxxxxxxxx                   
                    platform-debug-dev-admin@e       cc:                                                      
                    clipse.org                       Subject:     Re: [platform-debug-dev] Behaviour of       
                                                      variable expansion                                      
                                                                                                              
                    04/02/2002 12:24 PM                                                                       
                    Please respond to                                                                         
                    platform-debug-dev                                                                        
                                                                                                              
                                                                                                              




Another suggestion/question I have is whether the use of a "watch list"
would work. Currently, the expression view and expression support
(IExpressionManger, IExpression) could be used to create a "watch item".
The interesting variable(s) can be placed in the expression view and their
expanded state will remain the same for the duration of the debug session.

Darin


                                                                           
   sutton@xxxxxxxxxx                                                       
   Sent by:                             To:                                
   platform-debug-dev-admin@ecl platform-debug-dev@xxxxxxxxxxx             
   ipse.org                             cc:                                
                                        Subject:        Re:                
                                [platform-debug-dev] Behaviour of variable 
   04/01/2002 03:15 PM          expansion                                  
   Please respond to                                                       
   platform-debug-dev                                                      
                                                                           




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

_______________________________________________
platform-debug-dev mailing list
platform-debug-dev@xxxxxxxxxxx
http://dev.eclipse.org/mailman/listinfo/platform-debug-dev