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


AL-IV:    Versions history

January, 20, 2023 - new version: 2.7.3

  • Changes:
    • Color Commander updated (to version 0.64);
    • Zoomer6 updated (version 6.0.2);
  • Fixes:
    • C#, {AL4_form}: mouse/keyboard events are blocked only in cases of nested mouse/keyboard events, not in result of any nested event handling;
    • C#, {AL_form}: Item_click handler could work incorrectly (handled on form close);
    • Delphi/FPC: {System_functions}.Application_name returned a path to the directory with an application executable rather then name of the executable;
    • FPC: Russian text in console (code page 65002 required rather then 65001);

January, 13, 2023 - version: 2.7.2

  • Changes:
    • Color Commander updated;
  • Fixes:
    • {Paint_lines}: setting line height was done too often;
    • C#, {NATIVE_DB|_ODBC...}: did not compile, fixed for case when the /int32 key is not used;
    • Delphi+KOL: compiling fixed for case of the key /$NOEXCEPTIONS;
    • Single line CASE ... ? ... ELSE ... ; did not compile;
    • IDE: drawing lines around blocks restored (did not draw in cases when the end was below the view area of text);

December, 29, 2022 - version: 2.7.1

  • Changes:
    • Zoomer6 - updated;
  • Fixes:
    • C#: Red-X {Paintbox} problem solved (thanks to Lazy Evaluation Ltd solution);
    • C# {AL4_form}, {AL4_drawing}: internal exceptions handling improved (the nesting level of event handlers did not restore, so click events stopped working even in cases of successfully handled technical exceptions);
    • KOL: Compiling;

December, 28, 2022 - version: 2.7.0

  • Changes:
    • A group of block statements LIMIT added:
      LIMIT LOOPS(nn) : ... ;
      LIMIT FUN(nn): ... ;
      which restrict time / amount of loops iterations / function calls in a block;
    • Additions and fixes in the language specification;
  • Fixes:
    • Java: Compiling for Android;

December, 11, 2022 - version: 2.6.1

  • Changes:
    • Single line statement allowed:
      CASE condition ? operator ELSE operator ;
    • Additions and fixes in the language specification;
  • Fixes:
    • Compiling overridden functions:


      • skipping of branches not corresponding to a selected types signature, implemented now more correct way;
      • the requirement abandoned to write {{ and }} without intermediate spaces only (in CASE ? {{ ... ... ; statement branches);

December, 5, 2022 - version: 2.6.0b

  • Changes:
    • Documentation changed in correspondence of recent changes + mistypes fixed;
  • Fixes:
    • Delphi/KOL: operation >> could return the previous string if the user did not enter new symbols and just pressed the Enter;
    • C#: code generating for accessing items of arrays of integer constants;

December, 3-4, 2022 - version: 2.6.0a

  • Changes:
    • C#/Delphi: all the integer fields and variables (except FOR loop counters) now are translated to 64 bit integers. The compiler key /int32 added to revert this backward. Two modifiers for classes was added: INT64 REQUIRED and INT64 DESIRED: if required and /int32 is in options, this treated as an error; if desired: as a warning;

      only Delphi/FPC: variables and fields with the INDEXING attributes always are 32 bit Integer, too;

      Constants MIN_INT and MAX_INT | EGER_32_VALUE still have values corresponding to bounding values of the 32 bit Integer;
  • Fixes:
    • C#: MIN_INT constant value fixed;
    • C#: generating of the system function call RotateL / RotateR fixed;
    • Delphi/KOL: {Canvas}.Measure - {AL4_drawing}.String_measure - incorrect negative font size using fixed;

November, 30, 2022 - version: 2.5.3

  • Changes:
    • Compiling with options in a common options file (specifying a section by the parameter /[section]): it is now possible to move same options from different sections to the section [Common];
  • Fixes:
    • Report leaks: a project using national units could be compiled incorrectly (e.g., Test_projects\Russian_code);
    • Compiler: using named constants in fields initializators - constants could be refused to be calculated due casching the current line length in the object {Text_parser}; this was fixed resetting the cache before calculating a constant;
    • {Paint_table}: in result of the event mouse_double_click mouse logical down state did not released so on return of the mouse cursor into form lines continued selecting (e.g. after closing a modal dialog called by the double-click); 

November, 24, 2022 - version: 2.5.2

  • Changes:
    • Compiling shortened function version: a requirement added to use the function CLONE if a variable, field or an array item is returned (of the correspondent structure type);
    • Compiler now disables comparison operation == / != between two structural values;
  • Fixes:
    • Compiling OVERRIDE (overridden) methods having the PUSH identifier: the error was fired incorrectly about inappropriate methods order;
    • Compiling of an assignment of the NONE object (in an initialization of fields of an objects created with the construction {Type}(Field1=..., FieldN=NONE, ...)
      - the type of the destination field did not take into account, in result the NONE object of the class {Object} (base to all the classes) was assigning.
      - And still it has no specific fields / methods, later usage of such filed could lead to low level errors;
    • Delphi/{Form}: automatic resizing controls could set its size to zero (now Set_control_size ignores 0 values for Width and Height parameters);
    • Compiler: function returning a structure or an object of a class but not having a body - a NNOE object of the type {Object} was returning actually (then, in result of the optimization, this could lead to attempts to access inappropriate fields of a NONE object of an incorrect data type);
    • Android: accessing items of constant arrays fixed;
    • Delphi/C#/Android: code was incorrectly generated for FOR arrays on constant arrays (FOR x IN C[] : ...; / FOR x IN C[a TO/DOWNTO b] : ... ;)

November, 11, 2022 - version: 2.5.1

  • Changes:
    • Compiler: the absence of branches (other then ELSE) for a CASE statement with a non-Boolean condition is accounting as an error;
    • Compiling shortened functions FUN f(...)==>{t} := expression . :
      • It is not allowed to use the shortened version if the expression is an object construction {type}(field1=..., field2=..., ...) of another (even derived) type then the function result;
      • Checking the NEW modifier presence added for such functions returning an object of classes;
    • Compiling structures reusing other structures (LIKE {type}) from another classes: allowed but in case of cyclic references leads to error messages from the compiler;
  • Fixes:
    • Delphi(VCL)+FPC: setting foreground color for {Label} control before showing a form (KOL: the same problem but it is not planning to fix this);
    • Android/Java: compiling of projects restored (enough functions added in,;

November, 1, 2022 - version: 2.5.0

  • Changes:
    • IDE: small optimizations and improvements (Report Editor);
    • Compiler: names of classes imported are checking for exact matching of at least one of its names to the pattern specified (so, classes {MAin} and {Main} are not matching);
  • Fixes:
    • {Report} + {Printer}: small fixes;
    • Delphi/KOL + {Form}: small fixes;

October, 20, 2022 - version: 2.4.9a

  • Changes:
    • IDE: small optimizations (Report Editor, Form Designer);
  • Fixes:
    • The flag {Report}.Scale_down did not work (incorrect loop condition);
    • IDE/Report editopr: setting Scale_down, Scale_up values from the visual report editor did not work;
    • {Report}.Resize, Resize_to_fit did not work (forgotten back assigning a structure with now Bounds value);

October, 19, 2022 - version: 2.4.9

  • Changes:
    • IDE: small optimizations (Report Editor);
  • Fixes:
    • {Report}.Generate worked incorrectly in cases when the target Canvas did not assign (the Destination method did not call). The problem was fixed by using in such case of an object of the class {Bitmap}.

October, 12, 2022 - version: 2.4.8

  • Changes:
    • IDE: hints were added for fields of classes and structures in constructors {type}(...); other small improvements;
  • Fixes:
    • C#: generating code for the delete operation for an item of an array of structures;
    • IDE/Designer: saving / restoring values of multi-lined controls (like {Combo}), generating code of the CONSTRUCT for some controls with empty string parameters;

September, 30, 2022 - version: 2.4.7

  • Changes:
    • IDE + Reports Designer: improvements; also, it now works for all the classed based on a class which name is starting from the string "{Report": so it is possible to inherit your own {Reports_all} and then to derive several other classes from it and use the Reports Designer to edit them visually;
    • {Printer} + {Report}: scaling added, range of pages added;
  • Fixes:
    • Delphi: code generation for accessing an item of an array of structures;
    • {Printer} + {Report}: printing with the orientation Landscape=TRUE, calculating a band rectangle (Band_rect);

September, 21, 2022 - version: 2.4.6a

  • Fixes:
    • C#, Delphi: working with structures (assigning to an item of an array: .Clone() was not adding);
    • IDE: Report_editor - fixed and improved;

September, 20, 2022 - version: 2.4.6

  • Changes:
    • Delphi VCL + {DB}: it is now possible to use ODBC connections via kolodbc.pas, the instruction is in new class {NATIVE_DB|_Delphi_KOLODBC_to_use_with_VCL} (this is actual still ADO has an bug which prevents reading too big numeric values from databases leading to an exception 'BCD overflow');
    • Delphi/VCL: more compact code for All_classes.pas (in case when it is larger then 64K lines, the Delphi32 debugger is turned into pumpkin);
    • {Long_operation}: some changes in the implementation of the class: less dependence from a form which were active while the {Long_operation} form was shown, and auto-hiding provided on any event handler ending;
    • C#, Delphi/FPC: inner mechanics of life time control of structures implemented via objects changed so their usage counter actually no more used until a structure instance is destroyed;
  • Fixes:
    • Delphi VCL + {Dialog}: calling ready("result") did not close the dialog if called not in result of user action like button click or keyboard key press (for example, called from a timer event);
    • Delphi VCL + {Canvas}: offset / rotate / scale transformations fixed (the VCL OnPaint handler was resetting canvas mode to GM_COMPATIBLE);

September, 14, 2022 - version: 2.4.5

  • Changes:
    • Documentation on the language revised and corrected, and descriptions added for generic functions, .[]-methods and some mistypes fixed;
  • Fixes:
    • C#,Delphi: incorrect code generated for assignment of a an object which is a result of a function to an object (scalar) variable: usage counter was increased one time more then necessary;
    • KOL: errors in the native code;

September, 6, 2022 - version: 2.4.4

  • Changes:
    • Warnings added on block comments marked as REUSED, which actually are not referenced later in LIKE / REVERT statements;
    • Warnings added on function parameters which declared as dynmic arrays but actually it is enough to use fixed arrays. For cases when the warning is wrong it is possible to add a substring DYN (in any case) to remove such warning on the parameter;
    • The DONE statement decreases nesting level of block statements like the FOR statement would already ended;
    • {Paint_table}: handling mouse move events improved to handle more lost mouse events;
    • {Control}.Suspend / .resume, for the {Paintbox}+ additional suspension provided;
    • {Form_common}, {Dialog_common}:
      • {Paint_lines}+ : focus frame drawn on the control bounds;
      • {Paint_table}: if the header is shown, the focus frame is replaced with recoloring of the header background;
  • Fixes:
    • {File_path}.Rename|_file could delete file instead of renaming it if the destination file name differenced from the original name by only case of (some) letters;
    • C#: code generation: for NONE-objects simple fields ( of types INT, BYTE, BOOL, STR, ENUM now initialized by zeroes independently if initializations present tfor them (as it should be);
    • FPC, {Form}: setting form sizes before showing the window did not work;
    • Delphi: with the /op[timizations] +on, code generattion for FOR loops could give bad code which could not be compiled;


August, 30, 2022 - new version: 2.4.3

  • Changes:
    • IDE AL4: small changes (optimizing undo, tabs numbers in the menu on tabs, events grouping in the menu of the forms Designe);
    • Color Commander: small changes (even more colored, Details form added to the Copy/Move dialog - allows to control the operation queue);
    • Portable Notes: small improvements (absolute windows coordinates, the single instance);
    • Zoomer6: small changes (smoother scrolling with less amount of artefacts);
    • {Form}.Set_position 'KEEP_ON_SCREEN' - in Windows the taskbar position now is taken into account not allowing to intersect it (including the secondary screen taskbar in the Windows 10)
  • Fixes:
    • IDE AL4: opening recently closed did not work, problems drawing changes markers on the left side of the editor;


August, 19, 2022 - version: 2.4.2

  • Changes:
    • IDE AL4: visual selecting of html tags added and some other options to work with html (highlighting closing tags, selecting blocks of yags, jumping between starting and ending tags, entering new tags etc.);
    • An application Tools\Html_tools added allowing to re-format html file to make it more convenient to edit manually (removing rubbish span lang tags, auto-indentation);
  • Fixes:
    • IDE AL4: autosaving did not work while typing, fixed now;
    • C#, {Process}.Ended returned FALSE for non-existing perocess;


August, 9, 2022 - version: 2.4.1

  • Changes:
    • In the loop on an array of structures, the variable (representing an item of the looping array) now can be used at the left side of an assignment statement (e.g. to change value of its field), or in a separate statement like function call (where the variable is passed as the first (prefix) parameter, or its field is representing an object which method is calling. Earlier, such usage was implemented only for variables in the right side of assignments and '<<' statements;
    • To shorten code in expressions like
      it is now possible to write just
      including cases of system functions (earlier, it was possible to short code such way only for fields and usual functions);
  • Fixes:
    • {Form}.Show/Linux: form did not activate if another form was active before;
    • C#: due to a known bag in.Net while handling key combinations like Control+letter, when some text box was in focus, a sound was fired (exclamation), independently of RESULT returned by the key_down handler; Now, if 'DECLINE' value is returned, then further key handling is stopped and the text box does not receive the key combination which could not be handled correctly;
      ATTENTION! Some applications can stop working with keyboard if contain code which returns 'DECLINE' incorrectly in the key_down event. Do it only to prevent further key_press event calls, when the key passed was really handled in the key_down event handler;
    • Linux + {Form}.Width +.Height, .Bounds: form sizes returned incorrectly calculated because of strange decision of Lazarus developers just to return ClientWidth and ClientHeight instead of Width and Height;
      In new version, reading and writing form bounds are correct both in Windows and Linux, but the form should already be shown on the screen (but not only the event {Form}.shown was called - this is not enough in the case: use a timer tick after the <<shown>> event, at least 100 msec, to ensure that the form is already visible on screen);
    • FPC: the exception Access Violation was fired in some native code (in AL4_form.pas) while working with Str class objects replacing String in the AL-IV implementation;
      Problems were fixed in the key_press event handler and in the function Set_form_column_font;

August, 1, 2022 - version: 2.4.0a

  • Changes:
    • {Paint_tables}: text shadow drawing order changed to normal: 1st the shadow is drawn, then the text itself;
  • Fixes:
    • {Form}.Make_tool_window:
      • In the classic theme (Windows 7 and below) small thin line between the form header and the other part of form did not redraw;
      • in modern version header size (height) did not change;
      • restoring code did not finished (for the parameter Yes=FALSE);
      • code was not written for KOL version;

July, 28, 2022 - version: 2.4.0

  • Changes:
    • C#/{Form}: the field BOOL {Form}.Do_not_close added which been set to true prevents the system from shutdown. But it works only after returning the RESULT='DECLINE' in the <<closing>> event, otherwise the application is closed normally as usual;
      As a result, applications compiled via C# no more prevent the system from shutdown/restart - without any changes in code, just after recompile them (problems were with forms having the 'closing' event handlers returning the 'DECLINE' value);
    • Compiler: if the file readme.txt is present in its startup directory, the first line from it is printed on the console (with the AL-IV distributive version);
    • IDE: drawing speed optimizations;
    • {Paintbox}, {Canvas}: Invalid_rect - serious changes in setting and handling the rectangle containing pixels which should be updated while painting. The purpose is to optimize drawing in windows which should be updated partially only (and the method {Paintbox}.Invalidate_rect used in most cases). And though this could affect working (created earlier) applications, I decided to make this change permanent;
    • Compiler: an error message added for a case when the statement contains only a reference to a variable;
    • {Form}.Make_tool_window method added;
    • {Paintbox}.Update method added;
    • {Memo}: style MEMO_CENTER added;
    • Demo applications updated: Clock, Portable Notes;
  • Fixes:
    • Compiler to Delphi/FPC: in case of calling a function not returning a result and having an actual parameter which is an empty constructor of a structure, the compiler could incorrectly output an error message;
    • Compiler: in a warning about not balanced quotations (after the END statement), name of a problem class was not shown;
    • Compiler: the operation comparing a substring with an item of a strings array was implemented incorrectly, generating the code which could not be compiled by the C#/Delphi;
    • FPC/Delphi: ambiguous correcting mouse cursor coordinates stopped for the text (beam) cursor;
    • Free Pascal:
      • modal messages problem (with {Form}.message and {Form}.ask):it was fixed by showing our own dialog (on base of class {Dialog_common});
      • and with modal dialogs in Windows: code returned to the last know good (November, 15, 2021);

July, 21, 2022 - version: 2.3.9

  • Changes:
    • Color Commander: some improvements and fixes (support for localized files description.XX added, where XX is a language code. E.g. RU for Russian language, tree view moved to a separate window and does not use the preview area);
    • Demo\Clock: additional optional function added - indicating current window input language by changing desktop color (BLUE - English, RED - any other. Colors used can be changed via a localization file). This option was checked both in Windows 7 and Windows 10;
    • IDE/AL4: some small changes;
    • Demo application added: Portable - between different PC's - Notes;
    • {Form}: for vertical columns now negative Label width parameter is supported. It means that labels (left to controls) are of variable width but controls (right to labels) are fixed size (equal to the absolute value of the Label_width parameter);
      Also: controls having flag "Anchor bottom/right"  (expanding) ignore a label before, always placing in the next row starting from the left side of the parent column;
    • C#: now all the thread objects are created with the property IsBackground set to true;
  • Fixes:
    • Delphi/KOL: loading the applet icon (when the option /$ICON=... is set). The main icon resource name restored to MAIN (for KOL);
    • Compiler to C#: due to a side effect, incoorect if statements could be generated while compiling complex enough conditions in CASE statements;

July, 12, 2022 - version: 2.3.8

  • Changes:
    • Color Commander: some improvements and fixes;
    • IDE/AL4:
      • CTRL-F3/ CTRL-F2 work now exactly as F3/ F2 (searching forward/ backward);
    • {Long_operation}: automatic hiding when Indicate|_activity called;
  • Fixes:
    • C#/{Form}: message - after the message output the form specified as the parent did not focused;
    • C#/{Form}: Set_bounds - setting new position for a form did not work;
    • C#/{Combo}: Set_items("") - added one item to the list after clearing it though the parameter string was empty;
    • IDE/Designer:
      • {Memo} some options could be lost while recognizing the CONSTRUCTOR;
      • for {Memo} controls, now operation '+' used to combine flags, so it is not necessary to add the BITWISE option to classes of forms containg {Memo};

June, 24, 2022 - version: 2.3.7

  • Changes:
    • {Progress}: property Can_anchor_bottom is set automatically for case when the parent column is aligned 'TOP'/'BOTTOM';
    • {DB}: output to console of errors accessing fields on a closed dataset was added in the debug mode;
    • IDE/AL4:
      • indicating changes on the left/right sides and on tabs added;
      • the history of the last 10 highlighted words added;
      • highlighting positions of selected word also improved;
  • Fixes:
    • C#/{Dialog}: on the second Show_modal call, sizes of controls did not adjust in correspondence with size changes of parent columns;

June, 17, 2022 - version: 2.3.6

  • Changes:
    • Loops FOR on arrays of structures are implemented:
      FOR x IN A[]...;
      Where such loop variable actually is converted into a macro x --> A[x] each time and concerned as a structure which is accessing an item of the array specified. It is also allowed to use the loop variable as the destination of an assignment statement placing it at the right side as usual; The x.INDEX operation also is available;
    • {DB} << UPDATE..., BY structured_var/ INSERT ... BY... - for fieldswhich are not in the NOTNULL list of a table updating, functions with '0' on the end of its names are used to convert values assigned to SQL strings (which writes NULLs in place of 0/empty values);
    • Compiler: the rule checking for side effects made weaker for append-to-arrays operations (<<): the left side of such statements is ignored;

June, 7, 2022 - version: 2.3.5

  • Changes:
    • Compiler: while checking side effects in expressions, now recursiveness is not an option;
  • Fixes:
    • C#+FPC: while creating a {Memo} with horizontal scrollbar turned on, the scrollbar did not appear still word wrap was active;
    • Delphi/FPC: Adding an empty (new) structure to an array of structures of such types fixed;
    • Compiler: checking of recursiveness of a recursive static overloaded function led to crash of the compiler;
    • Delphi (VCL/KOL) / FPC + {DB}: Count_fields, Field(i) did not work in case of an empty results set after SELECT query (which did not allow to get a list of fields by a query like SELECT * FROM table WHERE 1=0);

June, 2, 2022 - version: 2.3.4

  • Changes:
    • Color commander: small improvements;
    • {Form_common}, {Dialog_common}: hints are provided now on virtual {Paint_table} controls too (via Get_info event which should provide Current_row[] correctly);
  • Fixes:
    • C#: if (in result of side effects) the object was removed (this) which method was running, its field This_obj returned null with correspondent consequences; To fix the problem, in the code generated the if added to check such bade case and return a correspondent NONE object;
    • {Form}: after adding the event sources stack, the trick stopped working with clicks during a long operation even started with a timer activation (delayed). A parallel stack of events kinds was added to fix this (it allows during timer deactivation to understand that this was done during the "timer" event handler so it can correctly change the events level value allowing later to click on buttons during long operations;

May, 19, 2022 - version: 2.3.3a

  • Changes:
    • Draft Notes: small improvements; Bezier lines drawing added;
  • Fixes:
    • FPC/Linux: compiling the compiler for Linux did not work because of unknown in Linux type TFileTime;

May, 18, 2022 - 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 fielddt . 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 usesREALvalues 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...) andNOT 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
      ----------------- '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
    • TheDONEstatement introduced which should be used to separate ending part of statements block in aFORstatement which is ending with aBREAKor==> 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 statementSILENT:...; 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 attributeINDEXING type orINDEXING (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 withoutINDEXINGattribute defined; If attributesINDEXINGspecified explicitly are not corresponding, this fires an error;
      Variables, fields and other units with the attribute INDEXINGset 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 afterBETWEENx, 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 querySELECT , fields listed in the sectionORDER 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 BYits 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 operationvariable=DB, BY TABLE tableto 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.Dismisswas 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
      (whererec- is a variable of aSTRUCTURE type, Db- a variable of the data type {DB}, or inherited, andtab- 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 modifiersDEBUG andANYTIME, 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 classStr 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_resetadded 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 << SELECTFROMcity, (*), WHERECountryCodeLIKE'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 - version: 1.6.6

  • Changes:
    • Important:The keywordFOREVER removed and should be replaced with
      FOR, INFINITE: code;
      It works exactly as theFOREVERworked before: it is not allowed to useBREAK/ 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 fixeson $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:
    • Fixeson $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 methodvariant_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: recognizingnew_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 likeCASE 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 toSTRtype 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 modifiersINIT andREAD, 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}.resizeuntil 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