| RUSSIAN(Русский) | ENGLISH |  |
This function requires cookies. If the browser does not accept cookies, the light theme is used always.

## AL-IV: Versions history

#### Мarch, 19, 2025 - version: 5.0.2
Fixes: FPC: Compiling for linux target restored;

#### Мarch, 16, 2025 - version: 5.0.1
Changes: C#: {Form}.mouse_xxxx - mouse coordinates are returning for the moment the mouse was pressed / unpressed / moved, not for moment of handling the event; += `{Memory_stream|_fast}`, the old {Memory_stream} class renamed to {Memory_stream_contig|ouos_but_slow}; += `{Scan_cat}` - scanning directories by portions; += `{List_str}` - sorted strings list with fast search and a tag associated; Fixes: While searching constants in imported classes, all the imported classes are scanned to guarantee that duplicated names were found (and in such case an error is fired); Updates: Color Cat v1.6; Zoomer v1.2; Demo\Clock v3.3.3;

#### February, 23, 2025
News: The domain al-4.ru added to access this site; The subdomain kol.al-4.ru can be used to access the KOL site from now;

#### February, 20, 2025 - version: 5.0
Changes: += `LOCAL : ... ;` - block for local variables: variables declared in such block are initialized each time when blocks starts executing (and released at the end of the block), but out of the block its local variables can not be accessed; += `NEXT i +=` expr += `NEXT i -=` expr += `NEXT v.INDEX +=` expr += `NEXT v.INDEX -=` expr For loops `FOR i IN [...], FOR v IN A[...]` the statement `NEXT` added which allows to skip certain amount of iterations (not less then 1); {File_stream} += Anyway_read_write_file_stream, allows to open a file for read+write allowing to open it simultaneously in other applications for read; += `{Memory_mapping}` - class to mirror a file to memory (for interprocess communications, speed is greater 5 to 9 times then using {File_stream}); Fixes: Delphi/FPC: defining a string constant could be a problem, temporary solution applied - for simple "text" strings enclosed into quotations once, {File_dialog}, {Gif} were affected; FPC (note): finally Lazarus 3.8 + Bgrabitmap 11.6.3. (both the last) are compatible to each other (at least in Windows); Optimization (I1) turned off for functions having local variables and parameters which are arrays (this fixes app crash in Delphi/KOL applications at least);

#### February, 02, 2025 - version: 4.5.1
Changes: Delphi VCL/KOL: implementing wrapper procedures in all_casses.pas changed to use (single) assembler instruction jmp. The option /$NOJMP was added to use the previous version of code generation; Fixes: Delphi/FPC: if the main form was inherited from the {Form_common} then it could not be closed by the [x] button;

#### January, 26, 2025 - version: 4.5
Changes: C#: the way of the protection of an object which method is executing is changed: instead of temporary increasing its reference counter on enter to a method (found to be "suspicious") and dereferencing it in a finally block, the inner object This_obj is organized as the weak reference rather then the hard reference. So when (and if) the object is destroyed it is transparently is substituted by the NONE object in its methods already executing; Delphi/FPC: protection method earlier used for C#, now applied for Delphi (there were no safe protection used earlier); {Form}.ask, message: the message text color is set now to BUTTON_TEXT so it will be visible always independently of forms color themes; {Form}.Set_position: changed to select a monitor by the maximal intersection square; += {Form}.Set_popup_point({point} pt); Delphi/VCL: now columns by default have no borders/bevels/scrollbars. To ruturn them, use symbol SCROLLED_COLUMNS. Also: columns are inheriting parent forms colors; Fixes: Delphi/FPC: CONT INT x = expression - did not work for simple expressions like 5 * 100; Delphi: {Save_dialog} - selected extension did not return if Default_ext was not assigned; Delphi/VCL: event "deactivate" did not implemented to be called; Compiling an expression starting from {Type}.Sothing_eg_fun(...); Reset of nesting levels when operator brackets were changed did not work - fixed.

#### January, 12, 2025 - version: 4.4.4
Changes: {Form}.{controls_layout} += 'CONTROLS_MANUAL' - controls are not moved sized automatically at all on the parent column; Fixes: If in an assignment statement the left part was starting from a function call and the chain was finished by a reference to an array item, the compiler failed; C#: Remove - deleting an item from an array with hard references to objects if the reference to the object deleting is the last from that array; Free Pascal: generating code to work with RESULT string characters when the function returns a string value; Free Pascal: arr_of_structures[].Allocate(n); C#: {File_dialog} - save dialog was broken - fixed; Compiler fired sudden error message on non-existing error "... several .. used ..." - in a variable declaration statement following a statement really using .. at the left side of the assignment;

#### December, 22, 2024 - version: 4.4.3
Changes: Symbol '`$`' in code is totally ignored except string literals content. But these symbols can be used as anchors in patterns of `BUT` parts of `LIKE ... 'label'` statements; `{Form}` += `menu_or_sender_alias`: works like `sender_alias` before - returning first `menu_alias` if assigned, and the `sender_alias` now returns `menu_alias` only if `sender_alias==""` (is empty string); += `,PUBLIC` modifier now available for fields of classes too; `{Dialog_file}` += Multiselect (for open files dialog); `{Form_common}`: += `Set_all_forms_foreground` (like `Set_all_forms_background` and can work together);

#### December, 8, 2024 - version: 4.4.2
Changes: += {Form}.Set_icon({Bitmap}) ; += initialization of fields of classes of an enumeration type other then {bool} or {byte}; Fixes: Delphi/FPC: code generating of a FOR loop on a fixed size array of items; Delphi.KOL: {Canvas}+{AL4_drawing}: canvas of the alpha slice did not initialize; IDE/Designer: by Events\menu_item, new menu items were inserted twice;

#### November, 27, 2024 - version: 4.4.1
Changes: In expressions, operation '!' can be applied to fields too: CASE A.!Contains_B ? ... ; ; Fixes: IDE/Designer: a control could be not recognizable in the CONSTRUCT even correctly formatted (but having an empty line at end; IDE/Designer: operation duplication of a control fixed;

#### November, 17, 2024 - version: 4.4.0
Changes: The class level statement added: `LIKE CLASS {Name_of_class}, BUT (xxx===>yyy), ...` (should follow the class header). It replaces entire class text by the text from the specified class replacing all the patterns listed; `LIKE ... BUT(xxx==>yyy)*?` leads to ignore checking amount of replacements done though at least 1 should be there anyway; {OpenAL}: the enumeration {device_name} added to help create a context; Fixes: Code generating for an object returned by a function (with possible modifier NEW): the CONSTRUCT was called twice (or more) for the object already created; C#: incorrect buttons layout in the dialog {Form}.Ask; C#: generating named ENUM constant equal to the first item in the enumeration; Class functions (not methods) could not access non-public fields of its own class objects; In case of an inline insert of a function returning a result always additional initialization were generated for the RESULT variable imported, though this is not necessary if the function inlining has an assignment ot the RESULT as the first statement in its body; The LIKE statement did not take into account new variants of block brackets { }, <-- -->, BEGIN/begin END/end, as well as lower case only keywords case/for/debug/push/silent; {OpenAL}: application was crashing in system without OpenAL installed; C#: {OpenAL} DLLImport declaraations fixed;

#### November, 11, 2024 - version: 4.3.3
Changes: C#: If the environment variable CSC_PATH is defined then the csc compiler is used from that path; {Form}.Bring_to_front just brings a form to the front, without activating it; Fixes: Compiling CASE condition { ... Compiling ==> } Delphi(VCL/KOL)/FPC: {Configuration}.New_write_config|uration - did not work even for HKEY_CURRENT_USER; INLINE optimization: the inner variable RESULT was not initializing to its default value;

#### November, 1, 2024 - version: 4.3.2
Fixes: Delphi/FPC: incorrect data type Integer instead of Byte was used while accessing items of arrays containing enumerations;

#### October, 30, 2024 - version: 4.3.1
Changes: Class modifier BYTES became obsolete and now just ignored, using bytes (actual enumerations {byte}) now is not deprecating and is not restricted more; Fixes: Embedded function Name did not apply to {bool} data though (from now) it is defined as the enumeration; CASE BYTE ? ['01', '02', ... '9f']: ... - such {byte} constants did not work in similar cases; Ambiguously bitwise operation were not allowed in inxes of arrays even if there were no variables there with the attribute INDEXING; IDE/Show errors was positioned on incorrect class in case when the class name was not included into the message text at the start of the message; {Form} + {label} + do_adjust_controls: a label width when the label is occupying entire line, anyway was restricted with the label width specified for the parent column (with vertical layout of child controls);

#### October, 20, 2024 - version: 4.3.0
Changes: It is allowed to use the '-' sign in names of enumeration items and to start them not from a letter; The class `{Basic_types}` added which is imported automatically for all the classes without listing it in `IMPORT` directives; Enumeration types `{bool|ean}` and `{byte|_8_bits}` are introduced (defined in the `{Basic_types}` class), type names `BYTE` and `BOOL|EAN` become deprecated and left just for compatibility. The default maximum count of warnings increased to 1000. IDE: code translating keyword removed. The directory Compiled was excluded from the archive containing the primary 0-generation of the compiler. It can be always recompiled using visual studio (open AL-IV.sln then use _1_compile_cs_(by_Primary).cmd to compile); Fixes: Delphi VCL (only!) + {Form}: after a small change in code in Dec, 24, 2023, the test application Test_visual_projects\Test_many_forms become stack on running... The working code peace was returned. IDE/Report Editor: Too deep recursion fixed.

#### October, 16, 2024 - version: 4.2.0
Changes: Syntax: support of Russian-language keywords removed (together with renaming function names etc.); SyntaxL SEAL syntax support removed (use new multiple brackets : ;, { }, <-- -->, begin/end, BEGIN/END); For functions, the modifier `PRIORITY(n)` or `PRIORITY LIKE(operation)` added which allows to set the priority for 2-parameters functions having a result which can be called in form X \fun\ y; It is now possible to specify the operation '!' not opnly in front of the entire expression but after a symbol '.' in the chain of calling functions, e.g. `A.!Equal(B)` as well as in case when a 2-parameters function is called as a binary operation: `A \!Equal\ B A \{Klass}.!Equal\ B A \!{Klass}.Equal\ B A \!(X).Equal\ B A \(X).!Equal\ B` (But it is not allowed to use the '!' twice for the same operand). Fixes: The 0 gen compiler compiling restored; Passing the THIS parameter to a method calling in form a binary operation: X \(expression).method\ Y

#### October, 4, 2024 - version: 4.1.1
Changes: Syntax: in case when a long condition in a sequential CASE statement occupies several lines of code, the compiler requires to locate the question mark '?' either at the end of the line or at the start of the next line of code (or place it single on a separate line). IDE: small fixes; Start removing support of Russian-language keywords. Fixes: Compiler: brackets handling `<-------------- --------------->`; IDE: freezes on a file with the END without an empty line before it; Compiler: `//comments` after the '`.`' in the last expression of a function; Compiling for Linux restored (only for Lazarus with versions 1.x, also checked for the Lazarus 3.0 (Debian package 3.0+dfsg-8build3) + FPC 3.2.2)and seems it works also with 3.4 or Typhon 8.x but it should be downloaded and installed via dpkg separately and then cause conflicts in libraries; If you are trying to compile visual projects in Linux on a directory mounted from the Windows shared folder (using cifs), then the Free Pascal resource compiler (fpcres) will fail to write output file .or from resource files. So, copy your project locally (and do not use paths containing spaces in it); FPC + Linux: the requirement to press ENTER twice after a broken compilation actually required to press it 3 times; Updates: IDE: speed + handling new operator brackets `{ }` / `<-- -->` / `BEGIN end` together with `: ;` .

#### September, 16, 2024 - version: 4.1.0
Changes: Syntax: it is now possible to call functions and methods with two parameters in form expression1 \function\ expression2 e.g.: x = A+1 \Max\ B-1 The function can be in one of forms: a. Function_name b. {Class}.Function_name c. (expression_in_parenthesis_returning_an_objectIs_descendant_of).Method_name and symbols '\' are surrounding such reference to the function (or method); This way to call functions also works for overloaded functions, too; ; Syntax: In any panthesis it is allowed to add any numer or nested square brackets. This can be used to visualizy nesting levels of parenthesis. E.g.: x = (a + b * Dist([ Pt([[x1, y1]]), Pt([[x2, y2]]) ])) / 2 Fixes: Delphi/KOL+{Text_file}: Load fixed to allow read UTF-8 at least when the Encoding was set explicitly to 'UTF8'; Delphi/KOL+{Text_file}: Save fixed for case when the file path does contain only a file name (without leading directory path); {Form_commo}.text_hint fixed for virtual tables (the array Current_row[] did not clear so another data was showing then under the mouse cursor); Compiler: brackets <-------------- --------------->

#### September, 7, 2024 - version: 4.0.0
Changes: It is disallowed to reuse keywords in lowercase as functions, variables, etc. names; It is allowed to use keywords `fun`|`ction`, `method`, `case`, `for` etc. in lowercase only; Additional syntax of statement brackets added: `{ }` or `<-- -->` or `BEGIN END` or `begin end` instead of `: ;` or `: .` In brackets `<-- -->` amount of symbols `'-'` can be any greater then 2. Changing form of a bracket in a nesting block resets nesting counter removing the restriction on amount of nesting blocks. String literal constants either enclosed as `"..."` or as `''...''` (using double apostrophes afore and after). In the first case, apostrophes in the `"..."` string are interpreted as usual characters, and in the second case symbols `'"'` are interpreted as characters, too. In expressions operations '`&&`' and '`||`' can be written using keywords '`AND`'/'`and`' and '`OR`'/'`or`' correspondently. The operation '`!IN`' can be represented either as '`!in`', or '`NOT IN`' or '`not in`'. The class ending directive `END` should have an empty line before it. The `END` block bracket if located in a separate line should not be separated from previous code by empty lines; Changes in the SEAL dialect; Improvements: Compilation: when project options are changed, all its classes are re-compiled (like with the option /$REBUILD); Compiler: it is allowed to assign a value to a loop variable enumerating an array items; Compiler+C#: in the option $VERSION it is allowed to use an arbitrary amount of numbers separted by '.', e.g.: $VERSION="1" or ..="1.1" or "1.1.1.1.1". IDE: lines ending out of below bound of the editor window were not drawing. Fixes: IDE: while compiling compilers as projects from the IDE compiling errors did not show in the messages window; C#: an error in code generating for the operation s.[*] = "?" of changing the last character in a string variable;

#### August, 5, 2024 - version: 3.4.3
Changes: C#/Compiler; options /diag / /diagnostics are added providing logging all the problems like array/strings bounds violations (usually suppressed by the AL-IV language/compiler generated code);

#### May, 1, 2024 - version: 3.4.2
Changes: Compiler; for long continued lines it is now sufficient to separate them from the next lines of code to avoid warnings (earlier it was required separate them also from previous lines of the same level, too); Fixes: Compiler: ambigious warnings about dynamic arrays parameters were generated for classes which were nt recompiled (still those were not changed); C# + MS Visual Studio: while recompiling project, references on files which were not compiled were not added to the csproj file 9used only by Visual Studio). Though without MS VS, the project was compiled and running OK; C# + {File_stream}.Read_file_stream, Anyway_read_file_stream: checking for file existing removed still there are situations when file exists but the Exists check function returns FALSE; {Dialog_file}: after calling Select_file, calling form lost the sender_ value (as well as sender_alias);

#### April, 21, 2024 - version: 3.4.1
Changes: Compiler; the option "L" added (e.g. /op +L) which allows applying only local optimizations (and also disables deleting unused functions, inlining of code from other classes); Compiler: class is not re-compiled also in case when only local optimizations are allowed (like in case when all the optimizations are off); IDE: Project wizard - it is possible to select one of optimizations options (+L, +, -); Designer - showing lines representing approximate size of the form given by the option "Custom size"; Fixes: Before compiling a class, its list of localization constants was not cleared (if loaded from an extern file, this prevented compiler normal working e.g. if testing was required for the project);

#### April, 17, 2024 - version: 3.4
Changes: Compiler: the key added: /$REBUILD (forces recompiling all the classes of the project); Compiler: when optimizations are off, and a class did not change (in comparison to early compiled unit of the resulting programming language), and the option /$REBUILD is not present, then such class is not recompiled (this increases speed of recompiling projects after some minor changes in code); IDE/AL4: while running a project (F8/Run button) with the SHIFT pressed, the option /$REBUILD is added automatically (and all the classes are recompiled); Compiler: the /$CCC option is obsolete and ignored (references to \CCC subdirectories are removed in compilers options); Fixes: Java/Android: {Console}.Key_pressed_async (Compiling did not work);

#### April, 8, 2024 - version: 3.3.8
Updates: Demo\Clock: closing windows by LKB+RMB fixed/improved; ColorCat: handling top level of catalogs improved/fixed (Windows/Linux); Zoomer6 (+Lite): some images were skipped while building a collage; Fixes: KOL: {Form}.Close: on application close the exception could be fired (a check added if the parent column for a control is searching not by a deleting control now); KOL: {Canvas}.Erase - while erasing a buffer of size 0x0 the application silently crashed (check for a zero size rectangle added); Free Pascal + Lazarus + Linux: compiling now possible again for the Linux platform; Linux + {Paintbox}+ : setting cursor shape to 'ARROW' led to convert it into left-to-right directed non-standard mouse cursor; Linux + {Form}.mouse_double_click event very often did not call still it was handling by the system as the nesting to the previous event (mouse_up);

#### March, 31, 2024 - version: 3.3.7
Changes: {Paint_tabs} drawing changed, more precise clicks on tabs. Updates: ColorCat: some improvements, + working with links; Fixes: {Dialog_dir}: after calling Select_dir, calling form lost the sender_ value (as well as sender_alias); Delphi + {File_path}.Recycle_file: buffer containing a string with paths of files/directories to recycle was freeing too early; Delphi: {System_functions}.Allocate fixed to provide specified aunt of bytes in the array passed rather then extending it for the spcified amount of bytes;

#### March, 19, 2024 - version: 3.3.6
Changes: {Form}: Changes in the order handling nested form (and controls) events: depending on the event handler it either is handling immediately or queued (without duplicating identical events from the same sender). Events queued are handled on the end of the nesting level handling, and while these are handling the same events are not queued again if fired. Events requiring immediate handling (keyboard, menu callbacks) are always handled without queuing. Updates: ColorCat: fix playing mp3 with ID3 tags v2.x; Fixes: Delphi/FPC: code assigning an object returning by a function to an object variable was generated incorrectly: leaks occurred; FPC: {System}.Short_path, .Play_audiofile;

#### March, 16, 2024 - version: 3.3.5
Changes: Compiler: absence of statements in a CASE branchnew considered as an error (at least type NONE or UNCOOKED); Compiler: in expressions if spaces are preceding '.' symbol this prevents setting new base object for later continuations like .x...; {Sound} += .Play_sound|_file(STR File), .Stop_sound|_playing(STR File); {System_functions} +-= .Play_audiofile... Updates: ColorCat: "preview" for audio files added (can be used as the audio player in the current directory), alerts for disk monitor events (sound/color flashing); Fixes: {Paint_table}: Multiselect did not work for selecting by dragging mouse with LMB pressed;

#### March, 4, 2024 - version: 3.3.4
Changes: {Form}.Set_form_progress(n_0_to_100); Updates: ColorCat: monitoring of disk operations added; Fixes: {Paint_table}: Multiselect did not work for selecting by dragging mouse with LMB pressed;

#### February, 25, 2024 - version: 3.3.3
Changes: C#: Target platform (.Net Framework) by default changed from 3.5 to 4.8; Updates: Demo\Clock: frames animation, closing applications by LKM+RKM; ColorCat: problems fixed with the Computer tab (memory leak, scaling, showing network drives), wiping speed increased. It is now possible to select "Ignore" when answering on the question about "not enough space on disk"; Fixes: C# + /$FRAMEWORK=x.y; C#: generating project, compatibility with Visual Studio 2017...2022 and with .NetFramework 4.7, 4.8; C#: compiling in Windows 10/11 without Visual Studio;

#### February, 18, 2024 - version: 3.3.2
Changes: The embedded function Byte(INT Value)==>BYTE was introduced to "convert" integer values to bytes (usually, it does nothing - but this can depend on a target platform); Option /noind|ex|ing turns off warnings about desirability to use the INDEXING attribute; Fixes: C# + {NATIVE_Alien_windows}; C# + {AL4_OpenAL}; FPC + OpenAL.pas += {$DEFINE WIN32} if not LINUX; FPC + Windows: the parameter -dWIN32 is added automatically; Compiler + --------- 'comment', REUSED: sometimes false warnings were fired about reused block claiming it is not actually reused; {String_functions}.From_hex for lowercase letters abcdef worked incorrectly; Compiler+SILENT: warnings about not used local variables were not suppressed; Delphi/FPC + fixed array/ranges of other arrays: code to clear temporary arrays in for loops no more adding (adding those could cause problems accessing base arrays);

#### February, 11, 2024 - version: 3.3.1
Changes: C#+{System_functions}.Platform_info: independently of the target compiling platform, for OS later then Windows 8 additionally outputs real current version, e.g. Windows 10.0, Windows NT 6.2...; Delphi/VCL: independently of a manifest, the function Platform_info returns real OS version number; Fixes: FPC+Windows+{Form}: events resize and moved did not call for frameless forms; Delphi + /$DEBUG: deleting the file breakpoints.txt did crash the application. Now, executing will continue; C#+{Form}.Show_application_button: if the value was set before starting the application, it was overridden; Updates: Clock - contnue playing with window frames, defining on which monitor the foreground window is on base of the greatest intersection square; IDE/Show errors - works now for target paths containing the word "build" (this allows to work with messages while compiling compilers; FPC+{Config}: a capability to read from the Registry on the HKCM key provided (earlier the TResgistry object could not created with user access rights even for read operations);

#### February, 5, 2024 - version: 3.3
Changes: IMPORTANT: The identifier '_' (single underline symbol) in an expression right to the assignment sign (or to the append sign '<<') refers to the expression at the left side of the assignment sign. So it is now possible to write: `very_long_variable_name = _.Some_function(...)` or `Some_variable.Long_field_name = 1 - _` or `.. = (_ + 1) * 2` and not only x += n While creating new objects in the initialization fields list it is allowed to use an assignment of form `x = _` instead of `x = x` (where x is the same identifier but assuming a bit different things). E.g., `Screen_ = Screen_` can be written as `Screen_ = _` to pass the screen object while creating a form (There is no such rule to apply to parameters passing to a calling function, so Parameter=_ still assigns the value to the left of the main '=' sign); Using the operation '`<<`' to add a string to a string variable now calls a warning. It is desired to convert such operation to an assignment with the concatenation: `X = _ Y` (it is possible that in future, the operation '`<<`' totally will be disabled for adding strings to string variables, leaving it for adding to arrays, output to console and replacement of calling `Write` methods); Linux + {Form}.Save_bounds/Restore_bounds: to save and restore width and height, Client_width and Client_height are used still setting size by the usual way sets the actual form's size larger a bit; Linux + {AL4_drawing}: The option SIMULATED_CARET is on always for Linux; C# + {Form}.Set_no_frame removes borders and caption totally; Fixes: SERIOUS BUG: FPC + {String_functions}.Starting could work incorrectly for UTF8 strings; Delphi/FPC: a redundant code still was generated for RTTI even with the /$NORTTI symbol defined in project options; Delphi/FPC + TRef_obj.Ref_dec_weak / Ref_dec_hard: sometimes was calling for nil-object which lead to exception firing and handling. A check for case Self=nil was added. Updates: Demo\Clock += frame around an active window (Windows only) + resizing (+Ctrl/Shift) / moving (Alt) / input language indication by its color; Typelin + Linux: fixes;

#### January, 28, 2024 - version: 3.2.6
Changes: Application Typelit added which allows to type text with an editable encoding converting latin characters to a desired Unicode symbols. Also supporting for quick typing suggestions from an auto-completed dictionary of words; Fixes: Free Pascal + Linux + {Clipboard}: copying UTF-text to the clipboard sis not work correctly via standard Clipboard functions (fixed using gtk functions directly); C#+{File_path}.Exists, Dir_exists finally fixed for network paths starting from '\\' (File_detail is called and file / directory assumed existing if it returns non-empty structure);

#### January, 24, 2024 - version: 3.2.5
Changes: IDE AL4: support of [SYNTAX="SEAL"] added including syntax highlighting, block lines drawing and instant code type, and correct code generating / recognizing in the IDE Form Designer and Menu Editor; ; Fixes: Free Pascal + Windows: crashing an application while navigating on a deep nesting menu (Delphi || Linux - were OK); Delphi/Free Pascal: correcting a form height added while adjusting columns on a form without a frame (No_frame = TRUE); Delphi/C# compiler: a code is not created to check if x > 0 for the operation x IN y (for x and y of type STR) if x == "CONST"; C#+{File_stream}: checking if file Exists for a file / directory on the network shared folder via File.Exists or FileInfo.Exists is not working so an additional check if a file exists before opening a {File_stream} turned off now;

#### January, 17, 2024 - version: 3.2.4
Changes: Compiler: reading of language to translate compiler messages from the environment variable AL4lang added (if it presents then file Compiler_language.cfg is ignored); Compiler now supports [SYNTAX="SEAL"] (C-like: { figure brackets } + ';' + capability to type basic keywords at the start of lines with lowercase letters); Fixes: Compiler/FPX+linux: compiling fixed under Linux; IDE: showing errors while compiling a project directly from the IDE: a problem showing encoded Unicode characters &#nnnn; - fixed;

#### January, 10, 2024 - version: 3.2.3a
Fixes: C#: previous changes in the {File_path} could brake compiling new projects; IDE: while selecting pair brackets, red-yellow-ellipse was focused one character right, other brackets (not on cursor) were marked as not having a pair;

#### January, 8, 2024 - version: 3.2.3
Updates: IDE: searching pair tag (while editing html); Color Cat (faster refresh; quick mark up files with [+]/[-]; preview of a directory showing a text file in it with the same name as the directory; cyclic switching tabs each 30 seconds with prevent stopping hdd-s; deleting system and read/only files); Fixes: C#: {File_path}.Extract_path could work incorrectly if file name was finished by some (strange) symbols; C#/Delphi: in the IN operation to check a substring presence in a string for an empty substring result was always TRUE (fixed adding a check first if the substring is empty);

#### December, 30, 2023 - version: 3.2.2
Changes: Demo\Clock: an option added to restore windows coordinates after some sudden changes (like detaching one of displays); Color Cat updated (small fixes, improvements); IDE: another button added to run a project without debugging (same as Control-F8/Control-Shift-F8). The button added earlier to run with debugging (F8/Shift-F8) now forces debugging adding /debug and /$DEBUG keys (but available only for Delphi/WinFPC projects); C#/Delphi/FPC: += {AL4_form}.Get_label_desired_width, more accurate placing labels on a form ({Form}.Adjust_controls); Draft Notes: fixes, improvenets; Fixes: C#: {File_path}.Exists, . .Delete: working with long file paths (longer then 260 characters) was fixed; Ide AL4: Opening a class by Ctrl+Enter / Ctrl+Click in the same directory fixed; Ide/Designer: duplicating controls with the special button did not work (CONSTRUCT did not update); Ide/Debugger: the previous value of a variable was shown even if it was not changed; {Form}.Adjust_controls - a label placed along in a row of a column, now occupies the entire row width;

#### December, 21, 2023 - version: 3.2.1
Changes: IDE AL4/Debugger + Delphi/FPC: structured variables and fields of the method output added (also of simple types, structures and enumerations); sorting of variables watching in the Debugger added - by type or name, ascending or descending; if a value was changed, it is shown in red; and the old value is shown (in blue) if the value is fit onto a single line; It is possible to copy types / names / values of variables watching; It is now possible to enter while debugging into native-only functions (to view its local functions / parameters); Setting a bookmark on the first line of a function header sets breakpoints on all the statements of the function; If there are several statements in a line and a stop was found not on the first from them, then (accurately enough) the line will be greened starting from the statement stopped; In the /$DEBUG mode, the compiler especially adds an empty statement at the ending point of a FOR block to provide some vivsible changes in the IDE editor when you are pressing F7 in a FOR loop code; Demo\Clock: an option added to correct mouse cursor position when it was stack on a bound of a monitor, to move it on another neighboring display in that direction even if these sizes are different; Fixes: C#: labels drawing overridden to avoid discarding whole words not fitting to the width available; {Form} + controls placing on a column aligned from top to bottom: width of labels in front of other controls is set exactly in correspondence with the label width parameter of a column (but if the next control is moved to the next row, then the label occupies entire column width instead);

#### December, 14, 2023 - version: 3.2a
Changes: IDE AL4 + Delphi/FPC: Step-by-step debugger was added. A project to debug should have the option /$DEBUG (new!), the project can be run from the IDE or by another way, the Debugger window (new!) shows current funcrtions stack and local variables values of simple data types of the funcrtion currently stopped, bookmarks in the source are used as breakpoints in the program been debugging;

#### November, 30, 2023 - version: 3.1
Changes: IDE AL4: The [Run/F8] button added (returned), allowing to start compiling from the IDE and to view compiler error/warning messages in the IDE window and jumping to correspondent lines in source files to edit them from the IDE (the project to compile should be opened by the menu item File | Open project first); IDE: searching declarations in directories of indexed files added, and searching non-qualified declarations of structures / enumerations if there are qualified references in the source in form {Class}.{type}; Fixes: IDE/Designer: aligning controls after labels in columns having aligning style "2 columns";

#### November, 20, 2023 - version: 3.0.3
Changes: {Form}.mouse_wheel + C#/Delphi(VCL): mouse wheel speed changed to the average of C# / Delphi (slowed for Delphi, fasted for C#); Fixes: C#: {String_functions}.Oem_to_string; C#+{Stream}.Get_line: getting an OEM text ; {Form}: fixes in controls placing in "two-columns" mode in horizontal columns (aligned 'TOP'/'BOTTOM');

#### November, 11, 2023 - version: 3.0.2
Changes: Compiler: some ambiguous warnings are eliminated (e.g. about calling DEPRECATED functions from another DEPRECATED functions, or about not used parameters in prototype methods); IDE/Designer: in the CONSTRUCT generated a rounding operator PUSH in_construct = TRUE : ... ; is adding so amount of calls of methods Do_adjust_columns / Do_adjust_controls is minimized and some sizing problems are fixed for controls still its all the options are set in the CONSTRUCT before calling these methods the first time; (To apply this change for a form it is necessary to open it in the Designer and change some value on it); Fixes: Compiler: controlling of types added while assigning fields in an object/structure constructors; Updates: Color Cat (renamed from Color Commander);

#### November, 6, 2023 - version: 3.0.1
Changes: Some warnings was eliminated in the compiler code (Delphi/C#); Compiler: some ambiguous warnings are eliminated (e.g. about calling DEPRECATED functions from another DEPRECATED functions, or about not used parameters in prototype methods); Delphi/FPC/C# + {Form}: the exterior of a form and buttons placing on horizontal columns are more similar to each others (but in the FPC the 3D-border is used for columns since the TScrollBox from the Lazarus is used to implement them); IDE/Designer: in the CONSTRUCT generated a rounding operator PUSH in_construct = TRUE : ... ; is adding so amount of calls of methods Do_adjust_columns / Do_adjust_controls is minimized and some sizing problems are fixed for controls still its all the options are set in the CONSTRUCT before calling these methods the first time; (To apply this change for a form it is necessary to open it in the Designer and change some value on it); {Form_common}: a label before the focused control changes its font style not to BOLD but to UNDERLINE; this fixes problems with resizing the label in case when labels are aligned right in a column; Fixes: Compiling the primary compiler is restored; Compiler: controlling of types added while assigning fields in an object/structure constructors; Updates: Color Cat (renamed from Color Commander); Zoomer 6 Vernissage; Diagram Draw;

#### November, 1, 2023 - version: 3.0
Changes: IMPORT: {{nnnnn}} . - allows to group several class names in a single file (with the extension .import). Files are added already: Standard.import, Visual.import и Files.import (with the synonym Streams.import). It allows to make IMPORT section shorter; Fixes: Delphi/FPC: {Mathematics}.Abs(x) did not work for case x==NAN; Delphi+KOL: BYTE Array[].Allocate(nnn) - did not erase the allocated space with zeroes; C#+{Font}: setting a custom font for a column did not affect its controls;

#### October, 22, 2023 - version: 2.9.4
Changes: {Form}.message/ask += button on the task bar for the message window; {Form}.ask/message: it is possible to set up an additional text for the message caption: PUSH Ask_caption = " - string": message(...) ; {Form}.ask/message += capability to adjust the dialog in the event decorate_ask_message_dialog; Delphi+{Form}+{Button}: wide/heighter buttons by default sizing; Fixes: C#: {Label} - auto-size on caption change; Delphi/FPC: ambiguous calls of value_change events while auto-adjusting controls on form;

#### October, 1, 2023 - version: 2.9.3
Changes: METHOD/OVERRIDE += modifier OPTIONAL: no requirements to call the BASE or to use the modifier REPLACE in an overridden method in the next descender; {Form} += Auto_height; Designer/{Form}: += Auto_height; {Form}.ask/message: it is possible to set up the Ask_size for the message window. E.g.: PUSH Ask_size = Pt(width,height): message(...) ; Fixes: {OpenGL} - resizing did not take into account after creating the control;

#### September, 22, 2023 - version: 2.9.2
Changes: Tools\Drawing_diagram: jums added to diagrams by references in form //filename.dia in the last line of a block text (the line itself is not shown but entire block text become bold and colored green); Fixes: C#: {Bitmap}.Stretch_draw worked incorrectly in case when the destination rectangle size was the same as the image drawing size (drawn enlarged); Updates: IDE/AL4 (in addition to opening classes, jumps to diagrams added (it is possible to jump and open class file at the same time, too); Color Commander (+Delete empty subdirs, +Delete unfinished files, +Continued copying unfinished files, +Auto-pause);

#### September, 13, 2023 - version: 2.9.1
Changes: Drawing in {Paintbox}+after resizing a form works faster: a buffer bitmap is allocated a bit greater and just copied except the Invalidate_rect/Invalidate_all was called explicitly (or after window scroll); Fixes: C#: due to a small typo in {AL4_form} all the graphics was slowed down (the winapi function GetDC was calling instead of getting the cached value Scale_y); Updates: IDE/AL4; Color Commander (+Compact view, +...); Demo/Clock;

#### August, 25, 2023 - version: 2.9
Changes: IMPORTANT change in syntax of string symbols indexing and range operations: now the dot is REQUIRED between a string operand (like constant, variable or other scalar string expression) and the open square bracket: s.[i] - this changes are intended to provide an explicit difference from arrays indexing/range operations especially for cases of strings arrays; (For now the previous syntax is still working just generating warnings but for a couple of updates elder syntax will be qualified as errors except some special compiler option used). Compiler: a bit faster (functions searching); C#: compatibility with .Net 4.5.2 added, compatibility with any .Net 4+ improved; it is now possible to specify target framework via an environment variable AL4FRAMEWORK (setting it to a value like 4.6.1 or 4.5.2); C# + /$PROFILER=... - if another value is specified then ALL then function calls counters are not generating making analyzing of the profiler statistics easier for such options; Demo\Clock: a calendar with notes added; Fixes: {Calendar}: if a month was ending by a Sunday and a week was set to start from the Monday, then in vertical week days layout days columns did not add in such month; Delphi + {Canvas}.Foreground / Background + INT64 - alpha channel color was incorrect (at least this worked correctly with the key /int32 - now works both ways). Also this fixes text drawing in {OpenGL} + {Font2D} for INt64 mode.

#### August, 4, 2023 - version: 2.8.6
Changes: {Screen} += .Custom_messages: if set to TRUE, then the custom message dialog is used to show messages and asks ({Form}.message / .ask) instead of system dialogs which too often become hidden behind of other windows; {Form_common}: the flag {Screen}.Custom_messages is set by default (but not for the {Form} base class !), so if not to assign FALSE again then the custom form is used instead of system dialogs to implement {Form}.message / .ask; Compiler: a warning about necessity to separate a long line from other lines removed in case when a long assignment (starting from '=') is following a variable declaration e.g.: INT x|_variable = some long expression ( occupying several lines of code); IDE AL4 / View diagram: some improvements (context menu to reopen earlier opened diagrams, scaling with Ctrl + mouse wheel, ignoring spaces in a line //[diagram: name.dia], searching classes one level deeper about all already opened files, searching classes with divided names like {Some_class| very_very_long_name}); Fixes: Delphi/VCL: sometimes on (the second / later) call of the Show_modal, form did not show on screen (found it in state Minimized). This was fixed by correcting the window state from minimized (iconic) to normal state in the Form_activated event handler; an erroneous warning could be fired sometimes about REUSED blocks that these are not used actually though this is wrong; C#/Delphi: for arrays Remove(item) in some cases deleted all matching items, in other cases - only the first. Fixed now to remove all the items specified;

#### July, 31, 2023 - version: 2.8.5
Changes: Compiler: in case when an identifier was not found in the scope, the similar names are searching an listing in an error message. All such names are searching with the length different not more then by 3 symbols, without case of letters taken into account; IDE: a capability added to navigate using the embedded diagrams view. If a diagram is shown in result of mouse moving over a line with text //[diagram: path], and the diagram has blocks containing class names in {figure brackets} then clicking such block switches to Ide tab with such class text; {Form_common}: while attempting to activate a form from which a modal dialog was called, the dialog form is activated beeping with a standard sound; Fixes: C#/Delphi/FPC: when the right Alt is pressed, the system also switches on the flag "left Control is pressed", too. Now Key.Control is reset (in the key_press event only!), and your handler receives only Key.Alt flag set. Detecting keys combination Left-Control + Right-Alt is now your problem. Al least Right-Alt + Right-0Control should work, and behavior of key_down/key_up events is not changed;

#### July, 21, 2023 - version: 2.8.4
Fixes: Delphi/FPC: {Text_file}.Load did not work;

#### July, 19, 2023 - version: 2.8.3
Changes: Compiler: when using ending \* together with command line key /src, all the paths containing the word "compiled", are still ignored. This prevents clashing units from different languages while compiling or using output units as source files (at least automatically); Fixes: Delphi/FPC + Windows: {Process}.Ended was implemented by searching a window belonging to the process checking (this is incorrect: a process can work and do not have yet/already/at all any windows belonging to it). Now the API function OpenProcess is used; C# + {Form} + {Dialog}.Show_modal: an exception when a dialog was called from a closed parent form; Delphi/FPC + {Form} + {Dialog}.Show: it is allowed to use a descendant from the {Dialog} class as the main form of an application (.Show was ignored); IDE/Designer: generating code for storing/reading form Alias field, so it can be edited in the visual IDE designer; Delphi/C#: {Process}.Terminate;

#### July, 11, 2023 - version: 2.8.2
Changes: Syntax: it is allowed to break a line with a continued part starting from a (single) dot symbol (but it should not be alone in the continuation line); Compiler: in options file / command line parameters, options /src and /src_test now can have a path ending with \*. In such case the directory specified is included in sources search list together with all its subdirectories (recursively); Compiler: it is no more required to list in the imports all the descendant classes only because of using those methods - it is sufficient to import only a base (prototype) class; Visual development: new class {Screen_caller} added which allows to move from the monolith application architecture to a micro-module complex. Each module is a form with its satellites which implements some part of functionality of the entire application and it is compiled to a separate executable. This speeds up compiling time (since modules are smaller), and allows to compile several such modules at the same time, in parallel. There are also other advantages such as a capability to re-compile a sub-module without closing entire application, automatic paralleling of operations, using different compilers and compiler options to compile different modules, cleaning memory heap and so on... Fixes: C#: to generate an icon resource, now absolute paths are used (in .rsp file); in a project options path to an icon should be either absolute or relative to the directory containing the main class of the project; Code compiling for STORED parameters: initial default value different then 0 could be not applied sometimes;

#### June, 26, 2023 - version: 2.8.1
Changes: Delphi VCL/KOL, FPC: {Text_file}.Load speed improved for case of ANSI encoded source; FPC: the function is added {String_functions}.Ansi_bytes_to_utf8(BYTE[]) to convert large ANSI text to the inner encoding of the Free Pascal; FPC: some compiler options were changed to make compiling faster a bit; IDE: fixes in searching a symbol under cursor by Ctrl+Enter/Ctrl+Click; Color Commander: new functions, fixes.

#### June, 13, 2023 - version: 2.8.0
Changes: {Keyboard}: names of constants DEL / INS was changed to avoid conflicts with embedded functions; Compiler: if in an expression the dot character is following a string literal constant in double quotas but the dot is separated with spaces, this is not treated as a call to a function with the first parameter (the constant string) but it is supposed that another operand (starting with the dot) is concatenated with the string; This allows using "sugar" of re-using a previews object fields in the same expression in a strings concatenation; Color Commander: version 0.75 (+searching duplicated files, +preview video frames, +control previews, +removable disk eject, +fixes); Zoomer6: getting images sizes could be working bad; PSD format is not supported in C# / Delphi-VCL - this did not take into account; Fixes: IDE/Designer: converting text to text in quotas was fixed for controls {Combo}, {Listbox}, {Paint_table}, {Paint_turtle} and others; C#: generating INT/REAL CONSTANTs defined as expressions like 1024 * 1024; Delphi/FPC: generating call of the Main function in case when there are several such functions in the scope;

#### May, 16, 2023 - version: 2.7.9
Changes: IDE AL4: optimized for speed (drawing changes marks at right side via a cache bitmap); For lines of code large then 80 characters but starting from the quotation mark (") a warning is fired instead of an error; Fixes: Delphi/FPC, {String_functions}.Oem_to_string did not wrk due to a typo; Delphi(VCL,KOL)/FPC(Win): {File_path}.Rename did not work wor directories; Delphi/VCL: calling {Form}.Any_change disabled when the DESTRUCT method is called: something could be wrong otherwise; Delphi/VCL: ambiguous Clone() operation was used e.g. while adding structures to a dynamic array; IDE/Designer: converting text to text in quotas while generating the CONSTRUCT (for cases when the control text contains quotation marks itself); IDE/Designer: vertical position of a {Memo} text fixed; IDE/Designer: drawing controls with fonts configured fixed;

#### May, 2, 2023 - version: 2.7.8
Changes: C#, {AL4_Drawing}: DrawImage replaced to DrawImageUnscaled where it is possible; Fixes: C#: generating code for comment block in the debug mode: did not work correctly in case when the comment contained the symbol '\'; C#: generating code assigning a result of a function to a scalar object variable was incorrect, the resulting code led to objects leakage, this could be critical in case of large images; C#, {AL4_drawing}.Can_load_bitmap_fmt: when called for "WEBP", always returned FALSE (checking for presence of libwebpXX.dll was incorrect);

#### May, 1, 2023 - version: 2.7.7
Changes: The Color Commander is updated 0.69 (deleting with SHIFT+DEL, hints on current op progress in status); Zoomer 6 application updated (cutting a rectangle with CTRL+mouse added); Draft Notes application updated (thin frame, fixes); While checking lines of code for exceeding 80 characters last closing brackets ')', ']', '}', quotations <'>, <"> and punctuations ';', ',', '.', '?' are ignored. Fixes: FPC+BGRABITMAP: {Bitmap}.To_clipboard did not work; FPC+BGRABITMAP: {Bitmap_direct}.Lock / .Unlock - did not work;

#### April, 23, 2023 - version: 2.7.6
Changes: The Color Commander is updated (0.68); Fixes: C#, Delphi/FPC: working keyboard handler in modal dialogs;

#### March, 26, 2023 - version: 2.7.5
Changes: {DB}.CStr, CInt, CID, ... - in the debug mode when fields are requested not present in a query results, a message is fired into the console; The field {DB}.Level_trace_stack controls functions stack output. {System_functions}.Trace_blocks(INT) function is added which turns on/off tracing block comments: when on in the debug mode, a message containing class name, function name and comment text is output to the console when the comment is "executing"; The Color Commander is updated (0.67); Fixes: C#: working keyboard handler in modal dialogs;

#### February, 15, 2023 - version: 2.7.4
Changes: C#,Delphi/FPC + {Bitmap}: code drawing images changed: earlier version did not account canvas transformations (scale, rotation, offset); Color Commander updated (to version 0.65); Zoomer6 updated (version 6.1.1); IDE/Designer: speed up text entering values;
Fixes: C# + {Bitmap} + {Printer} + {Report}: printing of an image on a printer canvas did not work; Delphi/FPC + {Bitmap}.Stretch_draw / Draw: problems were fixed with drawing and printing ({Printer} + {Report});

#### January, 20, 2023 - version: 2.7.3
Changes: Color Commander updated (to version 0.64); Zoomer6 updated (version 6.1);
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 TIME(nn) MSEC/SEC/MIN/HOURS/DAYS: ... ; 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 AL4_form.java, AL4_drawing.java);

#### 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 A[].Delete(A[].Count-1) it is now possible to write just A[].Delete(.Count-1) 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}` or `LIKE {Class_name}.{structure_type}` In result, all the fields of the source structure type specified are added on the top level of the declaring structure; In case of a source structure from the same class, it should be already declared above; Block comments in form -------------- 'text' in calls to constructors of structures or objects like `x={type}(field=value, ----------------- 'comment' fieldN+1=valueN+1, ...)` Fixes: Delphi/KOL, {DB}: reading Date fields from databases; Fixes in compiling overloaded functions;

#### December, 29, 2021 - version: 2.1.2
Fixes: C#, Delphi/KOL, Delphi/FPC, FreePascal/LCL+ {Printer}: printing fixed;

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

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

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

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

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

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

#### November, 14, 2021 - version: 2.0.2
Changes: IDE Designer: improved calculating of the central column size; {Paint_tree}: drawing improved, icons drawing added (turtle drawing), function to handle keys commands (arrows and others); The sugar with accessing to anothr field of the same object in the same expression is improved: Tree.Node(.Selected), Control.Width +.Height, etc.; Compiler: in case of assignment a value to a field of a structure returned in result of a function call (pointless operation); {Form}, {Paint_turtle}: while locating controls in a column from the top to the bottom, controls of type {Paint_turtle} created following another control always are placed in the same row (so it is allowed to place up to three controls in a row, if the first is a label and the 3rd is {Paint_turtle}); {Paint_turtle}: subbuttons mode added (turnting a {Paint_turtle} control to a horizontal line of several buttons); SQL/DELETE: it is allowed to use special word ALL in place of WHERE clause (DELETE FROM MyTable, ALL) to specify that the entire content of a table is deleted, and this is not an error; Fixes: Delphi(VCL)/FPC: {Paintbox} - setting vertical scroll position; Designer: adding new aliases in the CASE of an event handler (click) while jumping to it from the menu of the Designer; SQL INSERT, UPDATE: using comments --------------- 'text' in a list of assignments of values to database fileds; Compiler: more correct working under chains of comparisons (in case when there were other operations between comparisons, e.g. a + b < d + e < f + g). And therefore in case a < b && c < d the chain operation is not detected still the && \ || operations priority is lower; IDE/Designer: loading problems for {Paint_turtle} having Like_button=FALSE; Android/JAVA: compiling {AL4_form} was broken;

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

#### October, 31, 2021 - version: 2.0.0
Changes: Another variant of the FOR statement added: FOR i ENUM some_method:...; which allows using methods to enumerate iterations. E.g. for databases: `DB.Open FOR i ENUM DB.Results: tabl1 << DB.CStr("Last_name") .. << DB.CStr("First_name") .. << (Now.Year - DB.CDate("Birth_date").Year).S ; DB.Close` The`DONE`statement introduced which should be used to separate ending part of statements block in a`FOR`statement which is ending with a`BREAK`or`==>` statement; E.g.: `FOR flag IN A[]: CASE flag.Color!=RED? CONTINUE flag; DONE << "first found red flag is " flag.Name #NL BREAK flag;` The block statement`SILENT:...;` was introduced to enclose blocks of code in which warnings from the compiler are suppressed; A special feature controlling types of indexed arrays is introduced. A variable or a field declared (or a parameter of a function, or a loop variable) can have an additional attribute`INDEXING type` or`INDEXING (list,of,types)` and if it is used as an index of an array item, such type(s) is(are) compare to the type of the array item indexed; While this feature is not used this just makes a warning about indexing with a variable 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 after`BETWEEN`x, before AND; In SQL queries in a list of JOIN's and in a selection list it is also allowed to insert block comments in form ---------------- 'text' which later can be used to remove some portions of the request code by some specific conditions; While compiling an SQL query`SELECT` , fields listed in the 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 BY`its alias "y". Fixes: {Form}.column_hidden: if there are more then one column aligned 'CLIENT', only the first one could be shown;

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

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

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

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

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

#### September, 15, 2021 - version: 1.8.9b
Fixes: {Memory_stream}.Write_byte worked incorrectly;

#### September, 14, 2021 - version: 1.8.9a
Fixes: While calling overloaded functions, the compiler sometimes could not find correct version of the function.

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

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

#### August, 27, 2021 - version: 1.8.7
Fixes: While optimizing code functions marked with the modifier CALLBACK could be removed erroneously; While optimizing code containing calls to overloaded functions, the code of such functions became empty;

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

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

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

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

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

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

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

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

#### April, 27, 2021 - version: 1.7.8
Changes: {DB}/Table: while compiling SQL queries, searching field names in a structures based on tables now case insensitive; {DB}/TABLE: it is allowed in table base structures to use fields of enumerated data types (in databases, these should correspond to INT value); {DB}/TABLE: it is now possible to read entire current record in a database query using a statement like `rec << Db, BY TABLE tab` (whererec- is a variable of a`STRUCTURE` 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%' Db.Open` 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 keyword`FOREVER` removed and should be replaced with `FOR, INFINITE: code;` It works exactly as the`FOREVER`worked before: it is not allowed to use`BREAK`/ `CONTINUE`, return is available only with the`==>` operator or by an exception; Important: For embedded functions RotateL || Rotate_Left and RotateR || Rotate_right semantics of parameters was changed: now the second parameter means the amount of bits involved into the operation, and the rotation is always done onto 1 bit (in the minor part of the source number, which size is given by the second parameter, other bits are not touched). Fixes: Gcc: compiling projects (non-visual) with C++ usign g++ restored, at least in Windows (together with a capability to open resulting projects in the MS Visual Studio 2010+ and compiling/ debugging in it);

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

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

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

#### March, 18, 2021 - version: 1.6.2
Fixes: Additional 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 like`CASE sender_alias? [...]:...;` in event handlers while creating those and jumping there from the Designer's form menu "Events". Aliases are added only for appropriate controls which can be handled by certain event handler (e.g. the paint event is appropriate for {Paintbox} or {Paint_lines}); IDE Designer:double click on a control on the form drawn jumps not just to the first event with the control clicked but cycles between all such events (recognizing the control by its Alias in the code); Output statement (<<):for all the concatenating expressions, which are not strings, the compiler tries to find a function Str from the scope (or system functions). I.e. now it is possible to write: `DEBUG"A="A#NL;` and this will be correctly compiled though there are no there ':', '<<' and an explicit conversion to`STR`type as in the "correct" version: `DEBUG: << "A=" A.S #NL;` {Form}:for columns aligned 'TOP'/'BOTTOM', a "property" was added`{controls_layout}: 'CONTROLS_LEFT', 'CONTROLS_RIGHT', 'CONTROLS_CENTER', 'CONTROLS_JUSTIFY', 'CONTROLS_LEFT_LAST_RIGHT'` ;

#### 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}.resize`until the first manual resize of a form); AL-IV: calling overloaded functions fixed with the first parameter which is a STRUCTURE (e.g.`A.S` , where A is a STRUCTURE e.g.`{rect}` );

#### January, 12, 2021 - version: 1.5.2
Changes: Color Commander changed to version 0.29. 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`

`` Home