xsharp.eu

The ADD OBJECT clause is fundamental to the definition of complex objects in non-visual code and may have nothing to do with UI. You can find a few examples of extensive use of this in VFPX.

I guess the easiest way to create such a diagram is to simply instantiate every class and query its ParentClass and BaseClass properties.

Class: Textbox ParentClass: Textbox BaseClass: Textbox 
Class: Container ParentClass: Container BaseClass: Container 
Class: Form ParentClass: Form BaseClass: Form 
Class: Grid ParentClass: Grid BaseClass: Grid 
Class: Page ParentClass: Page BaseClass: Page
Class: Column ParentClass: Column BaseClass: Column
Class: Checkbox ParentClass: Checkbox BaseClass: Checkbox
Class: Collection ParentClass: Collection BaseClass: Collection
Class: Editbox ParentClass: Editbox BaseClass: Editbox
Class: Control ParentClass: Control BaseClass: Control
Class: Custom ParentClass: Custom BaseClass: Custom

oClasses = CreateObject("Collection")

oClasses.Add('Textbox')
oClasses.Add('Container')
oClasses.Add('Form')
oClasses.Add('Grid')
oClasses.Add('Page')
oClasses.Add('Column')
oClasses.Add('Checkbox')
oClasses.Add('Collection')
oClasses.Add('Editbox')
oClasses.Add('Control')

oClasses.Add('Custom') 
oClasses.Add('Empty') &&Causes error accessing the .Class property

For Each cClass in oClasses
	
	oObject = CreateObject(cClass)
	? "Class: " + cClass + "   ParentClass: " + oObject.Class + "   BaseClass: " + oObject.BaseClass

EndFor

As you can see, there is nothing exciting here... There is no magic low-level common base class underneath them all.

2) The FoxPro class syntax speaks of "Properties" and not of "Fields" or "Instance variables"

Code: Select all

DEFINE CLASS ClassName1 AS ParentClass 
   [[PROTECTED | HIDDEN] PropertyName1, PropertyName2 ...]
   [[.]Object.]PropertyName = eExpression ...]

What would you expect that happens when this is compiled to .Net. Should PropertyName1 etc. become a 'real property' (with a getter and setter) or should they be compiled into a Field.
The problem with compiling it to a field is that we sometimes see a syntax like this:

Code: Select all

DEFINE CLASS Animal as custom
Species    = "Animal"
ENDDEFINE

DEFINE CLASS Dog AS Animal
Species    = "Dog"
ENDDEFINE

If we compile "Species" to a field then the Dog class will try to redefine the field in the parent class.
Our compiler will then produce the warning:

Code: Select all

warning XS0108: 'Dog.Species' hides inherited member 'Animal.Species'. Use the new keyword if hiding was intended.

From what I have seen FoxPro declares everything as "real" properties and somehow stores name/value pairs in an invisible collection inside each object and both Species in the Animal class and in the Dog class read/write from the same collection. So all these properties are virtual as well
So my current thinking is to generate .Net properties from this and make these virtual so they can be overwritten in a child class. We can also add a collection, but we can also create a backing field. In case of a property that overrides a parent property we can change the getter and setter and redirect the call to the parent property.
But that would mean that you can't create fields with the current FoxPro syntax.
I see a couple of solutions:
a) with a special compiler option you can tell the compiler to generate fields or properties. When you generate fields you will get a warning when you redefine a field in subclass
b) we always generate properties but add a special syntax to declare fields, something like

Code: Select all

DEFINE CLASS ClassName1 AS ParentClass 
   [[PROTECTED | HIDDEN] FIELD Field1, Field2 ...]
   FIELD FieldName = eExpression ...]

Btw: our current definition allows you to specify the types for Fields/Properties:

Code: Select all

[[PROTECTED | HIDDEN] PropertyName1, PropertyName2 ...] [AS DataType]

clear
=test(.f.)
=test(.t.)

? "Does not look unreasonable..."
clear ALL
release All
? "And Now for Something Completely Different"
? "Proof: Wolf reads prototype Mammal, Poodle reads prototype Dog"
=test(.t.)

FUNCTION test(tlFlag)
local laClassNames[1], lcClasses, lnCnt, lnRun
lcClasses = "mammal,canine,wolf,dog,poodle"
lnCnt = alines(laClassNames, m.lcClasses,5,",")
for lnRun = 1 to m.lnCnt
	= choir(laClassNames[IIF(m.tlFlag, m.lnRun, m.lnCnt+1-m.lnRun)])
next

FUNCTION choir(tcClass)
local loSinger, lcSound
loSinger = CREATEOBJECT(m.tcClass)
lcSound =loSinger.bark()
wait window m.lcSound timeout 2
? m.lcSound

define CLASS mammal as Custom
	cSound = "meeep"
	nProto = SECONDS()
	nInitM = 0

	FUNCTION Init()
		this.nInitM = SECONDS()
		
	FUNCTION bark()
		return STR(this.nProto, 12,3) ;
		+ STR(this.nInitM, 12,3) ;
		+ " : " + this.Class

ENDDEFINE

define CLASS canine as mammal
	cSound = "wuff"
ENDDEFINE

define CLASS wolf as canine 
	cSound = "hoooowl"
enddefine

define CLASS dog as canine 
	nProto = SECONDS()
enddefine

define CLASS poodle as dog
	cSound = "wack"
enddefine

3) All methods inside FoxPro seem to be virtual. This was also the case for Visual Objects. We have a compiler option that does this automatically.

4) The ADD OBJECT syntax creates a property (field?) and sets the value of the property to a new object of the specified type and allows to set initial values for some properties of this new object. What is not clear to me is if this object is also automatically added to a collection of children (controls) in the class ?

5) Now that we move FoxPro to .Net we will also be able add new functionality. So far we have added the following (for free because it is there in our compiler already)
- The ability to declare attributes on a type, property method etc
- The ability to add more (visibility) modifiers then just PROTECTED and HIDDEN. For example also INTERNAL,ABSTRACT, STATIC and SEALED
- The ability to define Generic types and methods

Code: Select all

DEFINE CLASS MyStack<T> WHERE T IS NEW()

- All types can be specified in the Namespace.Type syntax. For example

Code: Select all

CLASS MyTable as System.Data.DataTable

CLASS MyFirstXSharpForm INHERIT Form 
  CONSTRUCTOR()
    SUPER()
    Size := Size{100, 100} // Check if it is not dimension, out of top of my head
    Text := "My first XSharp Form"
    VAR btn := Button{}
    btn:Text := "Close"
    btn:Location := Point{5,5}
    btn:Click := MyButtonClick  // what the click event will fire
    SELF:Controls:Add(btn)
  RETURN
  METHOD MyButtonClick(o AS OBJECT, e AS EventArgs) AS VOID
    SELF:Close()
  RETURN
END CLASS