README
======

Twm4Nx is a port of twm, Tab Window Manager (or Tom's Window Manager)
version 1.0.10 to NuttX NX windows server.  No, a port is not the right
word.  It is a re-design of TWM from the inside out to work with the NuttX
NX server.  The name Twm4Nx reflects this legacy.  But Twm4Nx is more a
homage to TWM than a port of TWM.

The original TWM was based on X11 which provides a rich set of features.
TWM provided titlebars, shaped windows, several forms of icon management,
user-defined macro functions, click-to-type and pointer-driven keyboard
focus, graphic contexts, and user-specified key and pointer button bindings,
etc.

Twm4Nx, on the other hand is based on the NuttX NX server which provides
comparatively minimal support.  Additional drawing support comes from
the NuttX NxWidgets library (which necessitated the change to C++).

Twm4Nx is greatly stripped down and targeted on small embedded systems
with minimal resources.  For example, no assumption is made about the
availability of a file system; no .twmrc file is used.  Bitmaps are not
used (other than for fonts).

The TWM license is, I believe compatible with the BSD license used by NuttX.
The origin TWM license required notice of copyrights within each file and
a full copy of the original license which you can find in the COPYING file.
within this directory.

STATUS
======

Progress:
  2019-04-28:  This port was brutal.  Much TWM logic was removed because it
    depended on X11 features (or just because I could not understand how to
    use it).  The replacement logic is only mostly in place but more
    needs to be done to have a complete system (hence, it is marked
    EXPERIMENTAL).  The kinds of things that need to done are:

    1. Right click should bring up a window list (like the icon manager???)
    2. For TWM-like behavior, a window frame and toolbar should be highlighted
       when the window has focus.
    3. A right click on the toolbar should bring up a window-specific menu.
  2019-05-02:  Some testing progress.  The system comes up, connects to and
    initializes the VNC window.  For some reason, the VNC client breaks the
    connection.  The server is no longer connected so Twm4Nx constipates and
    and eventually hangs.
  2019-05-08:  I abandoned the VNC interface and found that things are much
    better using a direct, hardware framebuffer.  The background comes up
    properly and the Icon Manager appears properly in the upper right hand
    corner.  The Icon Manager Window can be iconified or de-iconified.
    The Icon Manager window can be grabbed by the toolbar title and moved
    about on the window (the movement is not very smooth on the particular
    hardware that I am working with).
  2019-05-10:  A left click on the background brings up the main menu.  At
    present there are only two options:  "Desktop" which will iconify all
    windows and "Twm4Nx Icon Manager" which will de-iconify and/or raise
    the Icon Manager window to the top of the hierarchy.  That latter option
    is only meaningful when the desktop is very crowded.
  2019-05-13:  Added the NxTerm application.  If enabled via
    CONFIG_TWM4XN_NXTERM, there will now be a "NuttShell" entry in the Main
    Menu.  When pressed, this will bring up an NSH session in a Twm4Nx
    window.
  2019-05-14:  We can now move an icon on the desktop.  Includes logic to
    avoid collisions with other icons and with the background image.  That
    later is an issue.  The background image image widget needs to be
    removed; it can occlude a desktop icon.  We need to paint the image
    directly on the background without the use of a widget.
  2019-05-15:  Resizing now seems to work correctly in Twm4Nx.
  2019-05-20:  Calibration screen is now in place.
  2019-05-21:  A "CONTEMPORARY" theme was added.  Still has a few glitches.
  2019-06-01:  A retro, emulated segment LCD clock is now in place.

How To:

  Icon Manager
    - At start up, only the Icon Manager window is shown.  The Icon Manager
      is a TWM alternative to more common desktop icons.  Currently Twm4Nx
      supports both desktop icons and the Icon Manager.

      Whenever a new application is started from the Main Menu, its name
      shows up in the Icon Manager.  Selecting the name will either de-
      iconify the window, or just raise it to the top of the display.

  Main Menu:
    - A touch/click at any open location on the background (except the
      image at the center or on another icon) will bring up the Main Menu.
      Options:

      o Desktop.  Iconify all windows and show the desktop
      o Twm4Nx Icom Manager.  De-iconify and/or raise the Icon Manager to
        the top of the display.
      o Calibration.  Perform touchscreen re-calibration.
      o Clock.  Start and instance of clock in the window.  The uses the
        the retro, LCD emulation of apps/graphics/slcd.
      o NuttShell.  Start and instance of NSH running in an NxTerm.

    - All windows close after the terminal menu option is selected.

  Window Toolbar
    - Most windows have a toolbar at the top.  It is optional but used
      in most windows.
    - The toolbar contains window title and from zero to 4 buttons:

      o Right side:  A menu button may be presented.  The menu button
        is not used by anything in the current implementation and is
        always suppressed
      o Left side:  The far left is (1)the terminate button (if present).
        If present, it will close window when selected.  Not all windows can
        be closed.  You can't close the Icon Manager or menu windows, for
        example.  Then (2) a resize button.  If presented and is selected,
        then the resize sequence described below it started.  This may
        the be preceded by a minimize button that iconifies the window.

  Moving a Window:
    - Grab the title in the toolbar and move the window to the desired
      position.

  Resizing a Window:
    - A window must have the green resize button with the square or it
      cannot be resized.
    - Press resize button.  A small window should pop-up in the upper
      left hand corner showing the current window size.
    - Touch anywhere in window (not the toolbar) and slide your finger.
      The resize window will show the new size but there will be no other
      update to the display.  It is thought that continuous size updates
      would overwhelm lower end MCUs.  Movements support include:

      o Move toward the right increases the width of the window
      o Move toward the left decreases the width of the window
      o Move toward the bottom increases the height of the window
      o Move toward the top decreases the height of the Window
      o Other moves will affect both the height and width of the window.

    - NOTE:  While resizing, non-critical events from all other windows
      are ignored.

  Themes
    - There are two themes support by the configuration system:
      o CONFIG_TWM4NX_CLASSIC.  Strong bordered windows with dark primary
        colors.  Reminiscent of Windows 98.
      o CONFIG_TWM4NX_CONTEMPORARY.  Border-less windows in pastel shades
        for a more contemporary look.

Issues:

    2019-05-16:
      Twm4Nx is in a very complete state but only at perhaps "alpha" in its
      maturity.  You should expect to see some undocumented problems.  If
      you see such problems and can describe a sequence to actions to
      reproduce the problem, let me know and I will try to resolve the
      problems.

    Here are all known issues and features that are missing:

    TWM Compatibilities Issues:
    1. Resizing works a little differently in Twm4Nx.
    2. Right click should bring up a window list
    3. For TWM-like behavior, a window frame and toolbar should be highlighted
       when the window has focus.
    4. A right click on the toolbar should bring up a window-specific menu.

    There are no near-term plans to address these compatibility issues.

    Other issues/bugs.  All-in-all, I would say that Twm4Nx is maturing well
    and is attaining stability.  That being said, there are some issues and
    untested functionality that should be addressed:

    1. Icon drag movement includes logic to avoid collisions with other
       icons and with the background image.  That later is an issue.  We
       need to paint the image directly on the background without the
       use of a widget.
    2. There are a few color artifacts in the toolbar of the CONTEMPORARY
       theme.  These look like borders are being drawn around the toolbar
       widgets (even though the are configured to be borderless).
    3. Most Twm4Nx configuration settings are hard-coded in *_config.hxx header
       files.  These all need to be brought out and made accessible via Kconfig
       files
    4. I have seen some odd behavior when many NxTerm windows have been
       opened (around 15).  Specifically, I see failures to start NSH in the
       windows so they come up blank.  All other behaviors seem normal.  Most
       likely, some NxTerm resource allocation is failing silently and leaving
       things in an unusable state.  The board I am using has 128Mb of SDRAM
       so I can't believe that memory is the limiting factor.  These are,
       however, RAM-backed windows and will use significant amounts of memory.
       The primary issue is that the number of windows should probably be
       managed in some way to assure that the end-user does not experience
       odd behaviors when resource usage is high.
    5. Menus with sub-menus have not been verified.  There is no use of sub-
       menus in the current code base so I expect that there are issues when,
       for example, and item from a sub-menu item:  That menu and all of its
       antecedent menus should be closed.
    6. There is an optional MENU button that may appear at the far left on
       the toolbar.  It is not used by any window in the current code base
       and, hence, is unverified.  I would expect some issues with generating
       and routing the MENU button events to applications.  There are likely
       other unverified features.
    7. X/Y input may be either via a touchscreen or a mouse.  Only
       touchscreen input has been verified.  There is, however, very little
       difference.  The primary issue is in cursor support:  Cursors are
       needed with a mouse.  Cursor images also change depending on the
       state (like grabbing and dragging or resizing).  There is also a
       possibility of using auto-raise with a mouse as well.  All of this
       logic is in place, but none has been verified.
    8. NxTerm windows really need to be scrollable.  They are difficult to
       use with only a few lines on a small display.  A related usability
       issue is the font height:  The fonts report a maximum font height
       that results in a large line spacing on the display and, hence,
       fewer lines visible in the small window.  This is latter issues is
       a problem with the fonts not Twm4Nx, however.
    9. There is a trivial rounding error in the calculation of the LCD
       width in SLcd::CSLcd::getWidth().  It currently truncates down.
       It needs to round up.  This sometimes leaves a small, one-pixel-
       wide sliver on the clock display.  This display always recovers and
       this only cosmetic.

Adding Twm4Nx Applications
==========================

  Application Factories and the Main Menu
  ---------------------------------------
  The original TWM supported a .twmrc in which you could describe application
  programs supported on the desktop.  Currently no such start-up file is
  available for Twm4Nx.  Rather, all applications must be added via run-time
  interfaces.  And overview of these interfaces is provided in this
  paragraph.

  Currently, there are only two applications developed for Twm4Nx:  (1) An
  NxTerm hosting NSH that is analogous to an XTerm hosting the Bash shell
  in a Unix environment, and (2) a touchscreen calibration application.
  Let's focus instead on the NxTerm application as an example because the
  touchscreen calibration is a rather unusual beast.

  These example applications can be found at: apps/graphics/twm4nx/apps and
  apps/include/graphics/twm4nx/apps

  In short, adding an application involves a "Factory Object" that is
  hooked into the Main Menu.  A Factory Object is an object that is used
  to create other object instances.  The way in which the Factory Object
  is represented is purely a decision of the application developer.  One
  option, however, is to use the pure virtual base class IApplicationFactory
  as defined in apps/include/graphics/twm4nx/iapplication.hxx.  This base
  class provides only a single method:

    bool initialize(FAR CTwm4Nx *twm4nx);

  where CTwm4Nx is the Twm4NX session instance that allows the class
  implementation to interact with session specific resources.  Multiple
  sessions would be required, for example, if the platform supported
  multiple displays.

  In practice, the application factory implementation class inherits from
  the following base classes:

    1. IApplicationFactory.  Provides the common initialize() method.
    2. IApplication.  Provides the information for the application's entry
       in the Main Menu
    3. CTwm4NxEvent.  Hooks the application factory into the Twm4Nx event
       notification system.

  Initialization consists of instantiating the application factory instance
  and calling its IApplicationFactory::initialize() method.  The application
  factory instance is a singleton that must persist for the life of the
  session.  For the NxTerm application factory, this is done in
  apps/graphics/twm4nx/src/twm4nx_main.c like:

    CNxTermFactory nxtermFactory;
    success = nxtermFactory.initialize(twm4nx);

  In addition to general initialization, the IApplicationFactory::initialize()
  method must register a new entry with the main menu.  You can see an
  example of this in apps/graphics/twm4nx/apps/cnxterm.c:

    FAR CMainMenu *cmain = twm4nx->getMainMenu();
    return cmain->addApplication(this);

  The argument to the CMainMenu::addApplication() method is of type
  IApplication *.  Remember, however, that our application implementation
  class inherited from IApplication.

  The IApplication pure virtual base class is also defined in
  apps/include/graphics/twm4nx/iapplication.hxx.  It essentially describes
  what the Main Menu logic should do when the menu item is selected.  It
  includes these methods:

    1. getName().  Provides the name string that will be shown in the
       Main Menu for this selection.
    2. getSubMenu().  One possibility is that selecting the Main Menu item
       is that it may bring up yet another sub-menu of options.
    3. getEventHandler().  Returns an instance of CTwm4NxEvent that is used
       to route menu selection events.  Remember that our application
       factory inherits from CTwm4NxEvent so this function only needs to
       return the 'this' pointer.
    4. getEvent().  Provides the event ID that will be used in the event
       notification.  The returned value must conform to the description
       in apps/include/graphics/twm4nx/twm4nx_events.hxx.  In particular,
       the recipient of the event must be EVENT_RECIPIENT_APP.

   The Twm4Nx application is then started when the application factory's
   CTwm4NxEvent::event() method is called with the specified event.

  Application Windows
  -------------------
  How the application factory starts an application instance is purely up
  to the application designer.  Typically this would include starting a
  new application task.  General characteristics of an application include:

    1. It probably should inherit from CTwm4NxEvent so that it can receive
       events from the system.
    2. To create the window, it must instantiate and initialize an instance
       of CWindow.
    3. It must configure application events to receive notifications from
       Twm4Nx.

  To create an application window, the application must call the
  CWindowFactory::createWindow() method.  For the NxTerm example, this looks
  like:

    NXWidgets::CNxString name("NuttShell");

    uint8_t wflags = (WFLAGS_NO_MENU_BUTTON | WFLAGS_HIDDEN);

    FAR CWindowFactory *factory = m_twm4nx->getWindowFactory();
    m_nxtermWindow = factory->createWindow(name, &CONFIG_TWM4NX_NXTERM_ICON,
                                           (FAR CIconMgr *)0, wflags);

  The window factory is another factory that creates and manages window
  instance.  The createWindow() method requires four parameters:

    1. The name of the window.  This is the name that is show in the window
       toolbar and may be the same name as was used in the Main Menu entry.
    2. A reference to the the Icon image associated with the window.  This
       is the image that is show on the desktop when the window is
       iconified.  It is of type NXWidgets::SRlePaletteBitmap.
    3. A pointer to the Icon Manager instance that this window belongs with.
       This can be NULL to use the default Twm4Nx Icon Manager.
    4. A set of flags that describe properties of the windows.

   The flag values are defined byte WFLAGS_* definitions provided in
   apps/include/graphics/twm4nx/cwindow.hxx:

    1. WFLAGS_NO_MENU_BUTTON     Omit the menu button from the toolbar
    2. WFLAGS_NO_DELETE_BUTTON   Omit the delete button from the toolbar
    3. WFLAGS_NO_RESIZE_BUTTON   Omit the resize button from the toolbar
    4. WFLAGS_NO_MINIMIZE_BUTTON Omit the minimize button from the toolbar
    5. WFLAGS_NO_TOOLBAR         Omit the toolbar altogether
    6. WFLAGS_ICONMGR            This window is an icon manager
    7. WFLAGS_MENU               This window is a menu window
    8. WFLAGS_HIDDEN             Start with the window hidden

  Once the CWindow is instantiated, events needed by the application can
  be configured as is done in the NxTerm application:

    struct SAppEvents events;
    events.eventObj    = (FAR void *)this;
    events.redrawEvent = EVENT_NXTERM_REDRAW;
    events.resizeEvent = EVENT_NXTERM_RESIZE;
    events.mouseEvent  = EVENT_NXTERM_XYINPUT;
    events.kbdEvent    = EVENT_NXTERM_KBDINPUT;
    events.closeEvent  = EVENT_NXTERM_CLOSE;
    events.deleteEvent = EVENT_NXTERM_DELETE;

    bool success = m_nxtermWindow->configureEvents(events);

  Again, recall that the application inherits from CTwm4NxEvent.  So passing
  'this' as the event object above assures that the specific events are
  routed to the application instance.

  Drawing in the application window can be performed using that facilities
  of NXWidgets using the NXWidgets::CGraphicsPort associated with the
  window.  The NxTerm application does not perform any drawing, however;
  that drawing is performed by the NxTerm driver.

  The NXWidgets::CGraphicsPort can be obtained from a CWindow instance,
  say m_window, like:

    FAR NXWidgets::CWidgetControl *control = m_window->getWidgetControl();
    NXWidgets::CGraphicsPort *port = control->getGraphicsPort();

  That CGraphicsPort is then passed to the widget constructor, binding the
  widget to that window and forcing all widget drawing to occur within the
  window.

  Obviously, a lot more could be written about drawing, much more than can
  be addressed in this README file.
