Just a more general observation about private variable usage: If I am informed correctly in legacy Foxpro it was the norm to bind to variables you scattered and those most often were private variables. By nature of @GET paired with READ commands you were keeping the code stack and therefore all private variables alive and in scope. This is not the case with forms. Whatever you do in Init() or Load() only is on the call stack as long as the form initializes, once all the initialization events happened, and for sure after the call stack returns from the activate event of the form, all private variables generated in Load or Init or Activate are gone again.
If you want something with the same scope as the form, I already gave a lengthy explanation here in another thread this should either be a cursor within the form datasession or a form property. Those two things have the same scope and lifetime as the form, even if the datasession is not private to the form, that just means it lives longer than the form, the form then starts and uses an already existing current datasession, which it leaves open when finishing and releasing itself. So you don't need and you don't use private variables in VFP, they are completely unnecessary.
The way I sometime (perhaps) use them is when AUSED, AFIELDS, or any such array generating function generates an array as private variable, when I didn't previously declared a LOCAL ARRAY variable. There is no way to change that to producing local array variables by default, but the same goes about any variable you forget to declare LOCAL anyway.
To use the good old scatter, VFP9 offers using the NAME clause, you can scatter a dbf record to a form property you first create with Thisform.AddProperty("oRecord", CREATEOBJECT("empty")) and then populate with SCATTER NAME THISFORM.oRecord ADDITIVE which means you finally have THISFORM.oRecord.field1, THISFORM.oRecord.field2, etc. or you create all fields of a table as direct form properties by SCATTER NAME THISFORM ADDITIVE, creating THISFORM.field1, THISFORM.field2, etc., which I consider less clean, as you risk a namespace overlap of field names with any native or also user defined form properties already existing before the SCATTER.
With buffering you don't need to scatter at all, though, so the major way to bind forms to data is by making use of datasession workareas, no matter if cursor, DBF, updatable view, anything else I forgot. As long as it's not READONLY, this is a two way binding of controls. Scatter is handy, if you really want some such record object to be able to pass it from form to form even across several datasessions and such objects (based on "empty") can also be passed to COM OLEClasses to languages not aware of VFPs workarea concept at all. So the legacy "revival" of scatter allows to use modern concepts like linq with collections of objects. Develop a collection class maintaining a "dataset" as a collection of "table" objects each being a collection of such a record objects and you imitate a .NET dataset, if you want. This is an optional way of going in a direction you obviously want to avoid stepping into, but you can't avoid the nature of VFP differing from legacy FoxPro in regard of callstack behavior of forms vs screens. This change of the event model behind windows forms you inherit in VFP from the Windows OS is one of the least seen changes when converting your mindset from legacy screens to forms.
I see it as a big advantage to only need the single central READ EVENTS command to read all events. Events are delegated to whatever object they are related to by windows norms of windows messagees and events and thus make it much easier than needing to take that responsibility of when and where to go into a READ state. Your reaction to a value edit is within control.Interactivechange(), for example, or the final control.Valid() event when before the user changes to another control so you don't program your code reacting to input somewhere after a READ command, you have your dedicated events for that reactions.
Bye, Olaf.