General Announcements

Contents: Latest Announcements, Previous Announcements.

This page contains news and announcements relating to the ETAC system and the website. Dates are in the form DMY.

Latest Announcements

New Data Control Diagram Document (14/02/2025)
A new innovative schematic diagram system for representing software now available.
The following document contains a new innovation for representing software, especially computer application programs, as schematic diagrams specifically designed for that purpose. The diagrams are called “data control diagrams” (DCD). A data control diagram can be used to design, maintain, and enhance any computer program. A DCD is not a software tool, but it can succinctly represent a complex program as a diagram, reducing the amount of design and maintenance errors. See Data Control Diagram Samples for some images of DCDs. View or download the PDF file DataControlModel.pdf for the full definition of a data control diagram.
ETAC Graphics System Now Pre-released (01/11/2024)
The interactive graphics system for ETAC has now been pre-released.
The pre-release version is a beta version of the actual future production release version 4-0-6-ena of the ETAC interpreter, but does not contain the formal documentation nor contain AppETAC.dll. Instead, it contains a tutorial package, consisting of 14 tutorials on the graphics system features, with user-interactive executable coding examples written in (the pre-release) ETAC. It also contains the source files of demonstration programs for a basic calculator and a flowchart diagram maker. Other example programs are also included in the tutorial package. Full documentation will be included in the production release version in 2025. See the Pre-release ETAC page for more information on the pre-release ETAC.
ETAC Graphics System Pre-releasing Soon (18/08/2024)
The interactive graphics system for ETAC is soon to be pre-released.
A pre-release version of the graphics system is expected to be made before the end of 2024. The pre-release version is a beta version of the actual future release version 4-0-6-ena of the ETAC interpreter, but will not contain the formal documentation nor contain AppETAC.dll. Instead, it will contain a user-interactive tutorial on the features of the graphics system written in (the pre-release) ETAC. It will also contain the source files of demonstration programs for a basic calculator and a flowchart diagram maker. Other example programs will also be included. Full documentation will be included in the production release version in 2025.
ETAC Graphics Work Nearing Completion (01/12/2023)
The interactive graphics system for ETAC is nearing completion.
The graphics system is currently being tested and refined. The testing involves creating some graphics application and test programs (these in themselves take significant time to create). Formal documentation of the system still needs to be done. The first-stage release is now expected to commence sometime in the year 2024.
ETAC Graphics Work in Development (25/10/2022)
Work is being completed for a fully featured interactive graphics system for ETAC.
The C++ code for an earlier unreleased graphics system is being adapted and enhanced for use with the ETAC system. The graphics system will be incorporated into AppETAC.dll, and perhaps RunETAC.exe or a new ETAC interpreter (to be decided). The graphics system, called VIS, is entirely originally designed (no third-party software is used or required), and is expected to be released in stages beginning sometime in the year 2023.

The following details present a (very) short conceptual overview of the current intention for VIS. VIS is a major work, and will be far more comprehensive than is indicated in Details.

Details

VIS (Visual Interaction System) is a system that involves user visual interactions with computer software, and can be used to create fully-fledged graphics computer programs via the ETAC programming language. Besides creating windows (VIEWs) and their associated features, like menus and control bars, VIS can create 2D vector graphics objects (using a Cartesian coordinate system) that the user can interact with, without the application programmer writing ETAC code in some cases. Optionally automatic features of VIS include mouse zooming (with zoom limits), mouse and key scrolling (with optional scroll bars), multiple graphics object mouse click and drag selection and highlighting, multiple graphics object resizing, multiple graphics object dragging. Graphics object drawing to a VIEW (Visual Interactive ETAC Window) is automatic; there is no programmer coding to actually draw a graphics object.

VIS allows an ETAC programmer to create a graphics application program by constructing the program via predefined (by VIS) components forming a tree structure. There are components for projects, drawing planes (the “canvas” for which graphics objects are defined), VIEWs, graphics objects and sub-objects, graphics items (includes poly-lines, poly-curves, text, RTF text, and bitmap images, which all belong to graphics objects), graphics contexts, pen attributes, brush attributes, bitmap attributes, text style attributes, menus, status bars, control bars, data packs, and more. The top-level components are projects, and all other components form a hierarchy under, and belong to, a project component. There could be more than one project component in an application program. A project component represents all the information that might be saved in a file for later loading.

Each component under a project is identified by a unique numerical identifier (generated internally by VIS) and a corresponding unique text identifier (created by the application program or automatically by VIS). The text identifier allows users to identify displayed components, such as graphics objects, for interaction with VIS. Components can contain variables allocated by the programmer for their own use, since components are ETAC named data objects.

VIS owns the components and maintains them where required. Therefore, the components are not accessed by (or stored in) variables, but accessed by their unique identification (either by name or by number). Any component created under a project component can access any other component under that same project (and, indirectly, any component of another project) at any time and place in the program while the project component is current.

To an ETAC application program, VIS is a set of ETAC API functions, most of which create and set up the components of the application program as configured by the application programmer. However, VIS does not have direct drawing functions; the application program defines what to draw, but not how to draw. Therefore, a drawing that appears on a VIEW is described via graphics components, and VIS takes care of rendering the drawing onto a VIEW (VIS can do that because it “owns” and has access to the components) as described by the application programmer.

VIS can be used to create any window application program entirely in the ETAC programming language, however, bitmap image manipulation and 3D vector graphics will not be initially supported. An ETAC application programmer will be able to develop application programs that create and manipulate interactive technical diagrams, educational material, documentary material, fancy GUIs, and more. Be aware that VIS will provide only the basic building blocks (components) for such applications; the application programmer will need to configure the components and implement some of their user interaction features.

Hello World Example

The following ETAC code uses default settings to create a VIEW (window) displaying the text “Hello World!” as a graphics object in the centre.

[* Simple Hello World program using graphics with default settings. *]

[* Use the default project. *]
vis_Project(?)
{
   [* Create a drawing plane (canvas) for the text to be drawn on. *]
   vis_DPlane("")
   {
      [* Create a VIEW (window) to display the text defined in the drawing plane. *]
      vis_VIEW("") {};

      [* Create a graphics object on the drawing plane to be displayed. *]
      vis_GObject("")
      {
         [* Create a graphics text item for the graphics object. *]
         vis_TextItem("") {@tiText := "Hello World!";};
      };
   };
};

void vis_WaitForEvents(?); [* Process user input (clicking the close button on the VIEW will end the program). *]

Each vis_XXX() defines the creation of a component containing many member variables (eg: @tiText, @tsItalic, @vTitle, @vStyle, @dpSetMseHitFnt) for setting the display and other features of a component. For example, to create an italic “Hello World!” three times the default height in “Times New Roman”, vis_TextItem("") {...}, above, would be replaced with vis_TextItem("") {vis_TextStyle("My Text Style") {@tsHeight := 3.0; @tsItalic := true; @tsFaceName := "Times New Roman"}; @tiText := "Hello World!";};. Later, anywhere within the current project (typically within user event handler code), the programmer can change the text foreground colour to red by: VIS("My Text Style").{void @tsRepColr(@tsColr := :#RGB_Red:);};.

The following code creates a line item component to draw a thin rectangle snugly around the “Hello World!” text. Both the text and line item components belong to the graphics object component which can easily be set up by the programmer to be selectable by the user (not shown here).

[* Hello world program displayed within its bounding box rectangle. *]

vis_Project(?)
{
   vis_DPlane("")
   {
      vis_VIEW("") {};

      vis_GObject("")
      {
         vis_TextItem("MyText") {@tiText := "Hello World!";};

         [* Create graphics line item for the graphics object. *]
         vis_LineItem("")
         {
            liBBox :- VIS("MyText").@tiGetBoundBox(); [* Get and assign the bounding box [minX, minY, maxX, maxY] for the displayed text. *]

            @liFlags := :!GLI_OUTLINED_SHAPE:; [* The rectangle is to be outlined but not filled in. *]

            [* Set the 5 points [minX, minY, maxX, minY, maxX, maxY, minX, maxY, minX, minY] for the poly-line of the rectangle. *]
            @liPoints := [liBBox%[1], liBBox%[2], liBBox%[3], liBBox%[2], liBBox%[3], liBBox%[4], liBBox%[1], liBBox%[4], liBBox%[1], liBBox%[2]];
         };
      };
   };
};

void vis_WaitForEvents(?);

Note that there are no drawing commands; the drawing is rendered automatically by VIS according to the specifications (@tiText, @liFlags, and @liPoints) set by the programmer.

VIS will be released as part of the ETAC interpreter, but additional ETAC script libraries will also be released for implementing ETAC programs efficiently. The script libraries will include functions for forming and manipulating Bezier and B-spline paths, and functions for basic geometric shape creation and manipulation. Other helper functions will also be included.

Previous Announcements

The ETAC System Converted to Unicode® (01/08/2020)
The ETAC programming language and ETAC package is now Unicode compatible.
The conversion to Unicode allows ETAC program source files to be written in Unicode (UTF-8, UTF-16, UTF-32) as well as in the existing Windows-1252 code page (other code pages are not supported). Also, text files are processed as Unicode text via new commands. Variable identifiers remain restricted to ISO Latin-1 (ISO-8859-1) alphanumeric characters. ETAC text strings are Unicode strings with some new options for string matching and parsing. ETAC has basic support for the full Unicode codespace (U+0000 to U+10FFFF). However, the support is only up to the Unicode scalar value level; character strings are not normalised. ETAC supports only strict conformance to the UTF-8, UTF-16, and UTF-32 encoding schemes; unpaired surrogate code points are not supported. For certain functionalities or parts thereof, only UCS-2 (BMP Unicode scalar value) characters are supported. The Unicode version of the ETAC system is released in ETAC_Installers_3-ena.zip. The self-contained executable ETAC Code Generator program (ETACCodeGen.exe in ETACCodeGenEXE_Installer_2-ena.zip) is also Unicode compatible.
The Functions ETAC Script Library Released (01/08/2020)
The ETAC source code of the Functions ETAC script library is now available with documentation.
The Functions ETAC script library (Functions Library) is a general purpose ETAC script library containing 60 ETAC functions defined in ETAC text script, and is distributed with the ETAC system (ETAC_Installers_3-ena.zip). The Functions Library is implemented in etacFunctions.etac (within ETACSource_3-ena_Installer.exe of ETAC_Installers_3-ena.zip). For details of the Functions Library see the document FunctionsETACScriptLib.pdf.
Conversion of ETAC to Unicode® (26/10/2019)
Work is commencing on converting the ETAC programming language and ETAC package to Unicode.
The conversion to Unicode will allow ETAC program source files to be written in Unicode (UTF-8, UTF-16, UTF-32) as well as in the existing Windows-1252 code page (other code pages will not be supported). Also, text files will be processed as Unicode text via new commands. Variable identifiers will be restricted to ISO Latin-1 (ISO-8859-1) alphanumeric characters as is currently. ETAC text strings will be Unicode with some new options for string matching and parsing. The ETAC implementation of Unicode will be restricted to plane 0, the Basic Multilingual Plane (BMP). Surrogate pairs will be treated as such, and processed by the operating system not ETAC. The self-contained executable ETAC Code Generator program will also be converted to Unicode.
Production Version of ETAC Re-released (21/02/2019)
The first production version of the ETAC programming language and ETAC package is re-released to the public.
The production (“stable”) version of ETAC has been re-released, and includes a new ETAC Code Generator utility. The programs in this release have been amended to be compatible with operating systems later than Windows XP without needing to set the compatibility mode under “Properties” of the executable files. The functionality of the programs in this release is identical to the previous release 01/02/2019. The version numbers have not changed. If the first release (01/02/2019) has already been downloaded and installed, this release can be downloaded and reinstalled after removing the Windows XP compatibility mode from the executable files in the existing installation. The two files re-released are: ETAC_Installers_2-ena.zip and ETACCodeGenEXE_Installer_1-ena.zip.
Production Version of ETAC Released (01/02/2019)
The first production version of the ETAC programming language and ETAC package is released to the public.
The production (“stable”) version of ETAC has been released, and includes a new ETAC Code Generator utility.
Website Updated (01/02/2019)
The ETAC web site has been updated to include a Products page.
The Products page contains substantial products that use the ETAC programming language.
New ETAC Code Generator Utility Program (01/02/2019)
A new ETAC utility program, ETAC Code Generator, is now included in the latest release of the ETAC system.
The ETAC Code Generator uses programmable template text files containing special descriptive codes and text to generate and update the desired text files. The ETAC Code Generator is ideally suited to generate source code for computer programs, but is completely universal. It is therefore able to generate any text file from templates. This is a substantial ETAC program. The ETAC Code Generator is also released as a stand-alone executable program. See ETAC Code Generator for details.
ETAC Script Libraries to be Completed (15/05/2018)
Documentation for a few ETAC script libraries needs to be completed before being formally released.
Three ETAC script libraries (etacFunctions.etac, CreateDlgRes.etac, and MemLook.etac) have been informally released in the form of ETAC binary code. These libraries are required by other released utilities. When the documentation for the libraries is completed, the ETAC source code for the three libraries will be formally released.
ETAC Graphics Work to be Completed (15/05/2018)
Work is being completed for a fully featured interact graphics system for ETAC.
The C++ code for an earlier unreleased graphics system needs to be adapted and enhanced for use with the ETAC system. The graphics system will be incorporated into AppETAC.dll. This work will also include making ETAC Unicode compatible.
External TAC Library to be Done (15/05/2018)
Work needs to be done to create an external TAC library for file and memory access.
This work is intended for the future to allow ETAC code to access file and memory data in a more comprehensive way than is available through the standard TAC library.