This function requires cookies.
If the browser does not accept cookies,
the light theme is used always.


AL-IV:    Versions history

May, 18, 2022 - new version: 2.3.3

  • Changes:
    • IDE AL 4: small changes
    • Color commander: some improvements / changes, showing/changing attributes and owner/access rights for files/folders are added;
    • {File_path} += FUN Set_last_access_time;
    • {System_functions} += FUN User_name;
      FUN Execute_program += flag 16 == RUNAS;
    • {DB} += METHOD Transaction_level ==> INT;
      += BOOL In_query, READ;
  • Fixes:
    • C#/Delphi(VCL/FPC), {Form}: Show did not restore a minimized form been shown though activated it;

May, 10, 2022 - version: 2.3.2

  • Changes:
    • Tools\Draw_diagram (application): export to gifs added with options (White & black - removing colored fill) and Hatched (replacing colors with hatches);
    • Demo+applications\Clock: some improvements;
  • Fixes:
    • {Paint_turtle}: after setting background, the special flag Custom_background is set, and later this background is used to fill the canvas before drawing;

April, 30, 2022 - version: 2.3.1

  • Fixes:
    • C#/{NATIVE_Stream_on_C_Stream}: code creating a structure {Long_int}.{long}; as one of consequences loading icons did not work in the {Icon} class;
    • {Form}: sender now restored after handling an event (from a stack of sender's stored) preventing strange situations when in result of a nested event handler call the sender was changed suddenly on the event handler method;

April, 21, 2022 - version: 2.3.0

  • Changes:
    • {DB}.Commit now returns a BOOL flag indicating that the transaction was commited OK (it can be used to show an error or log errors otherwise);

      Any errors while Exec/Open operations lead to unsuccessful commits (errors accessing already ready fields are ignored therefore);

      Also the Commit_a|lways method added (DEPRECATED) which works as Commit earlier;
    • Compiler: options /warn -style, /warn -index[ing] added to stop warnings about code style and using INDEXING variable declarations;
    • Compiler: while checking side effects in expressions / statements, recursion is checking only for methods, not for static functions minimizing amount of such detections (evidently too big otherwise);
    • IDE: improvements in the Instance code (ctrl+i, turned on by default);
    • IDE/Designer: double click on a control with LMB searches the control clicked (by its Alias) in the click event only; double click with RMB as earlier searches it in entire class code;
      Jumping to events before_CONSTRUCT, after_CONSTRUCT added;
  • Fixes:
    • fixed arrays of structures support removed;
    • FPC: a useless (and incorrect) message was appearing in the console about incorrect using resourceless foirms;
    • Delphi VCL/KOL, FPC (Windows): file time (creation, modification, access) was reading without shifting from the UTC to local time;

April, 7, 2022 - version: 2.2.9

  • Changes:
    • SQL: JOIN with duplicated tables/aliases issue a warning rather then error still duplicating sometimes necessary in alternated branches (separated with ------------'condition?' directives);
    • SQL: functions added Int_sql0, Date_sql0, Id_sql0, Bool_sql0, Str_sql0 to convert automatically zero/empty values to NULL;
      In SQL-queries in expressions in figure brackets use these functions except for NOT NULL fields or the special prefix symbol "@" is written: {@ expression };
  • Fixes:
    • SQL: INSERT ... , BY ... , BUT except_fields[] - query created was incorrect (with commas misplaced);
    • SQL: UPDATE ... , BY ... , BUT except_fields[] - was not implemented;
    • {Paint_table}: when Clear was called, the Current_line did not reset, so on a click on the same line after refilling lines, the event selection_change could not be fired as necessary;
    • C#, {Form}.message, .ask: the form (and the application too) lost the focus after the message dialog show (fixed using a timer fired about 10 mseconds later with a call to Activate() method);
    • Delphi/FPC, {System_functions|.Execute_program: an error in x64 applications fixed (with type reduction from THandle to DWORD);
    • Delphi/FPC/KOL: generating code initializing fixed arrays of objects af fields of classes/structures;
    • FPC + Windows: {Form}, {AL4_form}; when calling Popup_menu, application crashed still the Lazarus windows messages handler is not checking the situation that Application.MainForm can be nil. This was fixed changing the way forms are created (via Application.CreateForm);

March, 23, 2022 - version: 2.2.8a

  • Changes:
    • {Form_common}: when a control get the focus, the previous (to it) label is highlighted (otherwise, in Linux it is hard to find which control is active now);
  • Fixes:
    • C#, {Paintbox}++: the capability to catch normally arrow keys restored (the attempt to prevent moving focus to another control in some cases when an arrow key pressed was wrong);
    • Free Pascal, {Label}: the size of labels is not changed automatically for labels which size was set explicitly;

March, 22, 2022 - version: 2.2.8

  • Changes:
    • IDE: in the Find form, a capability added to skip lines containing a  certain string pattern;
  • Fixes:
    • Compiler: in case if an erroneous using of the DONE prefix for a statement (in a FOR loop) it's line number could be shown incorrectly 0 (zero);
    • C#/Delphi/VCL, {Paint_lines}/{Paint_table}: while selecting lines of a control with arrow keys the keyboard focus was moving to other controls on a form;
    • Delphi VCL/FPC: pressing SPACE / ENTER on a button could not click it;

March, 13, 2022 - version: 2.2.7

  • Changes:
    • {Paint_table}: += selecting by dragging mouse with LMB pressed, + with CONTROL: deselect/select additional lines;
    • IDE/Designer: initial event handler is created on the first jump to the even handler menu_item (via menu, when it is not yet existing and it is created first); so, on the second jump to it (via Events\menu_item) all existing menu item aliases are added to the CASE in the handler automatically;
  • Fixes:
    • C#: {Dialog} - in some cases (if the Result of the dialog modal show did not used / assigned) the application could crash on the dialog close;

March, 7, 2022 - version: 2.2.6

  • Fixes:
    • C#, Delphi(VCL)/FPC: mouse/keyboard events could be called while interrupting the main execution flaw (e.g. in result of too long paint operation or other long loop). In result, the method {Form}.Any_change could not provide correct state for controls (accessible/inaccessible, visible/invisible).
      Solved: by adding a flag/counter Allow_handle_events which prevents nesting calls of a loop handling messages queue;

February, 20, 2022 - version: 2.2.5

  • Fixes:
    • Compiling negative constants;

February, 7, 2022 - version: 2.2.4

  • Fixes:
    • {OpenGL}: for unknown reason size of the control was fixed at the first access to Width/Height property;
    • {Paint_tab}: handling mouse was stoping after handling it for internal purposes, this did not accept any additional mouse handling on a tabs bar;
  • Applications updated:
    • Color Commander:
      • Clicking on the active tab header activates the tab, which was active before it (now works);

January, 30, 2022 - version: 2.2.3

  • Changes:
    • Delphi/FPC (Windows): {File_stream} - modifying file size on disk is provided while writing to the file;
    • C#: {WebP} loading provided (libwebp32.dll or libwebp64.dll required);
  • Fixes:
    • FPC: Demo_projects\Zoomer6lite\{Image}: loading WEBP format fixed;
    • {Paint_turtle}: with new method {Control}.Click introduced some time ago, double click on a turtle button become interpreting as a single click only, fixed now to be handled twice;
    • FPC: {Hardware}.Get_drive_type did not work always returning 'UNKNOWN';
    • C#/{Long_int}: operations with long integers are fixed (in cases when low 32 bit value looks like a negative integer);
    • IDE/Designer: generating code for color from {system_color};
    • FPC: compiling visual applications under linux fixed;
  • Applications updated:
    • Zoomer6 / Zoomer6Lite: WebP support added;
    • Color Commander:
      • Deleting files improved: if it is not possible to remove a file to the Recycle Bin, it is asked to remove it permanently;
      • Copying large files fixed (greater then 4 GBytes) and improved: now progress of copying is showing correctly;
      • Canceling copy operations did not work (Delphi/FPC), now fixed;
      • Reading disk info speed increased;
      • Geitting info on disks fixed (FPC);
      • Buttons added: +, x;
      • Clicking on the active tab header activates the tab, which was active before it;

January, 20, 2022 - version: 2.2.2

  • Changes:
    • {DB}: While generating SQL code for INSERT and UPDATE, field names are enclosed into square brackets; also it is now possible to use such enclosing in a select list, where, group-by and order-by clauses of all the SQL queries;
    • {DB}: Method Transaction_dummy added (for debug purposes, to replace PUSH Transaction with PUSH Transaction_dummy quickly);
    • {DB}: Method Row_count added to get amount of rows affected in result of an INSERT / UPDATE operation;
  • Fixes:
    • {DB}: the problem fixed with repeating calls to Remove_not_allowed. Still the list of allowed branches was cleared in this method, the secondary call to it (including such in the Exec/Open just before running the query) removed all the optional branches from the SQL text. Now the list of allows is cleared only in the Exec/Open, so it is possible to call Remove_not_allowed several times without affecting the resulting SQL query text;
    • {DB}: Support added for comments ----------------- 'condition?' between assignments of fields in UPDATE SQL statements; the automatic comment just before WHERE also is adding if any such comment present (to prevent WHERE clause to be removed suddenly);
    • IDE AL4/Designer: there were problems after replacing METHOD to FUNCTION for the before_CONSTRUCT;
    • C#: {Form}.message could shift an application to an indeterminate state (message did not show, but forms could not be activated both with mouse or keyboard but pressing ENTER key); The dialog work changed to always show on the default display;

January, 9, 2022 - version: 2.2.1

  • Changes:
    • {Report}: methods Cell_r|ight, Cell_d|own added. This simplify preparing Bands/Cells to use them in report generating methods;
  • Fixes:
    • IDE/AL4: adopted to new changes in {Date_time} and {Stream};
    • C#/{DB} + OLE_DB: code adopted to new changes in {Stream};
    • C#/{DB} + ODBC: possible memory leaks are fixed in the native code;

January, 3, 2022 - version: 2.2

  • Changes:
    • {Date_time}: field DT of the structure {date_time} is replaced with the private field dt. To provide maximal possible compatibilty functions DT and Date_time. The first of them allows to avoid changing code converting a structure {date_time} to a REAL number (representing number of milliseconds from either 1,Jan,1601 or from the 1,Jan,1BC  depending on a platform); This change allows using {date_time} on platforms not having real numbers big enough to store amount of milliseconds from the start of the era;
      {File_path} still uses REAL values to store file times, but it is mostly platform-dependent, and later this can be changed, too;
    • {Stream} + {File_stream} + {Memory_stream}: To position in streams and to work with streams size, structure {Long_int}.{long} used now (in place of REAL). Thus, some small corrections could be needed in existing projects;
    • {DB}: in any case it is allowed to use table aliases including single table in a query; this allows to use nested queries both in case when a nested or master query uses a single table in a query;
    • {DB}: Support added of operations EXISTS(SELECT...) and NOT EXISTS(SELECT...) as SQL operands;
    • Method CONSTRUCT of a class can be recursive and so it can have the modifier  RECURSIVE;
    • Another kind of an assignment statement introduced: dstruc, BUT[(f1, f2, ...)] = sstruc[, BUT (fN+1, fN+2, ...)]
      It allows to assign fields of the source structure variable (sstruc) to fields of the destination structure variable (dstruc), where types of those structures could be different. While assigning, fields listed in BUT lists are not assigned (skipped). For all other destination fields it is necessary to exist correspondent source fields (matching by the short name). And types of correspondent fields must be equal. The assignment is not working (not implemented) for array fields.
    • While declaring a STRUCTURE type it is allowed to use inclusion from another structure with the statement:
      LIKE {structure_type}
      LIKE {Class_name}.{structure_type}
      In result, all the fields of the source structure type specified are added on the top level of the declaring structure; In case of a source structure from the same class, it should be already declared above;
    • Block comments in form -------------- 'text' in calls to constructors of structures or objects like
      x = {type}(field=value,
      ----------------- 'comment'
                 fieldN+1 = valueN+1, ...)
  • Fixes:
    • Delphi/KOL, {DB}: reading Date fields from databases;
    • Fixes in compiling overloaded functions;

December, 29, 2021 - version: 2.1.2

  • Fixes:
    • C#, Delphi/KOL, Delphi/FPC, FreePascal/LCL + {Printer}: printing fixed;

December, 26, 2021 - version: 2.1.1

  • Important fixes:
    • Compiling for Android restored;
  • Changes:
    • {Separator}.Set_separator_column_target({Form} F, STR Separator_col, STR Target_col_resizing) allows explicitly specify which column is resized by a certain separator column (in which direction now is decided on base of target column location, before or after from the separator column). In most cases it is not necessary to change setting =s for already working splitters but exclusions are possible;
    • {Paint_table}: Current_line not to detect which line is drawing (use Drawing.Item);
    • While checking accessibility of private fields, now descendents of friend classes are taken into account;
    • {Form_common}/{Dialog_common}:
      • for {Paint_lines} and its descendents focus frame drawing added;
      • functions added: Set_all_forms_min|imal_size_restriction(min_w, min_h),
        Set_all_dialogs_min|imal_size_restriction(min_w, min_h);
  • Fixes:
    • {Paint_tree}: on a programmatical call to Select method, the form even selection_change did not call;
    • {Table}: generating SQL-code for INSERT statements with optional groups of values set (separated with comments in form
      -------------------- 'condition ?'
    • {Form}: horizontal columns aligning controls style 'CONTROLS_LEFT_LABELS_ABOVE' fixed (45% of a column height is used by labels);
    • IDE/Designer: generating code to set multi-line text in the CONSTRUCT;
    • {DB}:
      • INSERT with optional fields set;
      • INSERT with several joined tables;
      • SELECT + GROUP BY: using fields with table aliases is allowed;

December, 18, 2021 - version: 2.1

  • Important fixes:
    • Delphi: error inserting bytes in the inner position of a bytes array;
    • Compiler: Searching a Str function (called implicitly, in << statement) in case of incorrect operand could lead to an incorrect (not compiling) resulting code;
    • FPC: compiling for Linux restored;
    • Delphi/FPC: Contains, Find in a fixed strings array;
  • Changes:
    • {Form}, {Timer}: handling disabled nesting event handlers is turned off if in the event handler "timer" (handling a timer tick) a timer is deactivated (as first as possible). This allows to start via a timer some long operations during which it is desired to not stop handling other events such as "click";
    • Method {Control}.Click added (to initiate the click even for a certain control, programmatically);
    • {Form_common} / {Dialog_common} : additional handling events enter / leave: invalidating {Paint_lines} controls (and descendants);
    • IDE: correcting horizontal position while walking with arrow keys up and down in the text;
  • Fixes:
    • FPC: the compiler saved the All_classes.pas generated in Ansi encoding, so national chars (e.g. names of enumeration items) were replaced with '?' symbols;
    • IDE/Menu edit: selecting a submenu when there are several submenus defined;
    • IDE/Designer: horizontal scrolling did not appear if there were no menus on form;
    • {Paint_table}: caret position one line upper from correct;
    • {Paint_table}: redudant selecting of lines occured while pressing down/up arrows to change current line (like shift would pressed);
    • C#/Delphi(VCL)/FPC, {Paint_lines}+{Paint_table}+{Paint_tree}: handling TAB, SHIFT+TAB to tabulate between controls fixed, and keys ESCAPE (if cancel button present) and ENTER (if default button present on the form);
    • C#, {Paint_table}: on the first form show only part of a table was drawn;
    • FPC: auto-positioning of controls in an initially invisible horizontal column did not work until the form manual resize after becoming the column visible;
    • Delphi(VCL), FPC: setting control size programmatically did not stop auto-sizing such controls (for buttons, labels etc.);
    • C#, {Form}: handling events 'enter' / 'leave' did not implemented;

      Delphi: events 'enter' / 'leave' worked only for graphical controls ({Paintbox} and descending {Paint_...});
    • {DB}, {MDB}, \AL4\Test_projects\Test_db: compiling / working tests with MS Access is restored (function Str_sql moved to the separate class {Db_sql_string} which special version should be specified by adding the path DB\4MBD first to the list of sources for a project);

December, 12, 2021 - version: 2.0.6

  • Changes:
    • {Form}.Column_layout += 'CONTROLS_LEFT_LABELS_ABOVE' (for horizontal columns);
    • IDE/Designer: automatic added not yet handling menu items to the CASE statement of the menu_item even handler while jumping to it from the menu "Events";
    • IDE/Designer: checking an ancestor form class name is given not on exact name matching but on starting it from "{Form" / "{Dialog", so it is now possible to visual adjust forms based on another ancestor, e.g. {Form_common};
    • Classes {Form_common}, {Dialog_common} are added, to use them as prototypes for forms and dialogs in applications. These have defined some typical handlers for some events;
    • A compiler command line key /max_desc {Class},n to restrict amount of classes derived from the Class specified in the entire project;
  • Fixes:
    • a LIKE b (strings comparing);
    • {String}.Replace_all now works from the last found to the first, so now replacements like x ==> xy work well;
    • Delphi: generating code adding a new structure (just created) into an array (a case of a simple structure);

December, 3, 2021 - version: 2.0.5

  • Changes:
    • A field of a structure can be not public, therefore it is available for read and write in the class where the structure type is defined and in its descendants;
    • {DB}: a special structure type {id|entity} is created to work with IDENTITY fields in database tables (earlier, the REAL type was suggested for that purpose);
    • {DB}: a method Nulls ==> STR added which returns after a SELECT query for a record a string containing a list of fields which are NULLs;
    • {DB}: a request INSERT ... BY structure can be extended with the part , BUT str[] with a string array specified with names of fields which values should not be set;
    • IDE/Designer: menu (schema) drawing added, with the capability to go to a menu item handling code by double click on it;
  • Fixes:
    • {Dialog}: closing event did not call (now it is called for dialogs too, but the result of the function is ignored);
    • C#,Delphi(VCL)+{DB}: Transaction implemented correctly for ODBC & OLE DB;
    • {Paint_tree}: drawing lines;

November, 27, 2021 - version: 2.0.4

  • Changes:
    • IDE/Designer: group selecting changed with Shift/Control (Control+click adds or removes a single control to/from the selection, Shift+click expands the selection adding all the controls intersecting the rectangle around already selected + the control clicked);
    • IDE/Designer: the capability to edit values for all the selected properties added (only those properties are shown which are appropriate for all the selected controls, its labels become RED in case when properties are not the same for selected controls);
    • IDE/Designer, {Paint_turtle}: visual working with properties Border, Ink, Fill, Ink_disabled, Fill_disabled;
    • {Form}, new_column: column has new option to align labels right;
  • Fixes:
    • IDE/Designer: changes and fixes in selected controls/columns duplicating;
    • {Paint_turtle}: drawing in 'FLAT' style fixed, initial clearing added;
    • {Paintbox} (Delphi, FPC): initial erasing added on create the buffer bitmap;
    • FPC: {Datepicker}.Text;
    • FPC: default and cancel buttons on form did not work (these are supported in LCL only for dialogs);
    • Optimization: calls to CONSTRUCT functions are taken into account as usual functions (the optimizer could remove entire CONSTRUCT code if there were no any other functions in the class called);

November, 21, 2021 - version: 2.0.3

  • Changes:
    • IDE/Designer: new properties available (Min width, Min height for form, Multiselect for {Paint_table}), mouse coordinates;
    • IDE/Designer + {Paint_table}: it is now possible to adjust columns visually;
    • {Form}: changes in columns aligning: if there are both 'LEFT' and 'RIGHT' aligned columns but there are no center aligned columns, then all the 'LEFT'/'RIGHT' columns are sized equally to occupy entire client width of the form;
    • {Form}.Set_size_min(min_w, min_h) method added;
  • Fixes:
    • Compiler: optimization with inlining a function containing loops with BREAK/CONTINUE statements, worked incorrectly (final code did not compile w/o turning optimization off);
    • While compiling long SQL-queries, scanning could be broken suddenly firing unclear errors in code;
    • Delphi: FOR + code optimizations (problems solved);
    • Delphi/KOL: {Dialog}.Show_modal - form did not hide, it just closed;
    • SQL/INSERT: in case of optional parts in the assignment list (separated with comment blocks ----------- 'condition?'), the code could be corrupted while removing such parts;

November, 14, 2021 - version: 2.0.2

  • Changes:
    • IDE Designer: improved calculating of the central column size;
    • {Paint_tree}: drawing improved, icons drawing added (turtle drawing), function to handle keys commands (arrows and others);
    • The sugar with accessing to anothr field of the same object in the same expression is improved: Tree.Node(.Selected), Control.Width + .Height, etc.;
    • Compiler: in case of assignment a value to a field of a structure returned in result of a function call (pointless operation);
    • {Form}, {Paint_turtle}: while locating controls in a column from the top to the bottom, controls of type {Paint_turtle} created following another control always are placed in the same row (so it is allowed to place up to three controls in a row, if the first is a label and the 3rd is {Paint_turtle});
    • {Paint_turtle}: subbuttons mode added (turnting a {Paint_turtle} control to a horizontal line of several buttons);
    • SQL/DELETE: it is allowed to use special word ALL in place of WHERE clause (DELETE FROM MyTable, ALL) to specify that the entire content of a table is deleted, and this is not an error;


  • Fixes:
    • Delphi(VCL)/FPC: {Paintbox} - setting vertical scroll position;
    • Designer: adding new aliases in the CASE of an event handler (click) while jumping to it from the menu of the Designer;
    • SQL INSERT, UPDATE: using comments --------------- 'text' in a list of assignments of values to database fileds;
    • Compiler: more correct working under chains of comparisons (in case when there were other operations between comparisons, e.g. a + b < d + e < f + g). And therefore in case a < b && c < d the chain operation is not detected still the && \ || operations priority is lower;
    • IDE/Designer: loading problems for {Paint_turtle} having Like_button = FALSE;
    • Android/JAVA: compiling {AL4_form} was broken;

November, 7, 2021 - version: 2.0.1

  • Changes:
    • In the SQL statement SELECT it is not necessary to enclose in brackets a single field in a list of the ORDER BY and the GROUP BY sections;
    • {Paint_table}.Hidden_col, Set_hidden_columns(N) - concealment of several last columns in a table;
    • {Form}: While handling any events, nested calls to event handlers of mouse down/up and keyboard events are locked (click, mouse_down, mouse_up, mouse_double_click, key_down, key_up, key_press);
    • C#, Delphi/FPC: for {Edit} the filter was implemented for symbols which can not be in a number if the option 'N' was passed on the edit control creation;
    • IDE, IDE Designer: some improvements and fixes;
  • Fixes:
    • IDE/Designer: loading a multi-configurated form constructor;
    • Delphi: generating a CASE without branches defined;
    • Delphi: generating code declaring (and initializing) a field which is an array of objects (of fixed size);

October, 31, 2021 - version: 2.0.0

  • Changes:
    • Another variant of the FOR statement added:
      FOR i ENUM some_method: ... ; which allows using methods to enumerate iterations. E.g. for databases:
      FOR i ENUM DB.Results :
          tabl1 << DB.CStr("Last_name")
          .. << DB.CStr("First_name")
          .. << (Now.Year - DB.CDate("Birth_date").Year).S
    • The DONE statement introduced which should be used to separate ending part of statements block in a FOR statement which is ending with a BREAK or ==> statement; E.g.:

      FOR flag IN A[] :
          CASE flag.Color != RED ? CONTINUE flag ;
               << "first found red flag is " flag.Name #NL
               BREAK flag ;
    • The block statement SILENT: ... ; was introduced to enclose blocks of code in which warnings from the compiler are suppressed;
    • A special feature controlling types of indexed arrays is introduced. A variable or a field declared (or a parameter of a function, or a loop variable) can have an additional attribute INDEXING type or INDEXING (list,of,types) and if it is used as an index of an array item, such type(s) is(are) compare to the type of the array item indexed; While this feature is not used this just makes a warning about indexing with a variable without INDEXING attribute defined; If attributes INDEXING specified explicitly are not corresponding, this fires an error;
      Variables, fields and other units with the attribute INDEXING set are allowed to have less then 8 characters in its names without firing an error message;
    • In expressions, chain comparison operations added (like a < b < c <= d). Any allowed comparisons are accepted, and a chain is converted to couples of comparisons united with the && operator (logical AND);
    • Comparison operation <> is allowed everywhere in expressions in place of != (not only in SQL queries);
  • Fixes:
    • C#, Delphi(VCL,KOL)/FPC: fixes in scrolling in {Paintbox};
    • C#: The object destructor if calling native functions could produce an infinitive recursion;
    • C#: error generating code for an unrolled FOR loop;
    • Delphi/FPC: error while assigning the object THIS;

October, 22, 2021 - version: 1.9.8

  • Changes:
    • {Localization_str}: function Localize_by(text[], prefix) added which allows to localise an application on base of a dictionary loaded into the array text[];
  • Fixes:
    • Compiler/optimizer: incorrect treating a function which the first statement is an assignment of a constant to the RESULT as the function returning such constant only;
    • {Paint_table}: drawing was a bit slow in case when amount of columns was big enough (100 and more);
    • Delphi/KOL: System_color for 'HIGHLIGHT', 'HIGHLIGHT_TEXT';
    • {Paintbox}: horizonal scrolling made programmatically worked incorrectly;
    • Compiler: Control using as an operand of an expression a function not returning a result;

October, 13, 2021 - version: 1.9.7

  • Fixes:
    • C#/{Label}: Autosize always was turned offc, not only in result of setting size explicitly;
    • {DB}: a fix for nested queries (in condition: x IN (SELECT ...));
    • C#: array[n TO m] when m >= array[].Count;

October, 7, 2021 - version: 1.9.6

  • Fixes:
    • IDE: when using some fonts some symbols occupied 2 positions in text making text editing hard;
    • C#/{Process}: while launching an executable the parameter Visible=FALSE did not take into account: the application was running visible;
    • {DB}: in SQL queries it is not necessary to add a comma following the list of FROM-JOIN-JOIN ... (this allows no more add a condition or other parts if these are not necessary);
    • Delphi/{Date_picker}.Text;
    • Delphi/{DB}.VBool;

October, 2, 2021 - version: 1.9.5

  • Fixes:
    • {Paint_table}: Resizing columns with mouse did not work if in result of a vertical scroll the top line was moved up;
    • {DB}.Remove_after for the last portion of a SQL request now works without necessity to add a fake code (like AND 1=1) and to prepend it with an additional block comment;
    • In SQL queries SELECT in cases when the list of selecting fields was located immediately following SELECT [TOP(n),][DISTINCT,], possible nesting parentheses were not taken into account - now this is fixed;
    • IDE/Designer: in case of several "columns" aligned by 'CLIENT' (when additional client-aligned columns are drawn at the right side of the form) the scroll range did not set enough to view all the central columns without expanding the designer window;
    • C#, Delphi/VCL+FPC + {Paint_table}: horizontal scrolling fixed (range did not set to enough value to scroll entire table horizontally);

September, 30, 2021 - version: 1.9.4

  • Changes:
    • In SQL requests SELECT it is allowed to place a list of selecting fields just before the FROM section like in the original SQL language;
    • In SQL expressions it is allowed to type a comma after BETWEEN x, before AND;
    • In SQL queries in a list of JOIN's and in a selection list it is also allowed to insert block comments in form ---------------- 'text' which later can be used to remove some portions of the request code by some specific conditions;
    • While compiling an SQL query SELECT, fields listed in the section ORDER BY are checked for ambiguity (the MS SQL for instance marks as ambigouos fields which are present in several used tables even if only a single such field is specified explicitly in a selection list). To resolve such ambiguity it is necessary to select such field renaming it using "x AS y" construction and then use in the ORDER BY its alias "y".
  • Fixes:
    • {Form}.column_hidden: if there are more then one column aligned 'CLIENT', only the first one could be shown;

September, 28, 2021 - version: 1.9.3

  • Fixes:
    • {Paint_table}: changing column width with a mouse did not work correctly if the control was scrolled right;
    • {Paint_table}: changing column width did not work if its size was set to 0 before;
    • {Paint_table}: too long column captions was intersecting each others;
    • {DB}: problems with encoding national symbols in a query text (fixed by encoding string literals in the form N'text');
    • {DB}.Remove_after fixed: only one portion of a code was removing (the last one);

September, 26, 2021 - version: 1.9.2

  • Changes:
    • In SQL queries (INSERT/UPDATE) it is allowed in sections of assignments of values to fields of a new record (as well as in the condition section) to separate them with comments in form ------------- 'text' and then to remove some assignments with the function {DB}.Remove_after;
    • Delphi/VC, FPC + {DB}: it is allowed to assign/compare integer fields and Boolean variables/values (value 0 in a field is treated as FALSE, all others as TRUE);
    • Delphi/VCL: property of the Delphi TForm.Autoscroll now is turned off by default (to turn it back it is necessary to add the symbol /$DEFINE=AUTOSCROLL_FORMS);
  • Fixes:
    • C#, Delphi/VCL, Delphi/KOL + {Date_picker}.Date, .Set_date;
    • Delphi/VCL: automatic sizing for buttons (labels, checkboxes) is fixed calculating text size for a bold font;

September, 23, 2021 - version: 1.9.1

  • Fixes:
    • C#/{File}.Exists: checking an existence of an non-existent file could work very long time for directories with a large number of files;
    • C#/{Process}: if an executable file is launching (.exe, .cmd, .bat) then the environment variables are taken from the current (system) environment rather then inherited in the working process;
    • {Complex}.Cpow;
  • Updates:
    • Color Commander application version 0.41;

September, 21, 2021 - version: 1.9.0

  • Changes:
    • IDE/Designer: form area size is expanded, mouse wheel speed increased;
    • IDE: drawing a number of a current line changed;
    • C#/{Label}, {Button}: if a control width as changed explicitly its automatic sizing is cancelled permanently;

September, 16, 2021 - version: 1.8.9c

  • Fixes:
    • IDE/Designer: when adding a control of the class {Date_picker}, the name of the class was used {Datepicker} (w/o underscore);
    • C#, {Form}: immediately after form showing the method Form_resize was forced to be called to provide correct controls layout in some cases;

September, 15, 2021 - version: 1.8.9b

  • Fixes:
    • {Memory_stream}.Write_byte worked incorrectly;

September, 14, 2021 - version: 1.8.9a

  • Fixes:
    • While calling overloaded functions, the compiler sometimes could not find correct version of the function.


September, 13, 2021 - version: 1.8.9

  • Fixes:
    • While optimizing code containing calls to overloaded functions, the code of such functions became empty (there was already the attempt to fix this but not 100% were fixed);
    • {Form}: wider left/right margins are returned for cases when there are 'LEFT' / 'RIGHT' aligned columns on a form;
    • Operation x << y when the 'x' is an object (and the statement is calling its Write method): the correspondence of types of a value adding to the Write method parameter did not check;

September, 9, 2021 - version: 1.8.8

  • Changes:
    • {Form}: for a form containing only columns arranged vertically its left and right margins are smalled to 2 pts; in case when there are only horizontal its vertical margins are nullified. In case of a single centered column both these rules are applied.
  • Fixes:
    • Delphi/KOL: Set_file_time_age fixed order of parameters (not last write time was changed actually but last access time);
    • Android: some fixes (passing a dynamic array in place of a fixed, compiling {Process});

August, 27, 2021 - version: 1.8.7

  • Fixes:
    • While optimizing code functions marked with the modifier CALLBACK could be removed erroneously;
    • While optimizing code containing calls to overloaded functions, the code of such functions became empty;

July, 22, 2021 - version: 1.8.6

  • Changes:
    • Option /$NO_SIDE_EFFECTS added, allowing to avoid checking side effects in expression. Do not use it for projects which can be compiled with final compilers which are sensitive to side effects (like C/C++);
  • Fixes:
    • Working of the interpreter (on C#) restored (partially, for non-visual applications);

July, 21, 2021 - version: 1.8.5

  • Changes:
    • Delphi: compatibility with Delphi3 added (unfortunately, in many cases the compiler gives an internal erroer but sometimes therefore it creates working executable file);
    • Delphi: option /$DELPHI3 added to force some compatibility in code generated;
    • Delphi: a possibility added to specify in the system environment variable FORCE_DELPHI a value 3 or 5 to force correspondent compatibility mode (like to options /$DELPHI3 or /$DELPHI5);
  • Fixes:
    • Delphi: some fixes in correspondence with last changes in the compiler;

June, 29, 2021 - version: 1.8.4

  • Changes:
    • Dephi: Delphi6 compatibility added;
    • Delphi: Delphi5 compatibility added (to compile with KOL, it can be necessary to add options $DEFINE=PNG_NOMMX, and $DELPHI5);
    • It is allowed in the operation variable = DB, BY TABLE table to use an object (in addition to a structure) as the left operand which has only fields represented in the database table specified;
    • It is allowed to add a record from a database query to an array of structures or objects without creating an intermediate structure or object variable:
      array[] << DB, BY TABLE table
  • Fixes:
    • C#/Delphi(VCL)/FPC + {DB}: getting date-time fields values from databases fixed;
    • Delphi/KOL + {Form}.Set_default_font: fixed;
    • Delphi/KOL + {AL4_form}: Get_form_column_controls_layout fixed;

June, 16, 2021 - version: 1.8.3

  • Fixes:
    • Operation of getting a record values from database (in form
      {type} struct << DB, BY TABLE struct_type
      if the .Dismiss was called in a loop then the structure was replaced with the NONE object on the first iteration, and all other values were zeroes; This was fixed assigning first a new structure to the structure variable;
    • Delphi/FPC: CASE on a string expression: symbol appearing as the character with index 0 of an empty string was incorrectly checking;
    • More careful testing of types of array parameters passed;

May, 26, 2021 - version: 1.8.2

  • Changes:
    • It is allowed to use chains x.y.z[i].w as operands in figure brackets in SQL expressions;
    • It is allowed to use a function result as the left side of the << operation (in cases when it returns an object of a class having Write method accepting a string parameter);
    • {Paint_table}.Resize_columns = TRUE : property added (which allows changing columns size with a mouse/finger);
    • It is allowed to pass a dynamic array in place of a fixed array parameter (but a warning is emitted);
  • Fixes:
    • More careful checking of a fact of passing a fixed array as the first argument when a function accepts a dynamical array on the first place;
    • C#: CASE on a string expression: symbol appearing as the character with index 0 of an empty string was incorrectly checking;
    • FPC/Linux: accessing array items of a CLAMP array;
    • C#: an unpredictable problem with passing the '^' character in command line arguments while calling an application via Process.Start(); This is seems not documented that the '^' should be doubled to be passed for a starting program;
    • Delphi/FPC(Windows) - visual applications: bug fixed with handling messages while calling directly {Form}.Process (led to Access violation at the run time);
    • gcc: console unbuffered input implemented (function {Console}.Get_char);

May, 19, 2021 - version: 1.8.1

  • Changes:
    • It is allowed to use comments -- 'comment' in ENUM declaration (between items);
  • Fixes:
    • {Paint_tree}: drawing nodes fixed;
    • {DB}/SQL: searching fields in tables in SQL expressions was case sensitive in some cases;

May, 13, 2021 - version: 1.8.0

  • Fixes:
    • IDE AL4/C#: When opening an empty file (and on the first run) an exception occurred on trying to draw a page thumb rectangle of an infinitive height;
    • apps\Clock: state did not save on a new PC; the language selected did not applied;
    • C#: {Form}.shown did not call on form re-show after been hidden;
    • C#: {Form}.Set_client_size added some additional width and height to a form (this was a remnant of a solve of some forgotten problem, did not removed earlier);
    • Delphi/VCL: {Form}.Set_no_border did not allow change window size manually - fixed;
    • Free Pascal: Str.Compare sometimes treated identical strings not equal due a bug;

May, 2, 2021 - version: 1.7.9

  • Changes:
    • {Form}: the control extending (anchored) bottom/right now should not be the last control in a column;
    • {DB}/{MSSQL}/FPC: correct working with native MS SQL encodings are provided when an application is compiled for the FPC/Windows platform (the path Library\DB\FPC should be configured before the Library\DB, so the class {MSSQL_base} in the variant with correct strings conversion methods is attached first);
      (It is not necessary to do so to work with MS SQL DB from Linux still the unixodbc driver does such conversions itself);
    • {DB}/SQL: in operation like
      struc << Db, BY TABLE tab
      it is allowed to use as a destination structured variable, any structure which all fields are corresponding to a source structure which is a base for the source table (and all the fields should be corresponding without conflicts);
    • {DB}/SQL: pseudo-function SQL(...) returning a string does not include external parenthesis; also it is not necessary to enclose the SQL(...) function into parenthesis in case when it is used as the right side of the operation X IN Y in a sql-expression;
    • {Paint_tree}: optimized speed (drawing/scrolling);
  • Fixes:
    • {DB}/Pascal(KOL, VCL, FPC): errors positioning to the first record in {DB}.Open;

April, 27, 2021 - version: 1.7.8

  • Changes:
    • {DB}/Table: while compiling SQL queries, searching field names in a structures based on tables now case insensitive;
    • {DB}/TABLE: it is allowed in table base structures to use fields of enumerated data types (in databases, these should correspond to INT value);
    • {DB}/TABLE: it is now possible to read entire current record in a database query using a statement like
      rec << Db, BY TABLE tab
      (where rec - is a variable of a STRUCTURE type, Db - a variable of the data type {DB}, or inherited, and tab - is a table name declared by a
      TABLE name : {base_structure} declaration;
      Actually, such statement is equivalent to insertion of several lines in code like
      rec.fieldN = Db.Cnnn("name") (where nnn in str, int, real, date, bool - depending on a type on a field);
    • {DB}/SQL: in SQL queries it is allowed to use symbols ',' before any AND / OR in WHERE clause;
    • {DB}/SQL: it is allowed to use nested SELECT queries in conditions, at the right side of operations IN / NOT IN, for example:
      ...WHERE x IN (SELECT FROM t, (fld), WHERE id={ n })
    • {DB}/SQL: automatic conversion of subexpressions in SQL(...) added for base data types;
  • Fixes:
    • {DB}/Table/SQL: in expressions used in queries operations AND/OR could not work;
    • {DB}/SQL: Operation << in statements like e.g. Db << SELECT ... could not be used still parameters of functions are read-only always;

April, 23, 2021 - version: 1.7.7

  • Changes:
    • {Separator}: simple and efficient code added to prevent breaking a splitter out of a form;
    • {Forms}: two new variants of controls layouts on a column: 'CONTROLS_TOP_TO_BOTTOM', 'CONTROLS_VERTICAL_2|_COLUMNS' (to work also in horizontal columns);
    • FPC/{DB}: connection with MS SQL from the Linux (via unixodbc) tested: it works;
  • Fixes:
    • FPC/Linux: while calling an application from the AL-IV code, all the parameters returned as a single parameter (classic Pascal/Delphi functions ParamStr(n) and ParamCount did not work), fixed adding parsing that string onto separate parameters;

April, 19, 2021 - version: 1.7.6

  • Changes:
    • The function added: {Form}.Set_default_font|_for_all_forms_created_later({Screen}, STR Face, REAL Size); (call it just after creating of the {Screen} object, in the function Main);
  • Fixes:
    • Visual library + IDE/Designer: still on some target platforms (KOL) the "natural" columns aligning is used, the visual order of columns while aligning (by the {Form} code) to provide the same result on all platforms. This affects only columns aligned 'RIGHT' and 'BOTTOM' (and this actually considerably when there are several such columns on a form);
    • Delphi/VCL: when the size of {Paintbox}+ control changed its inner box (used as drawing canvas) did not change sometimes;
    • Delphi/VCL: The event {Form}.shown called also when the form became hidden;
    • Delphi/VCL, KOL: when a modal dialog was closing by the X on the window, then its parent form could not be closed with the Close method (supposing the child dialog still active);

April, 18, 2021 - version: 1.7.5

  • Changes:
    • Visual library: a capability implemented to use a column as a splitter for other (neighbour) columns (depending on that column alignment 'TOP'/'BOTTOM' or 'LEFT'/'RIGHT' size of a neighbour column with similar alignment is changed by mouse dragging); In case of using IDE/Designer it is enough to set a flag "Is splitter" and in case of manual coding a form constructor it is necessary to add the {Separator} class control on it (reworked);
  • Fixes:
    • The compiler sometimes used for internal purposes variables named temp1, temp2, etc. In result, if such names were used in code this led to a naming conflict;
    • C#, Delphi/FPC: code generating fixed for case of assignment a new object to a pseudo-variable NONE (and there are there assignments to fields of the object created);
    • Delphi/VCL, Free Pascal/Windows, Linux: setting the mouse cursor shape for a {Paintbox}+ control fixed;
    • Delphi/KOL: with options /$SMALLER_CODE, /$SMALLEST_CODE visual applications did not work;

April, 16, 2021 - version: 1.7.4

  • Changes:
    • IDEAL4/Designer: a capability implemented not to assign a name to a control (e.g. to a label). In such case code is generating looking like NONE = New_label(...);
    • IDEAL4/Instant code: a pattern was added for the TABLE declaration, a pattern was improved for the STRUCTURE;
  • Fixes:
    • C# {Long_operation} - an error of type conversion fixed in the native low level code;
    • IDEAL4/Designer: positioning of columns aligned 'TOP'/'BOTTOM' in case when there are nested columns on the form with similar aligning direction;
    • IDE/Designer: updating a component declaration while editing its name in the Designer fixed;
    • Optimizations via inline insertions of functions body: while copying expressions containing functions, references to that functions did not add to internal arrays of references to called functions which could lead to remove such functions in some cases.

April, 15, 2021 - version: 1.7.3

  • Changes:
    • Better using the sugar (A.x, .y+1) in the same expression allowed: a field item can now be an operand of an expression, not only an entire expression;
    • In addition to class attributes [SYNTAX='PASCAL', LANGUAGE="EN"] another new attribute added: [ENCODING='ASCII']. It allows to load and use elder Pascal units without manual converting those to the UTF8;
    • In any string concatenation operations in TEST functions, and also in cases of concatenations only starting from a string constant literal, it is allowed to convert data types implicitly from other types to STR if a function S|tr accepting such data type operand is available in the scope, not only for the << statement;
    • The class {Long_int} was added which implements the structure {long|_integer} together with the basic set of arithmetic operations and necessary functions to compensate an absence of the such type as "long integer" in the AL-IV language;
  • Fixes:
    • {Form}.new_column : if there was a column without an alias on a form, then any other created column became "nested" in the column without alias making form exterior strange suddenly;
    • Linux: calling Test_reports (required en extension .exe in the executable file name);
    • Delphi/VCL: for {Form} in some cases adjustment of controls was not called;
    • Gcc: bitwise shift right operation ShiftR was implemented incorrectly using arithmetic shift instead of logical;

April, 11, 2021 - version: 1.7.2

  • Changes:
    • {Gif} + {Lzw} : decoding gif images speeded up;
  • Fixes:
    • C#: generating code for the /$PROFILER;
    • Delphi/FPC: generating code for unrolling FOR loops (UNROLL modifier);

April, 8, 2021 - version: 1.7.1a

  • Changes:
    • FPC + STR: working with symbols of a string in backward direction also optimized;
  • Fixes:
    • FPC + optimizations (INLINE) + Str inner type - fixed not initializing inlined variables;

April, 7, 2021 - version: 1.7.1

  • Changes:
    • C#: If the system supports high precision timers and the class {High_precision_time} is included, then the profiler for loops, functions and branches collects not just counters but time wasted for those code blocks executions (approximate, certainly);
    • If a class is imported with both modifiers DEBUG and ANYTIME, then this means now that in the debug mode it is included anyway (even if the optimizer does not want it), but in other way it is ignored totally (for the class there it is imported):
      IMPORT, DEBUG, ANYWAY: {High_precision_time} .
    • Free Pascal/UTF8: A special inner class Str added and the code generation was changed a lot for FPC: all the scalar string local variables except function parameters and results as well as all the class and objects fields moved to that Str type. This speeded up working with strings a lot (even the compiler speed under Linux);
  • Fixes:
    • FPC: {Png}.From_file without the BGRABITMAP_CANVAS option on;




April, 4, 2021 - version: 1.7.0

  • Changes:
    • The function {System_functions}.Profiler_save_reset added which saves collected counters nullifying them all. This function can be called from your code and results can be analyzed on a given (by your conditions) portion of executing, not only on results of entire application working time;
    • Changes in the language: the operation LIKE to compare two strings added: it works like in T-SQL but comparing two string operands, without case sensitivity, and allowing special pattern symbols '?' and '%' in the second operand, e.g. RESULT = my_string LIKE "AB?d%"
    • SQL: the relation LIKE was added in T-SQL expressions. E.g.:
      Db << SELECT FROM city, (*), WHERE CountryCode LIKE 'U%'
    • Compiler: CCC (Cache compiled code) is not used if saved attributes of compiling are different (/debug /final /op);
  • Updates:
    • Color Commander (speed up even more on results of the Profiler works, copies files now faster a lot, versions for Delphi/Free Pascal fixed - these just frozen on copy files);
  • Fixes:
    • Delphi/Free Pascal: working with threads fixed (this was not a good idea to use the threadvar declaration for All_threads some versions ago);




April, 2, 2021 - version: 1.6.9

  • Changes:
    • C#/Delphi/FPC/KOL: Support added for MS SQL (class {MSSQL}) to work from Windows -- for Delphi/KOL and FPC - only via ODBC / Direct-ODBC, for C# and Delphi/VCL it is possible also to work via Ado (Ole DB);
    • C#: compiling parameter /$x64 added allowing to create 64 bit applications;
    • C#/Delphi/FPC: Postgre SQL DB support added (the {Postgre} class) which can work either via DSN or with direct selver/database specified. For now, it works for Windows only;
    • C#/Delphi/FPC: mysql databases support added (th {MySQL} class), also via ODBC (and for now, only in Windows);
  • Updates:
    • Color Commander (speed up on results of the Profiler works, copies files now faster a lot);
    • Tools\Visual_profiler_analyzer (speed up on results of working - Refresh command for large data arrays was working too long time ==> for the {Listbox}.Set_text form layout suspending added);



March, 31, 2021 - version: 1.6.8

  • Changes:
    • The small console utility application added: Tools\Profiler_report which sorts the profiler data (by counters values) simplifying problems detection;
    • The visual utility added: Tools\Profiler_report\Analyzer which shows both set of counters grouped by classes and sorted by counter values, and opens the interested line of code in the IDE AL4 (the IDE also updated);
    • {Form}: The function added: Set_autoscroll|_for_all_forms_created_later, by default auto-scrolling is not adding to desktop applications (be more carefully, this affects only C# version, other platforms do not support auto-scrolling forms / columns except the Android - but the last case is very special at all);
  • Fixes:
    • Delphi: generating a large code with the option /$PROFILER=ALL could lead to the error message (too many local constants in a procedure);
  • Updates:
    • IDE AL4:
      • Scrolling and drawing was speed up on results of the profiler work;



March, 28, 2021 - version: 1.6.7

  • Changes:
    • C#/Delphi/FPC: The option /$PROFILER added: if it is present, on the end of work of an application, all CNT_ counters are saved to the file profiler_data.txt (grouped by classes); the option can be in form /$PROFILER=nnn where nnn can be one of FUNCTIONS, COMMENTS, LOOPS, BRANCHES, ALL (only the 1st letter is considered);

March, 26, 2021 - new version: 1.6.6

  • Changes:
    • Important: The keyword FOREVER removed and should be replaced with
      FOR, INFINITE: code ;
      It works exactly as the FOREVER worked before: it is not allowed to use BREAK / CONTINUE, return is available only with the ==> operator or by an exception;
    • Important: For embedded functions RotateL || Rotate_Left and RotateR || Rotate_right semantics of parameters was changed: now the second parameter means the amount of bits involved into the operation, and the rotation is always done onto 1 bit (in the minor part of the source number, which size is given by the second parameter, other bits are not touched).
  • Fixes:
    • Gcc: compiling projects (non-visual) with C++ usign g++ restored, at least in Windows (together with a capability to open resulting projects in the MS Visual Studio 2010+ and compiling / debugging in it);

March, 24, 2021 - version: 1.6.5

  • Changes:
    • {Localize_str}: automatic removing translations which are not used more (did not found while saving base dictionary). Deleting occur only if there are any changes in the base dictionary. Not used sections are not deleted but marked with the comment with the date&time where these were detected not used (in different configurations of an application, it is possible that some different classes are used which are not used in other platforms but there are sections corresponding to them in the .lng file).
  • Fixes:
    • C#: working {Long_operation} fixed (did not work);
    • Delphi: try-finally block did not generate for the PUSH statement having ==> (return) in its body. This was a temporary solution for problems compiling code in Delphi/FPC, a time went to fix this another way; Also the problem is fixed for CONTINUE / BREAK statements jumping over PUSH bounds;
  • Updates:
    • IDE AL4:
      • Designer: restoring Title property ({Dalog_file}, {Dialog_dir});
      • Designer: generating code for long sting values like x = "string" (e.g., Filter in {Dialog_file}): the string did not split while generating;
    • Diagram draw:


      • more natural resizing for the LINE, together with drawing selection markers on it;
      • after auto-loading the last file, in the save dialog, the file name was not typed, and doubled extension appeared;
      • now, when file is saved, its auto-saved version on disk is deleted;

March, 22, 2021 - version: 1.6.4

  • Changes:
    • Syntax sugar added: if in a single statement two sequential expressions are accessing fields of the same base object, then all the following accesses could be in form .Field, without other (same) symbols. E.g.:
      m = mouse.Offset(-Paintbox1.Bounds.Loc.X, -.Y);
  • Updates:
    • IDE AL4:
      • an indication of selected words in the text added at the right side to the vertical border line, together with a thumb showing current page position in the text;
      • Some other improvements and small fixes in the Instant code mode implementation;

March, 21, 2021 - version: 1.6.3

  • Fixes:
    • Delphi: generating code accessing an item of an array via an index which itself is an item of an array (A = B[C[i]]);
    • Compiling embedded functions with capitalized names (CLEAR, INDEX, etc.)
  • Updates:
    • IDE AL4:
      • special code input mode added: Instant code with inserting a prepare code pattern after entering a keyword and a space character, e.g.:
        CODE $condition ? $statement
        ELSE $statement ;
        (all the items starting with the "$" are disappearing automatically when you start editing on them, it is possible to use LEFT/RIGHT arrow keys to jump between them quickly, and there are some additional possibilities such as removing untouched ELSE branch by the Delete key when the caret is at the end of the previous line in code); the Instant code mode easily can be turned off (Ctrl-T) or on (Ctrl-I);
      • fixes in Find text operation;

March, 18, 2021 - version: 1.6.2

  • Fixes:
    • Additional fixes on $CCC;
    • C#: generating code accessing an item of an array via an index which itself is an item of an array (A = B[C[i]]);
  • Updates:
    • IDE AL4:
      • indexes on classes added (File | Index classes) for sources in certain directories (with subdirectories), showing hints on parameters of functions which classes did not loaded into IDE;
      • tracking of changes in a line added, with a suggestion (shown in the bottom of the editor) to press CTRL+R (in such case the Replace text dialog is shown but with parameters prepared on base of changes made in the line);
      • duplicating bookmarks set in the source added on the top panel to show which bookmarks are already set and to allow to jump there using mouse;
      • it is now possible to change the bottom panel size using mouse drag;
      • Form Designer: it is now possible to drag selected controls onto empty columns, too;

March, 15, 2021 - version: 1.6.1

  • Fixes:
    • Fixes on $CCC on base of first experiences on working on real projects (there were required to save/restore additional options, set additional properties for variables/constants while compiling/loading CCC files etc.);
    • Some fixes on using symbols BGRABITMAP, BGRABITMAP_CANVAS;
  • Updates:
    • IDE AL4: lines added connecting branches of CASE statements; better algorithm used to draw lines indicating block levels in PAS files;
    • Color commander: a queue (of 2) active and queued processes provided (as two buttons at the right side of the space not occupied by the files table). Also: a fix for RAR archives having paroled filenames (could not be deleted still a hidden RAR process did not finish);

March, 6, 2021 - version: 1.6.0

  • Changes:
    • FPC: A conditional compiling symbol added BGRABITMAP_CANVAS. Without it, when only BGRABITMAP is set (by the option /$BGRABITMAP), such library is used only to load images, thereas drawing uses standard TBitmap (this seems working faster, at least in Windows);
    • AL-IV: It is allowed to not specify the NEW modified for a function if a new object assigned to the RESULT variable has an owner (defined there bu the OWNED BY construction in code) or added to an array of objects (the >> A[] construction at the right side);
    • Colors added to console output for the primary version of the compiler, so compiling the main C# compiler (CSharpBuild) now done with colors;
    • C#, Delphi/FPC: by default, new feature added (with the key /$CCC=yes): class compiling results saved in files with extension .ccc (Cache Compiled Code) and in case when the source of a class was not changed and imported classes too were not changed for that class, it is not re-compiled but just re-loaded from a ccc file (which usually is faster). Other options are: $CCC=no, $CCC=save, $CCC=load. The option is new and is on tests. Add the key $CCC=no in case of problems.
  • Fixes:
    • Delphi/FPC: specifying more then 1 conditional compilation symbol in the parameter /$DEFINE=x,y (via comma);

February, 16, 2021 - version: 1.5.7a

  • Changes:
    • FPC: New version of the FPC 3.2.0 + Lazarus 2.0.10 + BGRABitmap 11.3.1 tested (in Windows and Linux). These versions are found fully compatible with entire code created (though some selected applications were tested). It is just required to specify correctly system variables $LAZARUS_HOME, $BGRABITMAP_UNITS - in Linux, and correct path to the fpc in the environment variable Path in Windows (and also fix paths to the FPC in Linux in the _FPC_build_linux_Lazarus.options file);
  • Fixes:
    • FPC: the problem with mouse wheel scrolling fixed;

February, 16, 2021 - version: 1.5.7

  • Changes:
    • IDE AL4 / Designer + {Form}: it is allowed to have several different layouts for a form with the same (or slightly different if necessary) set of controls created in different order, layout and with different parameters depending on a result of the overridden event method variant_layout;
  • Fixes:
    • C#: after calling menu it was necessary to call manually the Invalidate method for all the {Paintbox} (and plus) controls which could be covered with the menu opened. Now all the painting controls are updated automatically;

February, 8, 2021 - version: 1.5.6

  • Changes:
    • Compiler: It is not allowed in the left side of an assignment to use as the target variable name a variant of a local variable name which is matching to the name of a class field (e.g. if we have the local variable w|hat_found and the field what_found|_in_text, then it is not allowed to assign a value using the name what_found, but w can be used there). The variable type is not essential for the rule;
    • IDE AL4: it is allowed to use Ctrl+LMB to jump to a word definition (labels, variables, functions etc.) - same as Ctrl+Enter. Plus, other improvements in the interface;
    • Color Commander: updated to version 0.33;
    • {Form}: rules for "nested" columns are clarified: it is allowed to have such columns with aligning TOP/LEFT/RIGHT/BOTTOM relative to the "parent" column which aligning should not be parallel; and also: when there are several client aligned columns, the only single such column is showing (the first returned FALSE in the form event column_hidden);
    • IDE/Designer:
      • some changes in view columns and calculating their sizes at design time;
      • Changes in columns showing and aligning rules are taken into account (the first client aligned column is placed on the form, all another client aligned columns are placed from the right bound of the form scheme);
      • Additional view mode added: scheme of columns,
      • hatching added for controls which can be hidden or / and disabled;
  • Fixes:
    • IDE/Designer: {Tray} control generating fixed. The last parameter now (path to tray icon is just set from the text from the Value field in the Designer (so, it is possible to type there a name of a function returning such path, for example);
    • IDE/Designer: recognizing new_column fixed for case when the statement is occupying several lines of code;
    • Delphi/VCL: order of mouse double click event generating changed from mouse down - up - double-click - down - up to mouse down - up - down - double-click - up;

January, 28, 2021 - version: 1.5.5

  • Changes:
    • Delphi: New option added /$SCLASS == /$STRUCTUREASCLASS (all the structures are translated to classes rather then RECORDs event having simple fields only) - this option is necessary as technical, to implement the interpreter;
    • Delphi: New option /$RTTIONLY={Class1},{Class2},... was added which allows to economy up to 20 Kbytes of executable size (RTTI is generated only for specified classes);
    • IDE AL4/Designer: automatic generation of code like CASE sender_alias ? [...]: ... ; in event handlers while creating those and jumping there from the Designer's form menu "Events".
          Aliases are added only for appropriate controls which can be handled by certain event handler (e.g. the paint event is appropriate for {Paintbox} or {Paint_lines});
    • IDE Designer: double click on a control on the form drawn jumps not just to the first event with the control clicked but cycles between all such events (recognizing the control by its Alias in the code);
    • Output statement (<<): for all the concatenating expressions, which are not strings, the compiler tries to find a function Str from the scope (or system functions). I.e. now it is possible to write:
      and this will be correctly compiled though there are no there ':', '<<' and an explicit conversion to STR type as in the "correct" version:
      DEBUG: << "A=" A.S #NL ;
    • {Form}: for columns aligned 'TOP'/'BOTTOM', a "property" was added {controls_layout}: 'CONTROLS_LEFT', 'CONTROLS_RIGHT', 'CONTROLS_CENTER',

January, 24, 2021 - version: 1.5.4

  • Changes:
    • Color Commander changed to version 0.31 (added: preview archives top level content, better working in Linux, convering colors to HSL used for better colors set in the Dark color theme);
    • {Form}: events key_down and key_up fired only once now for a key press: if there is no a control with a focus, the sender == NONE and sender_alias == "" (so sender is the form itself); The previous version, when the single key press could be handled twice - from the form and from the focused control, could lead to chaos and worked very various waus on different target platforms, making it hard to create multi-platform apps;
    • {Paint_table} --> {Form}.Get_info : instead of setting the Current_line, now the field .Drawing.Item (of a {Paint_table} object) is set before calling the Get_info event to get a virtual table item row (in previous case, Set_current_line led to multiple nesting calls of adjustment functions and to flickering of a form on the screen);
    • {Form}: in columns aligned 'TOP' / 'BOTTOM', if the last item has the flag Anchor_bottom|_right set, then it is automatically extended to the right side of the parent column;
    • {Form}: moving or resizing a form does not (and should not) lead to calls of Any_change: size and location of a form on screen should not affect controls state such as Checked, Text, Hidden and others in most cases. If therefore it is necessary to do so, then it is always possible to call the Any_change method (but it is better to do this not in the resize event but to delay a bit may be using timer);
  • Fixes:
    • Compiling overloaded functions (having multiple type parameters like {INT, REAL, {complex}}) do not differ by the first parameter type, the decision which variant to use is delayed until scanning other parameters (otherwise there was compiling error there). In case of different first parameter types, certain overloaded version is selected immediately;

January, 17, 2021 - version: 1.5.3

  • Changes:
    • Color Commander changed to version 0.30 (added: searching files, preview text - with selecting/copying selected to the clipboard, and image files of most popular formats, view directory tree as color blocks with info on sizes).
    • Delphi: $INCREMENTAL option abandoned for a time (supporting it very hard, and it solves very thin class of task which I believe to solve a bit later and only for Delphi+Windows, with a multiplatform AL-IN|terpreter);
    • AL-IV: if a filed has both modifiers INIT and READ, then it is therefore allowed to use the standard object constructor object={Type}(...), initializing all such fields (but these fields become unavailable to modify it later except in descendant or friendly classes as usual for read-only fields);
  • Fixes:
    • IDE/Designer: entering multi-line text foxed (earlier, the caret always moved to the first line);
    • FPC/{Form}: in the inner event Form_shown, the event Form_resize also is called (otherwise there were no calls to {Form}.resize until the first manual resize of a form);
    • AL-IV: calling overloaded functions fixed with the first parameter which is a STRUCTURE (e.g. A.S, where A is a STRUCTURE e.g. {rect});

January, 12, 2021 - version: 1.5.2

  • Changes:
  • Fixes:
    • Delphi/VCL: automatic width sizing is implemented for the {Checkbox} on a column aligned 'TOP'/'BOTTOM';
    • Compiler/Optimizations: some problems found for the optimization 'V5' (merging same type local variables). It is turned off until solve;
    • Delphi/FPC: MIN_INT corrected to $8000_0000;
    • FPC: in case of integer constants having 31th bit set the compiler could not compile code;
    • Delphi/KOL: in case if symbol PAS_ONLY switched on, the function Extended2Str works incorrectly: the corrected code with the bug fixed is included into AL4.pas;
    • Delphi+FPC: any unstable working problems seems (I believe) fixed finally for the {Thread}: protecting of common variables added (using critical sections), and the list of threads (global variable) was declared as the threadvar. This last should minimize (to 0) a possibility of a mutual influence of threads of different levels in a creation tree;
    • Delphi/VCL+KOL: {Text_file}.Load fixed for case of UTF8 texts (even if the Encoding was set to 'UTF8', auto-detected 'ASCII' was using);
    • IDE/Designer: generating of a class {Ex_...} for a form fixed (it contains 4 generated functions to save and restore form state, including filled in fields to/from a structure {ex_...} correspondent and generated for the form, and to save and restore form state in/from a configuration, in a specified branch). In the function getting a form state from a configuration, now disabled capability was used: updating fields of a structure variable passed as a parameter. Now, it returns the structure {ex_...} as a RESULT;

January, 7, 2021 - version: 1.5.1

  • Changes:
    • IDE AL4/Designer: {Paint_tree} support added;
    • Another application created with the AL-IV is published: Color Commander; Now it is running (and mostly functioning) in Windows and Linux and can be compiled and launched in Android;
    • A gallery of the most interesting applications made with the AL-IV is published on the main page of the AL-IV.
  • Fixes:
    • FPC: Compiling under Linux (Lazarus/x86) tested;
    • FPC/Linux: functions {Form}.Get_active crashed when there was no any active control - fixed;
    • FPC/Linux: {Dialog_dir} + {Tray} are fixed (reference to the AL-IV control from the native control was stored in Tag converting it from Pointer to Integer rather then to IntPtr);
    • FPC: {Dialog}.Show_modal(parent_form) fixed (due a very annoying typo in the native code an exception occurred);
    • FPC: typing in edit controls fixed (handling keyboard keys assigning key to 0 value to prevent further handling for handled keys led to stop passing these to controls, in contrast to Delphi VCL / KOL);
    • FPC/Linux: {File_path}.Delete_file, Recycle fixed;


Previous versions history (2020)

See here

Previous versions history (2019)

See here


Previous versions history (2018)

See here


Previous versions history (2016-2017)

See here