

  << dx0 >>                                                   --> v1.0 for PHP 


  DX0 is true, cross-browser DHTML delivered by PHP.  The acronym DX0 originates
  from this concept: [D]ynamic HTML [X]ross-Browser with Zer[0] Unused Code.

  DX0 is not just an incredible DHTML library for PHP, but it sniffs the browser
  on the server-side and delivers specific code for the user's browser and 
  version.  Think about how useful that is to your users.  Netscape users won't
  have to download code with Internet Explorer functionality that won't ever be
  used.  And vice versa.

  All you need to run DX0 is a working installation of PHP on your web server.
  This file is merely a set of includes that you may use on your pages to
  generate browser-specific DHTML.  Thank you for downloading it.  You have
  earned 60 points.

  whytheluckystiff@mailcity.com 
     [ http://deathstar.eng.utah.edu/~kroford/dx0 // dox and updates ]
 
  Come Join the DX0 mailing list :: http://www.egroups.com/groups/dx0 :: Now is
  a great time to join, since DX0 is being ported to Python and new objects will
  be added weekly.  Provide your input and learn how to make it all work better.

  / INTRO / 
  In Q2 of 2000, Intel.com was redesigned and featured some quasi-trasparent 
  menus I'd been working on.  At the same time, I was working on making the
  page compatible with M14 of Mozilla.  I'd been focusing on DHTML for a year
  and a half and come to a few conclusions:

    1. The page was going to gracefully degrade to 3.0 and below.  I wanted it
       to look nice in Lynx.

    2. I wasn't going to use LAYERS any more.  ILAYERS are unescapable, but
       I could do without having to write LAYER code just to support NS4,
       when NS6 won't recognize the tag.

    3. I was under a restriction of 70k (including graphics).  That meant the
       page needed to sit at about 24k (including any attached JS files). 
  
    4. The page had to be flexible with font sizes.  Margins might be
       different.  Everything should be placed relatively.

    5. The code had to be abstracted away so that updates to news items
       and such would be simple.

  These were the core issues and I'm sure that any DHTML developer faces them.
  With Intel.com I faced a particular problem with trying to lower my code
  size in accordance with their need for a DHTML country selector.  My
  designer thought the list box was ugly and he wanted to use a DHTML list
  box I had created for WebOutfitter.  That code was bulky though, and
  required extra mouse handler functions and style sheets and stuff.  I
  ended up sacrifing some degree of good practice to get the code down in size.

  This is why I believe PHP is well suited to assist with DHTML.  A short
  while later I started working on a site for my friend's software 930shell.
  I had been playing with advanced windowing and he wanted to use it on the
  site.  He had PHP installed, so I built a basic include file and a
  PHP-generated include file that would do the work.  The result
  has been incredibly satisfying.  The site for 930shell and this software is
  at http://930.bored.org.

  Many people have used DHTML APIs by Dan Steinman or by Goodman (the JS
  Apostle) or by Eric Krock, etc.  I really like what all these gentlemen
  have done, but I've always found the libraries to have holes.  An obvious
  hole is the new Mozilla browser.  I've seen few pages work yet.  I know
  the Mozilla team is now adding innerHTML and some other Generation Five
  functions, but I don't think it'll quite bridge the gap.

  The point is:  This library works right now and it's tiny.

  
  / ABOUT THIS RELEASE /
  This release is pre-1.0.  It is not the full package.  It is just the core
  classes, along with an example (dx0window.inc) of a module class.  Many
  additional classes have been finished.  Before any of those classes are
  released (in 1.0), this core must be debugged in Mozilla.  You can help by
  trying out the example pages in your browsers or by even trying to make a
  few pages yourself.  As you make pages, think about what could be more
  usable about the whole library.  That would really touch my heart.  Once I
  can prove that there is enough success in the major stable browser versions,
  then I'll release 1.0 with the additional classes I have finished. 

  Much thanks to Sergio and alf on the list for their testing and excellent
  comments.  Thanks to the incredible number of people who mail we to say
  thanks, since it helps me continue working on the project.

  I am also getting DX0 ready for admission to PEAR when it opens up.  Some
  PEAR guidelines may be too strict for my taste, though.  I don't think it's
  necessary to name variables exactly according to PEAR standards (especially
  when DX0 has already been in use -- I wouldn't want to be responsible for
  any more pages breaking!)  Let me know what you think.

 
  / IMPLEMENTATION /
  This library has two primary parts:

    1. dx0basic.php3, the php-generated js file.
    2. dx0.inc, the class files and definitions.

  It's really small, huh?  It's perfectly minimalistic.  I don't envision
  this core will change.  I definitely plan on adding objects on, but that's
  just not as essential as the core.

  These two files also rely on a third file, though.  dx0vars.inc stores
  your setup options and should be the only file you may have to touch if
  you need to tweak things.

  The core is implemented by requiring dx0.inc at the top of each of your
  documents like this:

  <? require 'dx0.inc'; ?>

  I also like to use the $GLOBALS[DX0_BROWSER_IDENT] at the top of the page. 
  That way I can debug if the page is coming out wrong in different browsers. 
  You can use it in your comments just to be eccentric:

  <!-- This page specifically made for <? echo $GLOBALS[DX0_BROWSER_IDENT]; ?>
       -->

  Another useful global is DX0_DHTML.  If you want certain parts of your page
  to go out only to DHTML browsers, then:

  <? if ($GLOBALS[DX0_DHTML]) {  ?>
  This text is only viewable by DHTML-capable browsers.
  <? } else { ?>
  This is for non-DHTML browsers.
  <? } ?>

  Currently, DX0 supports the following DHTML browsers:
    Netscape 4.x, Netscape 6 Preview 1 (Win32, Linux, Mac)
    Mozilla M14, M15, Current Builds
    IE4.x, IE5.x 
      (Win32, Some incompatibility with IE4 for Mac, Neoplanet included)

    Other browsers like Opera, NetPositive, and iBrowse have yet to be included,
    but easily can be if they allow DHTML elements.  Also, because Mozilla is
    still in development, you can expect frequent patches as further stable
    builds are released.
 
  Both parts of this library core have distinct purposes:
    1. The dx0.inc gives you the ability to generate your initial page without
       ever having to sniff the browser yourself.
       If you want to write a DHTML "layer" (I call them "elements" in this
       document), then you can use:
       <? $dx0test = new dx0absElement("dx0Test", array("x" => 0, "y" => 5)); ?> 

    2. The dx0basic.php gives your JavaScript full access to all of your
       elements after the initial creation.
       If you wanted the dx0Test element to move two pixels down:
       <SCRIPT LANGUAGE="JavaScript">
       dx0Test.moveBy(0, 2);
       </SCRIPT>

  This should give you an idea of how powerful this library is.  Not only does
  it have the power of an abstracted library like the DynAPI or CBDHTML.js, but
  it's got the power of PHP to generate flawless js files and shrunken code.

  There are a few tricks to learning this library and I hope you will send me
  any problems, so that I can help perfect the library.  The best way you can
  support it is by input.  I try to get on EFNET IRC every once in a while
  at #codesmokers.  

  As you're playing with these files and trying to get them to work, make sure
  you name them appropriate to your server.  On my server I keep all my php
  files name .php.  On your server you may need to change them to .php3 or
  whatever is set in srm.conf.

  Also, if you are changing the extensions, you must change a global variable
  in dx0vars.inc.  DX0_PHP_EXTENSION must be set to the extension you'll be
  changing dx0child.php to.


  /  The DX0 PHP Classes /
  There are two core DX0 classes.  You saw dx0absElement above.  There is also
  dx0relElement.

  These classes must be declared in your <HEAD> tags, before the <BODY> tags.
  It's a good practice to get into for this library.  If DX0 has to make style
  sheets or JavaScript, you'll want it to be up there. 

  dx0absElement (name, [properties])
  -----------------------------------------------------------------------------
  Creates an absolutely-positioned element.  It's coordinates are relative to
  (0,0) in the client window.  The only required parameter is "name".  I have
  found that creating empty, generic layers can be very useful, so I
  have made the other parameters optional.
  Parameters :
    1. name: the unique identifier of the object.
       This name also becomes the name of the object you will reference 
       inside of JavaScript.  The name of the element itself in the HTML
       BODY is name+"ID".  Unique names are very important, that's why I have
       added dx0 to the front of every class, function, and variable.  It's not
       hungarian notation, it's to keep you safe from overlapping this library
       with other functions and libraries.

       TIP:  It's ideal to name your PHP object the same as your JavaScript
       object.  Most module libraries will do this anyway.
       ex.: $dx0testObj = new dx0absElement("dx0testObj", $props);

    2. properties: an array of properties for your object.
       An array is used so that properties like "opacity" can be filtered
       out for browsers that don't support.

  dx0relElement (name, [properties])
  -----------------------------------------------------------------------------
  Creates a relatively-positioned element.  It's coordinates are relative to
  the position in which it is placed (using dx0relElementName.place())
  Parameters: see dx0absElement above.

  Why are absolutely- and relatively-positioned elements declared differently?
  Why don't I just let you use the "position:" attribute?  Because I feel the
  best way to accomplish things cross-browser is by using the <DIV> tag for all
  absolute elements and the <ILAYER> and <DIV> tags for relative.  They just
  work out like that.  You need to keep in mind with relative elements that
  in Netscape 4.0 you can't do JavaScript images swapping within them.  There
  is an NS4.x bug that can't find document.layerName.document.images.  You can
  find document.layerName.document.links, but not .images.  Please remember:
  No rollovers in relative elements until Netscape 4.x goes away. 

  Properties for the above elements are as follows:
    "left" or "x"	X-coordinate for left edge
    "top" or "y"	Y-coordinate for top edge
    "width"		Width of element
    "height"		Height of element 
    "clip"		Array of clip coordinates (x0, y0, x1, y1)
                        (i.e. "clip" => array(12, 24, 14, 26)) 
    "z-index" or "z"	Z-coordinate for element surface
    "backImage"		Background image url (works in NS and IE)
    "bgcolor"		Background color triplet or name
    "visibility"	Whether "visible" or "hidden"
    "opacity"		A percentage of transparency can be assigned (0 to 100)	
    Other attributes are not cross-browser and are not listed here.  DX0 will
    write all undefined attributes to the style sheets, but will not add them
    to Netscape layers.  So other attributes like "border" can be used with
    results in IE and Mozilla.  Consult the CSS specs for further information.

  Special, secret properties:
    "liquidX"		Gives the element a "liquid" coordinate relative to
    "liquidY"		the bottom-right corner of the window.  The element
			is repositioned each time the browser is resized.

  Once you have a dx0absElement or dx0relElement instantiated, you can begin
  to make it work.  In the <HEAD> tags: 

    <? dx0prep(); ?>

  This function will create any style sheets.  If you have INLINE_STYLES turned
  on in the dx0vars.inc, then you won't need to run this.  I like it off and
  have seen better results in Netscape.  If you do turn on INLINE_STYLES, then
  turn on LAYER_SUPPORT also please.

  Next, you may begin to place your elements on the page:

    <? echo $dx0test->place('<CODE>THIS PAGE IS USING DX0</CODE>'); ?>

  Or you can leave the parameter blank:

    <? echo $dx0test->place(); ?>

  You will want to do this between your body tags.  For relative elements, you
  should place() them in the natural flow of the page-- where you want it to
  appear.  Absolutely-placed elements don't matter, but I would definitely
  keep them out of tables.

  One thing I like to do to with elements that have a lot of data inside is
  this:

  <?
  echo $dx0test->place('

    <CODE>
    THIS PAGE RUNS ON <A CLASS="dx0h1" HREF="http://930.bored.org">DX0 v'
      .$GLOBALS[DX0_VERSION_NUMBER].'</A>   
    <BR>
    <IMG SRC="i/this.is.dx0.jpg" WIDTH="141" HEIGHT="12">
    </CODE>

  ');
  ?>

  That way your PHP will make more sense.  I guess.  What you should also know
  is that elements can still be embedded inside of other elements.  Take this
  for example:

  <? echo $dx0window->place(
      $dx0titlebar->place('<IMG SRC="i/titlebar.jpg">')
        .'<BR>'.$dx0content->place('<CODE>Window contents here.</CODE>'));

  Or you can use the openTag() and closeTag() functions, if it seems cleaner
  to you:

  <? echo $dx0element1->openTag(); ?>
  <SPAN CLASS="text1">Inside dx0element1</SPAN><BR>
  <? echo $dx0element2->openTag(); ?>
  <SPAN CLASS="text2">Inside dx0element2</SPAN><BR>
  <? echo $dx0element2->closeTag();
     echo $dx0element1->closeTag(); ?>

  DX0 automatically sets up for you the parent-child relationships with these
  embedded elements. Normally you would have to go out of your way to handle
  events in these various elements, but DX0 takes care of it.  At least it
  seems to be working so far...
  
  After your elements are all set, there is one final function that adds all
  the functionality for using the page after it has loaded.

  At the bottom of the page you will want to add the php-generated script file.
  Like this:

  <? dx0basic(); ?>

  This function will only put the <SCRIPT> tags in if the browser is DHTML-
  capable.  So the js file won't be loaded unneccesarily by Netscape 3, which
  is nice.  This function also writes JavaScript mouse handler code and load
  code and specific setup for your page.  The js file usually ends up at 3k
  and the extra JavaScript turns out to be about 4k. 

  The dx0setup() function is also written, which basically just attaches the
  mouse handler functions and turns your elements into real javascript
  objects that will work with the js file.  You don't have to completely
  understand just yet.  

  If you are a complicated JavaScripter, then you should know that I attach
  the dx0setup() function to the window.onload.  So if you are planning to run
  several functions onload, then you should turn off the DX0_AUTO_ONLOAD in
  dx0vars.inc and load dx0setup() javascript yourself.

  If you want some of your own functions to be run onload, use this function:

  <? dx0registerFx("onload", "initializeMyStuff();"); ?>

  This also works for onResize:

  <? dx0registerFx("onresize", "alert('Quit Resizing Your Browser!');"); ?>

  So, here's our basic DX0-flavored DHTML template:

    <? // DX0 DHTML Template
       require 'dx0.inc';
    ?>
    <HTML>
    <HEAD>
    <TITLE>DX0 Template</TITLE>
    <? $templateFloater = new dx0absElement("templateFloater", array("top" => 10, "left" => 10));
       $templateInliner = new dx0relElement("templateInliner");
       dx0prep();
    ?> 
    </HEAD>
    <BODY BGCOLOR="#FFFFFF">
    <? echo $templateFloater->place('<CODE>Floating here in dx0.</CODE>'); ?>

    <TABLE BORDER="0" CELLSPACING="0" CELLPADDING="0">
    <TR>
      <TD><FONT FACE="Arial,Helvetica" SIZE="2">Welcome to dx0.  Press the
          button below for more.</FONT><BR>
          <? echo $templateInliner->place('<A HREF="nextPage.html"><IMG
          SRC="i/button.next.jpg"></A>'); ?>
      </TD>
    </TR>
    </TABLE>

    <? dx0basic(); ?>
    </BODY>
    </HTML>

  Makes sense?  Seems pretty simple?  Good.  You've got down how to use dx0.inc
  and now we'll begin to really see the usefulness of dx0basic.php, which gives
  us all the functions we need.

   
  / The DX0 JS File /
  The JavaScript API that has been assembled for this project is contained in
  the dx0basic.php file.  This API is incredibly useful and (with your help)
  I hope to keep it updated so that those who come to learn it will be able
  to enjoy the benefits of DHTML without the enormous quantity of
  late nights I spent finding out browser issues.  When I worked on Intel.com,
  I was equipped with a lab of about twenty computers running different
  platforms and browser versions.  I became familiar with the idiosyncracies
  of the Macintosh, Windows NT, Window 9x and Linux browsers that
  are most frequently used.

  To begin with, the following functions become immediately available upon
  load of the page (assuming DX0 has done it's job running dx0setup):

    dx0elementName.show();
    dx0elementName.hide();
    dx0elementName.moveBy(x,y);
    dx0elementName.moveTo(x,y);
    dx0elementName.moveXTo(y);
    dx0elementName.moveYTo(y);  
    dx0elementName.clip(x0,y0,x1,y1);
    dx0elementName.getLeft();
    dx0elementName.getTop();
    dx0elementName.getWidth();
    dx0elementName.geHeight();
    dx0elementName.write(innerHTML);

    optionally, you can also load these functions:
    dx0elementName.load(url);
    dx0elementName.slideReset();
    dx0elementName.slide(speedX, speedY);

  Most of these functions should be self-explanatory.  If not, I hope you will
  be patient as I expand this documentation in the coming months.  I assembled
  this library in a day, because I'd like to see it become useful immediately
  to those who may use it.  In the meantime, be patient, it will
  grow and I will nail down some dox.

  The one function I would like to explain, though, is the load() function. 
  I have this function optional, because I don't see people using it on every
  page.  If you want to use it on a certain page, then you can do it by
  replacing this:

    <? dx0basic(); ?>
 
  with this:

    <? dx0basic("LOAD_ON"); ?>

  at the bottom of your pages.  I envision that a useful part of DX0 will be
  the ability to turn off sections of the js file.  I would appreciate any
  comments.

  The load variable is very cool, because it allows you to load files from an
  external HTML file into your page.  These pages must be formatted a specific
  way in order to work, though.

  If you have created the instance called "dx0test" and you want to be able to
  load the document called "simple.html" into it, then your page would look
  something like this:

  <? require 'dx0.inc'; ?>
  <HEAD>
  <TITLE>dx0test loading...</TITLE>
  <? $dx0test = new dx0absElement("dx0test");
     dx0prep(); ?>
  <BODY>
  <? echo $dx0test->place("Empty..."); ?>

  <SCRIPT LANGUAGE="JavaScript">
  <!--
    // now we want to load in something new when the link is clicked.. 
    function loadSimple() {
      dx0test.load("simple.html");
    }
  // -->
  </SCRIPT>
 
  <A HREF="javascript:loadSimple()">Click here to load simple.html</A><BR>
  <? dx0basic("LOAD_ON"); ?>

  </BODY>
  </HTML> 

  Simple.html will look something like this:

  <HTML><HEAD>
  <TITLE>simple.html</TITLE></HEAD>
  <BODY onLoad="parent.dx0childBorn()">
  Hello, to load simple2.html <A HREF="javascript:dx0text.load('simple2.html');">click here</A><BR>
  </BODY>
  </HTML>

  The essential part is that onLoad.  Make sure the child has that
  parent.dx0childBorn().  DX0 will take care of how to put it in each browser. 
  Also, DX0 will let you queue up a bunch of loads and it will just load them
  from off of it's stack.

  Cool, huh?  It works using an IFRAME.  So make sure you put the
  <? dx0basic("LOAD_ON"); ?> in your body tags.  That's the function that will
  create the IFRAME and get everything ready.

  Also remember that after the HTML is loaded, it no longer needs to call
  javascript in your parent document by using "parent." because after it is
  born, it is a part of the parent.  In the example above the anchor tag can
  call dx0text.load with no problem.

  I have also included a file called 'dx0child.php' which is a template for
  these child documents.  I find it useful if I want to load in a document that 
  the browser may not let me.  For instance, most browsers have a problem
  loading content into the layer that isn't from the host on which the page is.
  If I were to try to load 'http://www.enlightenment.org' into a layer using the
  conventional means, I would be bitterly rejected.  But if I load it
  with dx0child.php, it works.  Like so:

  <? dx0test.load("dx0child.php?src=www.enlightenment.org"); ?>

  dx0child.php will try to write the base href tag and the onLoad tag in
  so images will not be broken and the page will load correctly.

  Be careful with this dx0child.php document.  You may be tempted to modify it
  so it can load local files.  You musn't do that.  

  Now for the slide() function.  One thing that people were always asking me
  to do at Dahlin, Smith and White (see dsw.com) was to do sliding menus and
  crap.  Like how the dropdown box on Intel.com came down like a curtain from
  thin air.  This is such a common function that I wanted to write a generic
  one that could be used in any situation.  The slideReset() function will
  reset your element so that it is ready to slide.

  The slide() function will slide the element out if it is in or it will slide
  the element in if it is out.  It's a toggle.  If obj.slideFlag is -1, then
  the element is out.  If obj.slideFlag is 1, then it is in.

  The slide() function takes two parameters, speedX and speedY.  These numbers
  determine how fast you want the element to slide and in what direction.  It
  should make sense how these numbers work.  Positive numbers will cause the
  slider to appear in a positive direction and to disappear in a negative
  direction.  The higher the numbers, the faster. 

  If you would like to see an example, see ex.slide.php in this distribution.
  Try changing the numbers in slide() and see the effect.

  In conjunction with this, I have added a ps property for objects.  If you
  want to run a function after the object is done sliding, you may load ps
  with the value and it will be run after the action is done.  You may use
  obj.ps to store functions and obj.runPs() to run them.

  
  / MOUSE HANDLING /
  Other than the typical functions of moving and hiding and clipping, I think
  it's important for a good API to have good mouse handler functions.
  Mouse handling has been one of my debugging nightmares.  Here's a few
  reasons why:

    * If mouseDowns or mouseUps aren't returned false, then they will
       leave you with the hourglass and halted javascript.

    * IE4+, NS4.x, and NS6 all handle the mouse differently.
 
    * In IE 4.x for Mac the mouseUp handler will often fire BEFORE the
       mouseDown!  This is nonsense.

  DX0 automatically stores all mouse movement in two global JavaScript
  variables: dx0m_x, dx0m_y.  If you are worried about this slowing your
  page down, then you can disable it with the $DX0_MOUSE_XY in dx0vars.inc.

  If you want to attach a mouse function to a specific layer, then you
  can do it like this (before the dx0prep() function):

  <? $dx0test->addMouseFunction("dragEle"); ?>

  <SCRIPT LANGUAGE="JavaScript">
  <!--

    function dragEle(eleX, eleY, eleAction) {
      if (eleAction == "UP") stopDragging(dx0Active);
      else if (eleAction == "DOWN") startDragging(dx0Active, eleX, eleY); 
      else if (eleAction == "MOVE") moveDragging(dx0Active, eleX, eleY);
    }

    // define stopDragging, startDragging, moveDragging ...

       ...

  // -->
  </SCRIPT>

  So, how this works is once you give the name of the function to the object,
  DX0 will try to send that function three parameters every time a mouse event
  is triggered: the x-coordinate, the y-coordinate, and the action.  Possible
  actions are "OVER", "DOWN", "MOVE", "UP", and "OUT".  The name of layer on
  which the mouse was triggered is stored in the 'dx0Active' variable.  That's
  all on that for now.


  / DX0 FILES /

  Instead of having to use PHP syntax at all, you may alternatively install the
  parser included with this release to create DX0 files, which will allow you
  to bring DX0's power to an even simpler level.  To install the parser, there
  are a few steps.

  First, your Apache installation must have mod_rewrite installed.  This module
  allows the file to be read through the parser before it is sent on to the
  client.
 
  Second, you must place a .htaccess file at your web directory root.  One of
  the machines I use for development uses the ~username method of redirecting
  user web requests.  In otherwords, the url http://www.host.com/~username
  will actually map to /home/user/public_html on the host.  I place .htaccess
  in that directory and it affects all directories beneath it.  Here is what
   your .htaccess file should look like:

    RewriteEngine On
    RewriteRule ^(.*)\.dx0$ /~username/.parser.php3

  Naturally, you will need to change the path of parser.  The parser included is
  named parser.php3, but it is wise to place it in your root directory named
  .parser.php3 so it isn't erased accidentally.

  Lastly, the parser should work now that everything is in place.  You may need
  to modify parser.php3 to read your files correctly.  On the development
  server I mentioned earlier, I had to have the parser do a search and replace
  on "~username" and replace it with "home/username/public_html".  I have left
  that code inside, commented out for your possible use.

  Using DX0 files is very simple once you are set up.  Tags resemble normal
  HTML tags.  To create an absolutely positioned element:

  <dx0absElement ID="floatingObject" TOP="30" LEFT="30">
    Floating text here
  </dx0absElement>

  The parser is not case-sensitive, nor does it require quotes.  The class name
  of the object you are placing merely becomes the tag.  Objects distributed
  with DX0 which meet the basic class structure will fit in just fine.  Hence,
  the dx0windowCore class described below can be instantiated in a DX0 file with
  this:

  <dx0windowCore ID="floatingWindow" TITLE="Window That Floats"
     TOP="20" LEFT="100">
       This window uses DX0 tags to create itself.
  </dx0windowCore>

  If these classes are stored in include files, you must use a dx0include tag to
  load the file before the contents are parsed.  At the beginning of the file:

  <dx0include file="dx0window.inc">

  This file format is a step toward developing a more dynamic DX0 that
  will be easier to write.


  / ADDING DHTML OBJECTS /
  I'd like to see this library attain a set of DHTML objects that are reusable.
  The dropdown list box was always needed for my work on Intel.com and though
  the implementations were often different, only slight modifications were
  ever necessary.  Anticipate DHTML objects to be stored in their own include
  files and to not extend from existing classes, though contain many instances
  of them.

  I have created an example of this type of object in 'dx0window.inc'.  


  / IMPORTANT CONCLUSION /
  Yeah, so, that's it.


