• Changes:
   
  • Working under the visual components library to run applications on the Android is continued.
     
    • The event is implemented: selection_change for the {Combo};
    • The event is implemented: value_change for the {Edit}, {Memo};
    • Text input for the {Paint_lines}, showing blinking caret there;
    • Small changes in low level functions implementations of visual functions (setting font, getting system palette colors,
    • ... and non-visual, too (Application_name, ShiftR).
  • Working under the compiler for the Android and the development environment also is continuing:
     
    • command to automatically launch an uploaded apk was added into an upload_apk.cmd generated by the Project wizard (in the IDE AL4);
• Fixes:
   
  • Small fixed in the AL-IV to Java compiler for the Android;

• Changes:
   

  • Working under the visual components library to run applications on the Android is continued. Painting on the {Canvas} is working now well, with transformations.

  • Layout control provided for visual items on a form in the usual AL-IV visual library style (semi-automatic layout in columns).

  • A panning added for {Paintbox} content (and the {Paintbox} descendants, certainly).

  • For this moment some visual applications can be launched and running on the Android (including Test_paintbox, Test_paint_lines, Test_project). There events implemented: mouse (touch), click, timer and some other.

• Changes:
   

  • Working under the compiler from AL-IV to Java/Android and a visual components library to run the application on Android is continued. For now, main visual components are implemented ({Label}, {Button}, {Checkbox}, {Edit}, {Memo}, {Combobox}, {Progress}, {Date_picker}), and some non-visual ({Bitmap}, {Timer}). Only 'click', 'timer', 'menu_item', 'answer' events are implemented yet. It is possible to show several forms and switch between them via the system menu, modal dialogs also work. Application size (apk) is from 100-110 Kbytes to about 140-190 Kbytes, on test applications. Build time below 5 seconds, time uploading onto phone via USB about 3-5 seconds.

• Changes:
   

  • the compiler from AL-IV to Java is restored/changed and can now generate executable file for the Android (apk of size 192 Kbytes);

  

• Changes:
   
  • The operation ++ / -- is removed totally;
  • A capability added to name entities with more then 2 names, including creating several different groups of names separated by symbols || or \\. The only restriction here is that all the groups should start from the same letter. E.g., T_h|eight || Total_height;
• News:
   
  • Working started under the compiler from the AL-IV to the Android (on base of Java);

• Changes:
   
  • The operation ++ / -- is disabled for fields (of records and objects);
  • The demo application Invaders added (console version, C# only yet);
  • The Interpreter: almost all the visual demo- / test- applications are working now in the interpreter (including the Test_OpenGL);
• Fixes:
   
  • Compiler / C#: initializing of fields of OBJECT structures;
  • Interpreter: initializing DATA[] array fields;
  • Interpreter: a lot of fixes;

• Fixes:
   
  • Delphi/FPC: generating code for a loop by DATA[X TO Y];

• Fixes:
   
  • Compiler: SCENARIO compiling error;

• Changes:
   
  • The demo application Lines added (very similar to well known time killer game Lines - 500 lines of code);
• Fixes:
   
  • Compiler: incorrect working with a constant if an operation -CONST present in an expression;
  • Compiler: incorrect code generated for case when a symbol is assigned to a string which is an item of an array of strings which index is an item of an array (or a field of a record in an array of records);
  • Optimizer / C#: several inline insertions of the same fragment into the same functions was leading to duplication of a temp variable declaration (if the CASE statement was present in the inline portion of code);

• Changes:
   
  • {System_functions}: the function Get_char added;
  • Demo application added "15" (console version, 70 lines of code);
  • Interpreter: the key /$TEST added to run tests;
• Fixes:
   
  • Interpreter: while calling a native function, resulting shadow object did not convert to an interpreted.
  • Interpreter / C#: a lot of fixes.

• Changes:
   
  • Interpreter: running visual applications becomes possible now (except OpenGL).

• Changes:
   
  • Syntax: the requirement added to separate lines of code having continuations from other statements of the same block of code (with empty lines, block comments or symbols of the block end (';') placed in separate lines) - while compiling, warnings are fired in case of insufficient separators;
  • A demo application Miner added: less then 200 lines of code on AL-IV.
     
• Fixes:
   
  • {Long_operation}: ambiguous fires (the activity counter was not reset);
  • Delphi/FPC: working with fixed arrays in OBJECTs;
  • The interpreter / C#: a lot of fixes;
  • IDE AL4: skipping the first mouse click on window activation works as usual  for the caret moving though still does not allow to select with mouse dragging at such case;
  • IDE AL4: the problem fixed with launching one more instance if the IDE when opening a file in the Explorer (the mutex was not creating since some bad characters in its name);
  • Delphi/KOL: {Form}.mouse_double_click could not be called (not initialized local variable stop_handling: Boolean;)
  • Entire code base (probably) checked to satisfy new requirements (separating lines with continuations from others, disallowing standalone ++ / -- statements);

• Fixes:
   
  • Delphi/FPC: working with array ranges based on array ranges (created in result of passing a range of an array as a parameter of a function/method which is accepting a fixed array);
  • Delphi/FPC: working with fixed arrays in RECORDs;

• Fixes:
   
  • Interpreter: ++/-- operation (was implemented as prefix rather then postfix);
  • Delphi: accessing DATA[] in the code compiled;
  • FPC: getting an array size in RTTI native code (there is not enough parenthesis while calling Count function).
     

Results of sorting (Test_projects\Test_sort):
 

• Changes:
   
  • It is disabled to use  ++ / -- operations in standalone statements (like x++);
  • Native methods are disabled (only static functions allows to be NATIVE);
  • The modifier INIT|IALYZE is allowed for fields of OBJECT structures;
  • C#: option /$NOLONGOP works now for C# too (do not add checks of activity on each iteration of all the FOR loops);
  • The interpreter added which can execute the code without compiling it to other languages, but with restrictions (only for C#, support of visual applications is not yet ready);
• Fixes:
   
  • {Random_soft}.Set_seed ;
  • C#: generating operand DATA[] in expressions;

• Changes:
   
  • It is disabled to pass as a parameter-array a "read only" field (except from the class itself, its descendants and friends);
  • It is disabled to pass as a parameter an array which size is based on a enumeration (like A[{colors}] );
  • It is disallowed to pass a RECORD parameter and return a RECORD result to/from a NATIVE function (OBJECT should be used, or passing separate fields or using arrays or smth else if necessary). This is done so also for arrays of RECORD parameters.
  • The priority of the operation IN / !IN made above comparisons, so the expression X IN Y != Z now equals to (X IN Y) != Z;
  • The warning about calling a CALLBACK function not from the class itself now is fired only for non-public functions;
  • The demo Worm was added (about 150 lines of code).
• Fixes:
   
  • For a parameter - fixed array, the flag "read only" was setting;
  • C#, Delphi: generating code for OBJECT in some cases;

• Changes:
   
  • Ambiguous statements ==> are disabled;
  • It is not allowed to use the same field in both sides of an assignment of a new object created (even in casde when objects actually are different);
  • It is allowed to assign a value in a PUSH statement to a READ-only fields which has a SETTER method specified (examples can be found in the class {Font}: Size - Set_size);
  • {Form}.menu callback event method is abandoned (menu_item is enough);
• Fixes:
   
  • C#: code generation for a local (in function) array of objects (OBJECT);

• Changes:
   
  • Delphi/FMX+Android: calling the event closed for the main form when the application is going to the background.
• Fixes:
   
  • C#, Delphi/KOL: compiling visual projects problems still there are a couple of new functions used in Delphi+FMX/VCL to adopt mobile screen etc. (in C#/KOL these functions are just empty but therefore these are necessary to provide compiling);

• Changes:
   
  • Delphi/FMX+Android: supporting applications with several forms including modal dialogs. Swipe is now working for forms too.
  • {Canvas}: the method End_paint was added to provide correct ending of painting on a {Bitmap} object in the Android+FMX (otherwise, the drawing can not be seen).
    
    
    AN ANNOUNCEMENT: for this time I have to stop further working on support of a combination of the Delphi RAD Studio + FMX to compile AL-IV to other platforms. Amount of licenses granted me from the Embarcadero shortened to 1, still the death of one HDD and an impossibility of the RAD Studio to re-install on another machine. And the Embarcadero refused from increasing amount of freeware licenses for me.
• Fixes:
   
  • Delphi/FMX+Android: stable working of {Paintbox} (in the mode direct draw to the canvas of a {Paintbox} control);

• Changes:
   
  • Android/Delphi+FMX: in a visual application forms are supplied with a capability to be swiped to achieve hidden columns (though mouse events are delayed for 0.1 sec until making a decision if the swipe gesture was started);
  • Android/Delphi+FMX: in a visual application form at once only one 'TOP' aligned and one 'BOTTOM' aligned column is visible, others are accessible via vertical swipes (in usual mode). Also, column aligned 'BOTTOM' are handled last placing it below the central ('LEFT'/'CENTER'/'RIGHT' aligned) columns which size is made on base of its content. In the desktop version, 'BOTTOM' columns were handled before the central occupying all the space at the bottom what it was needed to them.
  • Android: in a visual application long tap (mouse down) is recognized as a right mouse click event with a visual feedback (white rectangle in a position of possible pop up menu);
  • Amount of applications which can be compiled and run under Android is increased. E.g. a demo application Calc (compiled for C#, Delphi/FMX, VCL, KOL, Android):
    
• Fixes:
   
  • Optimization: it is disabled to inline functions having side effects (assigning a value to a class field or something like this);

   

• Changes:
   
  • Delpi/FMX ==> ANDROID: In result of great efforts it is became possible to launch some visual projects developed using AL-IV, on devices with the Android OS onboard;
  • Delphi, the {Log_html} class: The method Redirect_console_to_log(BOOL) was added which allows to redirect all the console output to the current log file (Log.html usually);
  • Delphi/FMX+Android: If the {Memo} is created having Alias=="DEBUG", all the console output is redirected to it automatically;

• Fixes:
   
  • Free Pascal: Access Violation exception while running testing part of any project (though it were allowing compiling a project after pressing OK);
  • Delphi: the event mouse_double_click was not compiling (because of changes in code specific only for Delphi RAD Studio + Firemonkey);
  • Delphi/FMX: compiling the class {Dialog_dir};
  • Delphi/FMX: reading UTF-8 text from a stream (at least {Localize_str} was affected);
  • Optimization for case when FOR loop through an array executes one time (by removing FOR loop header);
  • Delphi/FMX: the option /$VISUAL added, which provides delaying of form creation (this guaranties normal working of some controls which must be created after the Application.Run);

• Changes:
   
  • Demo project "100" was added;
  • Class {Rational} was added;
• Fixes:
   
  • OBJECT declaration compiling:
     
    • arrays of strings and records;
  • C#, Delphi&FPC: generating code for sequential CASE containing in conditions references to RECORD variables;
  • Delphi: memory leaks (Ref_obj);

• Changes:
   

  • The capability added to compile code AL-IV into Pascal code in form of Delphi X (RAD Studio, BDS) projects in form of multi-target project on base of the FireMonkey components library (FMX). It is sufficient to add the key /$RAD (the alternative to keys /$KOL and /$FPC). A resulting project can be opened in the Delphi X and (theoretically) built for a desired platform other then Windows32 (Windows 64, iOC, MacOS, Android).

• Fixes:
   
  • Delphi: the field Shared was not declared for a dynamic array of RECORDs (DynARec).

• Changes:
   
  • {Form}: if a component present in a column with property Anchor_bottom=TRUE, it is automatically expanded onto the entire height rest from other controls independently of its order in the column (earlier, it should be the last in column));
  • It is disallowed to insert just constructed object to an array of objects without assigning it first to an intermediate variable;
  • The compiler: after the first error found, there no more warnings out into console;
  Fixes:
   
  • OBJECT declaration compiling:
     
    • incorrect requirement to use short only strings was removed;
    • C#: some problems code generating for an OBJECT objects solved;
  • Delphi: while introducing into compiled code (by the compiler) temp dynamic arrays (Temp_fixed), there were problems with a destruction order: base arrays could be destructed before fixed arrays based on these. Also the flag Shared was not set for fixed objects arrays. In total the result could be sad.

• Fixes:
   
  • FPC/Linux:
     
    • modal dialog was not closing;
    • showing a list of available fonts was leading to crash;
    • BACKSPACE was fired three times on each press;
    • there was a crash on exit when reading properties of an a destroyed form object;

• Fixes:
   
  • FPC/Linux: compiling with the class {Clipboard} (Test_clipboard);
  • FPC/Linux: compiling windowed applications (Text_visual_projects);

• Fixes:
   
  • compiling in Linux fixed (for non-visual projects, there are still problems with linking for visual projects);
  • {Form}: Client_width, Client_height - size in pixels was converting to points incorrectly;
  • IDE: slow speed of appearing of Search/Replace dialog fixed (and resizing improved).

• Changes:
   
  • {Form}: methods added:Client_width, Client_height, Set_client_size;
  • IDE: the Replace dialog improved: buttons Replace / Next are united, check boxes added "In current function only" and "Any part of word";
• Fixes:
   
  • {Form}.menu_item was not calling;
  • The capability to compile projects with the compiler made by the Delphi32.

• Changes:
   
  • {Form}: the method menu_item added (without parameters) which is preferable to override it to handle menu on form. The method menu(A|ction) was redeclared as 'DEPRECATED' and actually just calls new method menu assigning first its parameter value to the sender_alias field. (This change allows in scenario to wait menu item click by the WAIT operator just after popup_menu call, without interrupting the algorithm).
• Fixes:
   
  • Delphi/KOL: compiling code with dynamic arrays;

• Changes:
   
  • Another kind of a method added - SCENARIO, and also a block statement
    WAIT [event]: ... ;
    or
    WAIT ?
[event1]: ...
[event2]: ...
... ; , and statements GOTO scenario_name / CALL scenario_name. These new constructions allows to focus entire logic of a certain process flow in a single place rather then to diffuse it onto several event handlers.

• Fixes:
   
  • C#: replacing a reference to an object in an array of objects - amount of references on the object were counting incorrectly and it could be disposed (in result, the application used NONE-version of the object);

• Changes:
   
  • Data type OBJECT added (which works like CLASS, but declared internally in classes, and has no its own methods and can not be inherited);

• Changes:
   
  • It is allowed in a record constructor to omit parenthesis in case when there are no assignments to its fields, e.g.:
    {rect} r|ectangle_temp = {rect}
  • IDE Editor: and option "Shadow copy" added to copy all the saved files onto a shadow disk specified;
  • IDE Designer: quick jump by CTRL+CLICK on a form designer scheme was implemented to lines of code containing a reference to the control "Alias"; and by double click to the first appropriate event handling overridden method (like click, paint, value_changed etc.) where the control's alias is referenced (to that line, too);
• Fixes:
   
  • IDE, Form Designer: restoring state of properties Filter, Default_ext for the {Dialog_file};
  • {Paint_tabs}: incorrect control of right side minimal fit position (when amount and size of all the tabs make the content wider then the window size);

• Changes:
   
  • {Paint_tabs}: Select_tab moves the selected tab into a view;
  • IDE AL4: popup menu on tabs contains a list of all opened tabs to quick jump to it;
• Fixes:
   
  • Delphi: code generating for case of statements ==> nesting in PUSH statements;
  • Local variable which are fixed arrays with size specified by a enumeration type are implemented;

• Changes:
   
  • {Font}: fields Face, Size, Style[...] became available for immediate assignment (including assignment in statements PUSH), correspondent setters like Set_face, Set_size, Set_style are declared with the modifier DEPRECATED;
  • IDE AL4: popup menu on bottom field allows quick to jump to sections ---------'name' in current source;
• Fixes:
   
  • C#: a problem fixed with drawing reflected vertically/horizontally {Bitmap} (when a target rectangle has negative width or/and height);
  • Delphi: generating code for case of function exit by a statement ==> out from a PUSH block;
  • IDE, Form designer: restoring the Alias value for an {Edit} which is "read only" from a form constructor method (CONSTRUCT);
  • /$INCREMENTAL compiling: problems with recompiling classes having operation enum IN enums[], enums[] << enum;

• Changes:
   
  • Method was added: {Form}.Set_colors(Fore, Back);
• Fixes:
   
  • FPC: code generate;
  • /$INCREMENTAL: loose of correspondence of enumeration type when a class was recompiled containing a reference to it;
  • Delphi: {Bitmap}.Load (fields Width and Height did not change after loading);
  • C#: {Bitmap}.Draw - did drawn with incorrect scale when scale should be 1:1; speed up drawing in such case and all integer bounds of the destination rectangle;
  • A check added on assignment a value to a loop variable for case of a loop based not on an array (in such cases it is not allowed to modify a loop variable in the loop body);
  • Common compiling problems are fixed (sourced by an attempt to change compiling algorithms to separate compiling of separate modules from each others - though not successful);
  • Delphi code generation for an empty fixed bytes array;

• Changes:
   
  • C#: /$INCREMENTAL compiling supported though without dynamic code reload for already running application (therefore still only changed classes are recompiled, building of entire project made faster several times);
  • C#: speed up building by adding the key -warn:0 eliminating all the warning messages from the CSC compiler;
• Fixes:
   
  • IDE, Form designer: code to write control having composite name (can_hide[] << name/name2);
  • C#, {Form}, hidden: while handling the "hidden" event controls could change its order in the parent list of controls, in result its visual order could change (since C# controls stored in a list of children of a parent control can be changed arbitrary);

• Changes:
   
  • Embedded functions added to work with enumerations: Next, Prev|ious, First, Last;
  • Implementation of the class {Random_soft} changed: the Seed now is stored as a record of two integers, still C# does not allow to convert double (REAL) value to a long integer (Int64) except loosing some digits from the mantissa.
• Fixes:
   
  • Optimization V2 was deleting incorrectly in increment statement following the assignment to the same variable;
  • Delphi: generating code for dynamic arrays of REAL values;

• Changes:
   
  • A capability added to set as a range if a FOR statement an enumeration type:
    FOR e IN {some_enum} : body ;
    FOR e IN {Some_class}.{some_enum} : body ;
  • It is allowed to apply embedded function Int to a enumeration type expression;
• Fixes:
   
  • Delphi/DPC: Dynamic array of RECORDS: memory was allocated but not cleared for a dummy record in an  array, in result floating point errors were possible when an item was used out of bounds of an array;
  • Delphi/VCLIncremental compiling: RECORD type in assignments became incompatible after recompiling classes using imported RECORDs;
  • Delphi/FPC: generating code for fields which are declared as fixed arrays - size of a fixed array did not set;
  • Delphi: generating a code to nullify a field of a record which is a (fixed) array (e.g. in a handler of TooDeepRecursionException);
  • C#: {Paintbox}, {Form}.paint: before calling the "paint" event, all the transformations are reset on Canvas;
  • Delphi: generating code for a FOR loop for some cases of partial range of indexes:
    FOR s IN A[x TO y]: ...
  • Incremental compiling (Delphi/VCL): if the working directory was changed (e.g. after calling {Dialog_file}.Select_file), changed DLL with a recompiled class could not be found and loaded;
  • IDE AL4, Form designer: generating code for {Dialog_file}, when Save_dialog is TRUE;
  • Using qualified constants from another class ({Class}.SOME_CONSTANT);

• Changes:
   
  • If an object created is assigned to a local variable, and added (by the >> operation) to a local array, and the local variable (at the left side) has no 'TEMP' in its name, this is treated as an error (rules did not change, just followed more exactly in such case);
  • The class {Random_soft} added (the same as {Random} but provides exactly same sequences for the same initial Seed value independently on target platform and destination language);
• Fixes:
   
  • Recognizing very large REAL constantgs in code (greater then maximum possible INT);
  • C#, Delphi/FPC: generating very large REAL constans (".0" is adding to prevent the compiler accounting it as an integer number);
  • Delphi/FPC: generating code for fields which are declared as fixed arrays (with an enumeration type as a range of indexes like
    X[{enum1}]), for types INT, BOOL, BYTE;

• Fixes:
   
  • IDE AL4, Form Designer: drawing of columns aligned 'RIGHT';
  • It was not possible to add just created object to an array (operation >>) which is declared read only (with the modifier 'READ');
  • Optimization: setter for .[] operator was removing;

• Changes:
   
  • Tools\Web_maket - only files really changed in comparison with existing content are overridden on disk;
• Fixes:
   
  • C#: code generation for complex enough expressions in from-to parts of a range (requiring allocating temp variables for intermediate calculations);
  • Optimization: R2 (removing unused native functions was adding to used some additional unused functions/methods).

• Changes:
   
  • The demo-application Complex calculator was extended (operations added with polynomials and triangle solve);
• Fixes:
   
  • {Matrix}, {Cmatrix}: Clone (NRows <-> NColumns was disordered in parameters, affecting polynomials / vectors though did not affect square matrices);
  • IDE: Menu Editor could not correctly create a "Custom" value item;

• Changes:
   
  • Classes {Cvector} and {Cmatrix} are added (similar to correspondent {Vector} and {Matrix} classes but work under numbers of type {complex} rather then REAL);
  • The demo-application Complex calculator was extended (operations added with matrices and vectors under complex numbers);
  • If there are both same named function and variable/field in the scope, the function is more priority only in case when the next symbol is '(' in the source;
• Fixes:
   
  • Delphi: generating code in an embedded exception handler in case when a result should be returned which is a RECORD;
  • Delphi/VCL: after hiding some columns and then restoring its visibility, some columns could be disordered in comparison with the initial state;
  • More accurate functions removing while code optimizations;
  • Optimizations: while in-lining a function with parameters, infix operations could be lost for a parameter (-, ~, --, ++);
  • Delphi/VCL: {Form}.Mouse_cur

• Changes:
   
  • In FOR loop on an array, it is now allowed in square brackets to specify a range of indexes, including a case when indexes are decreasing (DOWNTO):
    FOR m IN M[x TO y] : ... ;
    FOR m IN M[y DOWNTO x] : ... ;
  • It is allowed to use in functions/methods local variables with names matching to names of fields of a class (warning is shown but only in case of methods);
  • Delphi/FPC: an option /$REAL=Extended added, if used then the compiler uses Extended real numbers instead of Double;
  • The demo-application added: Complex calculator (engineer type, working with complex numbers, about 60 operations, journal of operations executed, localization, about 1000 lines of code);
    
    (the screenshot made with 4 instances of the CCalc, built by C#, Delphi/VCL, Delphi/KOL and Free Pascal).
• Fixes:
   
  • Optimization on removing unreachable code was erroneously removing the ending statement ==> in nested blocks;
  • The optimization removed all the operators did not accounting them;
  • In the LIKE statement with EXCEPTions an error was occur when the tailing block was excluded;
  • Free pascal, {Form}: visual order of columns aligned to 'LEFT'/'RIGHT'/'TOP'/'BOTTOM' was opposite;
  • Delphi/VCL, {Form}: visual order of columns aligned to 'TOP' was opposite;
  • {Complex}.Csin;
  • IDE:
     
    • Setting width for a column aligned 'LEFT'/'RIGHT';
    • Form Designer: restoring name and size of a font for a control;
    • Form Designer: an {Edit} control did not read with the option "read only" when a form was opening;

• Changes:
   
  • IMPORT statements should not more placed in TEST functions, instead the modifier TEST added for usual TEST statements at the start of class;
  • For functions containing a single assignment of an expressions to  the RESULT, it is allowed to omit the keyword RESULT in such single statement:
    FUN av|erage_of_A_B(
    REAL A|_parameter, REAL B|_parameter) ==> REAL
        := (A + B) / 2 .
  • Rules to form an operator body became identical for all other functions (including the case of a single assignment to the RESULT). And, an operator can have a usual sequence of statements.
  • For operators, it is allowed to use the qualifier NEW.
  • For functions having a single statement, the requirement to place symbol ':' of the function header in a separate line became not mandatory.
  • It is possible now to specify a method .[parameters] in a class (having empty name noted by the dot in a header), which parameters are written in square brackets. If a setter method is defined for the .[]-method, then such method can be used at the left side of an assignment (calling the SETTER in these cases) (but it is allowed only the "=" statement, and combined statements like "+=", "-=" etc. are not possible in such cases).
  • Classes {Vector} and {Matrix} are added implementing so named mathematical objects.
• Fixes:
   
  • C#: fixed arrays on base of byte arrays are fixed (and so, loading an icon from file was fixed too, see test application Test_visual_projects\Test_TrayIcon).

• Changes:
   
  • It is now possible to redefine operators +, -, *, / (and also "-" unary operation) - for classes and records:
    • OPERATOR {type} + {type} ==> {type}: expression.
      OPERATOR - {type} ==> {type}: expression.
    • The modifier OPERATORS({Class_1}, ...) for a function (or an operator) using operators, which specifies the order in which classes are listed while looking for an appropriate operator;
    • The mandatory modifier OPERATORS for a class redefining operators;
    • Operators can be overloaded by input arguments types.
  • The class {Complex} added to demonstrate redefining operators.

• Changes:
   
  • The class {Thread} added. The principal of full isolation of address spaces of different threads from each others is implemented: after sending objects to the slave thread by the Take method, the sending thread loose them totally until it is handled there and send back (either by yield method or automatically after the last hard reference to it disappears);
  • The class {Slice} added which allows to cut a starting part of an array to pass it to another threads in an object shell (the part of the source dynamic array is excluded temporary, shifting indexes of the rest part of the dynamic array. It is allowed to cut several {Slice} fragments sequentially from the same array (e.g. for sorting purposes). It is possible to cut any type arrays except arrays of RECORDs.
  • Warning about DEPRECATED function is now appear only in case of a call of it (except from functions which are DEPRECATED themselves);
  • Warning about DEPRECATED class now contains the name of a class importing the problematic class;
  • IDE: a capability added to make a reference in comments onto a diagram (.dia, drawn by tool application Tools\Diagram_draw in the format
    //[diagram:<diagram_file_name>]
    A diagram specified in shown in a separate window (on mouse move over a line with such link).
• Fixes:

   

  • The primary compiler can now be compiled with the C# code (AL4.sln in the root of the distributive folder);
  • The dependency of a disk specified in the command line to compile the primary compiler is removed (code written in C# also uses the environment variable %al4%).
  • IDE: in the Form Designer the first control did not create if a column did not exists (now in such case the column is created first);
  • C#: using the type {Object} to declare variables, parameters, etc. (the compiler complained that the class {Object} was not imported);
  • C#: generating an initialization for a temporary fixed array of objects (used when a call of a function had place which requires such fixed array of objects as a parameter);

• Changes:
   
  • {Report}: a mode added (the Syllabels_second flag) to control how syllabel breaks are applied: when FALSE, wrapping uses syllabels always not trying to fit text into a cell without them;
  • {Report}: the aligning 'JUSTIFY' was implemented;
• Fixes:

   

  • {Report} - breaks by syllabels for some cases;
  • {Report} - works now for all the supported platforms: C#, Delphi/VCL, Delphi/KOL and Free Pascal;
  • IDE AL4 / Form Designer:

     

    • Report editor: a text was incorrectly handled containing comma (in the initial cell value); The flag Scaling up was not restored correctly while reading the CONSTRUCT; flags of scaling did not store and read in the CONSTRUCT; vertical center aligning did not restore correctly etc.

• Changes:
   
  • The modifier HANDLER was added for a function which can call CALLBACK-functions from the same class without warnings about this;
  • The visual component control is added: {Paint_font_styles}.
  • {Report}: printing with Wrap set to 'WRAP_WORDS' and 'WRAP_SYLLABELS' provided; methods Desired_rect(Cell_name) and Set_band_height(H) added. A lot of changes and fixes: now classes {Report} and {Printer} are ready for use (see demo in the folder Test_visual_projects\Test_print, it is working for Delphi/VCL and C#).
  • {Canvas}: the field {rect} Clip_rect added (for read and write). It allows to restrict any graphical output to canvas with the specified rectangle.
  • IDE AL4 / Form Designer:

     

    • The (working) visual Report editor was added;
• Fixes:

   

  • Incremental compiling:

     

    • refreshed class did not more treated as a FRIEND;
    • if there were several functions with similar names but in different letter cases, not corresponding function could be found to compare;
    • counter of warnings did not reset before recompiling a class, in result after sum amount become greater then 100 (or set by the /warn option), DLL did not create;
  • Delphi/VCL: when getting property {Combo}.Current for a NONE object representing not created {Combo}, an exception was firing;
  • More accurate skipping the BUT IN block after compiling it (now it can be finished with the combination '; .', and for block which is replaced, its nesting levels are taken into consideration);
  • Delphi: {Combo}.Select(-1) was impossible;
  • Delphi: generating of a code assigning a value to a record variable, in a reused in a LIKE statement, was leading to variable name duplication;
  • Delphi/VCL: as well as for KOL + C#, auto-sizing provided for {Button} when new text is assigned (important for cases when a button is placed in column aligned 'TOP' or 'BOTTOM');

• Changes:
   
  • A support of runtime type information added: when the class {RTTI} is imported, a set of functions becomes available, which allows to enumerate object fields, get its names, data types and get or change its values (for simple data types, scalar now only). It is possible to work with array items and fields of records (except arrays of records though). Such support added the first to simplify assigning data from fields of objects to sets of visual components on a form and backwards.
  • The block statement BUT IN 'label': ... ; added as a continuation of just called LIKE statement. It allows to implement iterating procedures without additional memory consumptions or lowering efficiency.
  • {Report|_printing}: creating a report reworked : first attributes should be specified, then a cell created.
  • It is disabled to use the UNCOOKED statement in blocks reused by LIKE/REVERT statements;
  • Symbol ==> in a function header can be placed in a new line;
  • The requirement to place symbol '?' in a separate line in CASE statements having more then one line in its condition is replaced by the requirement to start the '?' symbol in a new line in such case. (The previous formatting in a separate line also does not lead a warning).
  • Visual report editor (in the IDE) started (but not yet ready).
• Fixes:

   

  • Delphi/FPC: Generating code for a function returning a RECORD and using the append to an array operation (<<);
  • Delphi/VCL: attempt to work with Closed form could lead to run-time exceptions;
  • Delphi/VCL: an exception when Visible property is accepted for a not yet created form object;
  • Delphi/VCL: for the IBeam cursor, a correction was added for mouse coordinates getting;
  • Delphi/KOL: a rectangle is drawing in {Canvas} smaller 1 pixel in width & height to make it more similar to other libraries behavior;
  • Delphi/KOL: flickering of a form on its creation minimized (almost eliminated);
  • C#: an attempt to get Visible property of a non-existing {Form} was rising an exception;
  • C#: an initialization of a local dynamic array of records was done with a default constructor, so when an item out of range was accessing, this was leading to an exception because of impossibility to typecast the base class for all record classes AnyRec to a certain record class;
  • IDE AL4 / Form Designer:

     

    • Delphi: small corrections in graphics (dotted lines, size of a symbol ';' and so on);

• Changes:
   
  • A property Radio_group was added for the {Chackbox} (it behaves then like a very known Radiobox, though not changing its exterior view);
  • Classes {Report|_printing}, {Printers}, {NATIVE_Printers} added. Now it is possible to print onto print/plot devices and printing of reports of any complexity level.
• Fixes:

   

  • Delphi/VCL: setting a TRAP for write for a scalar object field fixed;
  • Delphi / FPC: generating << (append operation) for short strings (which are field in RECORDs);
  • Delphi: optimization with inline-insert of a function code was loosing initialization blocks for local record variables (a case of assigning a record "constructor" in a function);
  • IDE AL4 / Form Designer:

     

    • Buttons MOVE UP / MOVE DOWN worked incorrectly by mouse click (an arbitrary item on a form was selecting first);
    • Automatic creating of Alias values for controls fixed;

• Changes:
   
  • Methods added to save/restore form size & position on screen: {Form}.Save_bounds, {Form}.Restore_bounds;
  • The compiler: in case of calling a method using "parameter.method" notation, when another function with the same name is in scope, the priority is belonging to the method;
  • IDE AL4 / Form Designer:

     

    • Initially empty form also can be converted to a maintained by the Form Designer;
    • For empty columns, minimal size is assigned to them on draw 20x20 (pt);
    • Synchronizing alias of an item with the name of the item if these were matching before name editing;
    • The visual menu editor added for popup menus in a designed form (unfortunately, new format of a menu constructor is used, though it is compatible with the existing function popup_menu by parameter(s) - new class {Menu|_create} is used there. So, all earlier created menus should be transformed to a new format manually, to allow editing them visually);
    • It is possible now to create in a form constructor of a form maintained by the Form Designer, unknown classes of controls. As an example, the control {Separator} is created (on base of {Paintbox}, without scrollbars);
• Fixes:

   

  • Delphi/VCL: the event "moved" did not called when a window was moved by a mouse on screen;
  • Delphi/VCL: problems are fixed with exceptions on mouse wheel events (when there are no active controls on form);
  • C#: a modal dialog "message" could lead to hang of an application hiding behind a form;
  • IDE: in the Find/Replace dialog when called by keys combination CTRL-F, CTRL-R, search text edit field was in focus but without the caret shown (which could lead to problems when it was necessary to edit a text in a middle of an existing);
  • IDE AL4 / Form Designer:

     

    • Loading commands for {Paint_turtle} in a CONSTRUCT;
    • Other fixes (a lot, but not very essential);

• Changes:
   
  • Delphi/VCL: new feature incremental compiling (with reloading recompiled classes from DLLs) was improved / fixed:

     

    • All the last versions of DLLs created are re-loaded on each call of Update_functions;
    • The Update_functions method returns a string containing a (space separated) list of DLLs loaded;
    • A protect interval 1 second added to a compiler, before it starts recompiling changed classes;
    • Generating using of the NONE object of the base class {Object} in classes recompiled to DLLs, was fixed;
  • IDE AL4 / Form Designer: moved from the BETA stage to the stage "ready to use":

     

    • some problems are fixed with loading a CONSTRUCT, generation new CONSTRUCT, showing properties of controls/columns/form, drawing a form etc.;
    • jumping to events handlers in code added / creating event handlers (menu Form-Events...);
    • scaling added in the Form Designer.

• Changes:
   
  • Delphi/VCL: new feature added: incremental compiling with dynamic loading of recompiled classes (in DLL):

     

    • The key /$INCREMENTAL was added (the shortcut is available: /$INC). After compiling a project and running the application compiled, the compiler stays active and waiting changed sources of the application. Changed classes are compiled to DLLs.
    • The class {Incremental_compiling} was added with the function Update_funtions. It should be called in your application to load newly compiled functions from new DLLs created by the compiler. E.g./ call it in the "activated" event of your form, or by command (menu, button, keys combination, etc.)
    • The key /$NODLL={class1};{class2};...{class3} was added to exclude listed classes from the list of classes recompiled incrementally. Usually it is sufficient to add there {Form};{Control};{Screen};{AL4_form} to provide correct functioning.

• Changes:
   
  • The embedded method A[].Swap(i, j) added for all the arrays;
  • Generic functions are removed thom the AL-IV language (the class {Sorting} was converted to use LIKE....'label' statements to make code smaller, instead of generics);
  • Statement DEBUG IMPORT was replaced to IMPORT, DEBUG (i.e. DEBUG now used as the modifier);
  • The modifier DEBUG was added for functions/methods (a function with such modifier could be called only from a debug block, and a private debug function is not warned about if it is not used while all the DEBUG blocks are commented/removed);
• Fixes:

   

  • {Paint_turtle}: drawing a (loop) x n;
  • C#: calling TRAP write for a simple type field could not compile;

• Changes:
   
  • IDE AL4: Form Designer added (BETA);
  • The system color {system_color}.'MENU_HIGHLIGHT' added;
  • C#: the event {Form}.value_change now called only when the Text was actually changed for a {Label};
  • {Paint_turtle}.Paint_turtle static function added allowing to use it without a control creation (on any canvas);
• Fixes:

   

  • {Form}.Set_size(..., 'KEEP_ON_SCREEN') uses now a point with offset (1, 1), this should prevent moving to another monitor if the position to set was exactly at the top left position on a some display monitor;
  • C#: color System_colors('BUTTON_HIGHLIGHT') redirected to SystemColors.ControlLightLight (since ControlLight matches to 'BUTTON');
  • INLINE optimization: problems copying prefix operation '!' of a parameter of a function in-lined;
  • Delphi/VCL&FPC: {Canvas}.Rect(...) now draws a rectangle wider and higher one pixel to make the same as in C# and to take into account that coordinates are real numbers;
  • INLINE optimization was fixed for case of multiple inlining of a function having a parameter which is a dynamic array (again, was lost);
  • Event {Form}.hidden for a control did not work;
  • {Paint_lines}: extended names of the property Line_width and the method Set_line_height are corrected (these erroneously contained word 'pixels' which could be understanding as these are given in pixels though actually these values are always in points);
  • C#: creating fixed array of strings on base of existing array of strings (a slice);
  • C#: ShiftRight function worked incorrectly with negative numbers;
  • Delphi: generating PUSH for in-lined statements (duplicating variables);