ENGLISH

RUSSIAN(Русский)

 

AL-IV:    Versions history

December, 27, 2020 - version: 1.5.0
  • Changes:
     
    • It is allowed to skip ':' and following operator << in case when the quotation character is following: DEBUG "test"#NL ;
  • Fixes:
     
    • Delphi + FPC: fixes in {Thread};
    • Android/Java: generating the PUSH statement fixed (duplicating a local variable in case when LIKE / INLINE are using);
    • FPC: Compiling under Linux (Code Typhon) tested;
 

December, 20, 2020 - version: 1.4.9
  • Changes:
     
    • C#, Delphi[KOL,VCL]/FPC[Windows]: With new method {Form}.Track_submenu_items_select|ion call it is possible to track selecting menu items (which were created while tracking was true), selecting menu items for such menus lead to call the {Form} event selection_change with the menu_alias (which can be accessed also as sender_alias) set to the correspondent item Alias;
    • C#, Delphi/VCL: functions added: {Clipboard}.Files_from_clipboard, .Files_to_clipboard, .Clipboard_has_files, .Clipboard_has_text;
    • {Paint_table} calls {Form}.paint_item before and after each cell drawing;
  • Fixes:
     
    • Compiler: the erroneous appending (<<) to a read only field did not recognize;
    • Compiler: in some cases the loop variable iterating an array of items could not be modified in the loop (supposing it to be read-only);
    • Delphi: erroneous implementation of fixed arrays on other fixed arrays fixed: these are redirected to original dynamic arrays anyway as it should;
    • C#: Dismiss was not working correctly for an item of an array: resulting value was NONE;
    • C#: leakage of Thread objects fixed;
    • Delphi VCL, KOL: {Thread} fixed (destroying the controller returned by the Run method on the parent thread side, because of the second attempt to destroy the same object); also several other fixes there;
    • C#: {Paintbox} - blinking scrollbars fixed in case when the subsystem can not decide if to show or hide that scrollbars for some window size: in such case scrollbars are forced to show until the window size does not change again;
 

December, 8, 2020 - version: 1.4.8
  • Changes:
     
    • C#/{Form}.menu_item now is called also in case of menu closing not for reason when menu item was clicked (e.g. when a menu was closed because on a click out of a menu popping out), this allows to check if a menu is exposing yet ant to stop / continue some additional operations;
    • The warning about incorrect usage of the CASE ? statement in case of a single conditional branch in form [...]? is not firing now an error, such usage now is accounting as the normal case;
  • Fixes:
     
    • C#/{Paintbox}: scrollbars become invisible when the content size become less then the control size at a correspondent direction;
    • C#/{Paintbox}: a control was not redrawing in process of a mouse moving (e.g. in case of selecting text with the mouse on its descendant of the class {Paint_lines});
    • IDE/Designer: for short Alias'es of {Label} controls, the code setting such Aliases did not generate. In result, we lost all the short Aliases on all edited forms (e.g. on the IDE AL4 itself);
    • IDE/Designer: a lot of changes/fixes (uniquiness of {Label} names when creating it, corresponding its aliases to its names at creation, hiding inappropriate properties of some (unvisual) controls, generating code creating of labels and in some other cases, etc.);
    • Delphi/{Form}.key_down / key_up events - erroneously, keyboard key handling was stopping in case when the value 'DECLINE' was returned; contrary, in case of success handling of a key it was accounting as "not handled" so it was passed (by system) again, now from a control been in focus (with a correspondent value sender / sender_alias set to that control); This all could therefore handled correctly if to analyze the sender, but such behavior is incorrect basically, so I've had to fix it (though it could lead to consequences in already ready applications);
    • Delphi/VCL: {Form} - calculating sizes of controls expanding down for cases when there are following controls in a column (for columns aligned left/right/center);
    • C#/{Paintbox}+other{Paint_...} - working with scrollbars improved (fixed): more correct positions calculating using Math.Round, more correct setting LargeChange property of scrollbars;
 

November, 29, 2020 - version: 1.4.7
  • Changes:
     
    • IDE/Designer: menu to access Events and Menus moved to separate buttons in the Main menu buttons bar;
    • IDE/Designer: in case of unedited {Label} control name, its name automatically fullfilled with a very random sequence of digits (with is unique with the probability 0.999999999999...);
    • {Paintbox}/C#: the propert Handle_tab added (by default = TRUE) to control if to accept keyboard key TAB as an input character or to control tabulating between controls on a form;
    • Compiler: the option /warn80 added, when added to command line options, a warning is fired on a too long line rather then an error;
  • Fixes:
     
    • IDE/Designer: editing the text property of a control fixed (the caret moved to the start of the edit window on each input character);
    • IDE/Designer: calculating of the size of a form on base of sizes of controls and columns is fixed;
    • IDE/Class wizard: IMPORT section generation fixed (earlier it was necessary to edit it manually in most cases);
    • IDE AL4/Designer: adding #QU multiple times fixed in complex cases (concatenations of several strings): if amount of quotas is even and there are starting and ending quotas, the string is not corrected automatically anyway);
    • C#: cloning structures containing fixed array of structures, fixed;
    • Delphi/VCL: Get_working_dir did not finish returned path with the '\' character;
    • C#: tabulating with TAB key fixed on controls based on {Paintbox} ({Paint_lines}, {Paint_tabs}, {Paint_table}, {Paint_turtle}, ...);
    • C#: {Form}.enter / leave events calling are fixed (but work only for {Paint_lines} / {Paint_table} now);
    • C#: {Date}.Add_months - fixed for cases of 30 days or shorter months (.net does not correct those dates automatically);
    • Delphi: generating an assignment of an initial value to field witch is a fixed array while creating an instance of a STRUCTURE, fixed;
 

November, 21, 2020 - version: 1.4.6
  • Changes:
     
    • The option added /!platform to stop warnings about Platform dependent functions;
  • Fixes:
     
    • C#: {File_path}.Catalog in case of a root directory did not work properly w/o the trailing slash;
    • C#: for cases when in a method the objects is deleting itself before the method code ends, the automatic increase of reference counter is added on time of the method (but only for methods doing such deleting or calling functions which can do this);
    • In case of an assignment of a value to the pseudo-variable NONE, in the further using in the left side the pseudo-variable ".." (the same target), analyzing of a compatibility of the left and right sides thought that the left side is an expression of type BOOL (now there is reported thet is is not possible to assign a value again to the variable this way);
    • Delphi+FPC: generating an assignment to an item of a fixed array with bounds given by a enumeration A[{enumeration_type}];
    • Ambiguous clearing of "fixed" local arrays was removed;
    • {Date_time}.Hours_diff fixed;
 

November, 12, 2020 - version: 1.4.5
  • Changes:
     
    • IDE AL4: support added for the {Paint_table} class;
    • {Paint_table}: a function added New_paint_table;
  • Fixes:
     
    • C#: loading images (e.g. {Jpeg}.From_stream did not work properly if the class {Bmp} was not used in the application: the requirement replaced to the same but for class {Bitmap});
    • C#: code generation fixed for initializing fields which are fixed arrays of structures (arrays were generating of size 0);
    • Delphi+FPC: working with fixed arrays fields in structures is fixed;
    • Delphi/VCL: {Bitmap}.Can_load_format("GIF");
 

November, 6, 2020 - version: 1.4.4
  • Changes:
     
    • {Form}.Set_state({state} Normal\minimized\maximized); (With correct maximization without overlapping the task panel, including cases of multi-monitor systems);
    • Delphi KOL/VCL: {Form}.Set_no_frame, {Form}.Set_no_border improved (and fixed) making the form border very thin and preventing the possibility to resize it with the mouse;
  • Fixes:
     
    • {Form}.Set_no_frame(FALSE) fixed for Linux;
    • {Thread} fixed for Linux (cthread now adding first in uses clause of a dpr-file of a project);
    • Android: compilation fixed (typo in AL4_drawing.java);
    • Delphi/KOL: the event {Form}.moved did not have a handler;
    • Delphi/KOL + /$KOLGRAPHIC: the project's property SearchPath=... is provided in the dof file when project is generated, allowing to open the project generated in the Delphi IDE without manually adding a path to the KOLGraphic in the project options;
    • Delphi VCL/FPC: compilability for visual applications not having {Jpeg}, {Png} imported in projects;
 

November, 4, 2020 - version: 1.4.3
  • Changes:
     
    • Classes added: {Bmp}, {Jpeg}, {Png} to control a necessity of adding a code responsible for ability to load/save correspondent image formats from/to files/streams. Now loading of images should be written in form like:
      {Bitmap} B|... = {Jpeg}.From_stream(S, 'FULL')
      or (e.g.):
      B = {Png}.From_file(Path, 'HALF')
    • Classes {Pcx}, {Tiff}, {Tga}, {Psd}, {WebP} are added to implement reading or reading and writing of files in correspondent image formats on platforms where such image formats can be supported. Mainly, these are Free Pascal/Lazarus with the option /$BGRABITMAP on and Delphi/KOL with the option /$KOLGRAPHIC - Png can work without it in KOL); also WebP format is supporting natively on the Android platform; for {Gif} saving is possible only for target platforms C# and Delphi/VCL (with the option /$RXGIF turned on);
    • Delphi: an option /$RXGIF (it can be used in form /$RXGIF=<path>, in such case the environment variable RxLib is not used), with that option it is possible not to use  commands /COPY-BIN to copy certain files from the RxLib\Units folder: the path on the RxLib\Units folder is integrated into your project options (with the compiler key -U);
      The option /$RXGIF for the Delphi/VCL allows saving gif-files from the application;
    • For classes providing reading/writing graphic formats, functions are added Can_save / Can_load. Example of usage:
      CASE {Gif}.Can_save ?
           {Gif}.To_file(bitmap, path) ;
    • Delphi/KOL: if the option /$ICON=... is set then on (any) form creation, its icon is set to that icon automatically, too;
    • Delphi/FPC: the option /$DEFINE=aaa;bbb;ccc added which allows to pass additional conditional compilation symbols to the target compiler;
  • Fixes:
     
    • Android: compiling code for cloning STRUCTUREs containing arrays of references onto objects;
    • Free Pascal/Lazarus: option ofOverwritePrompt added for TSaveDialog created in {Dialog_file} implementation;
    • FPC/Lazarus: {Bmp}.From_clipboard fixed for /$BGRABITMAP turned on;
    • Delphi: generating of ASSERT statements fixed (cases when to create a formatted string, functions are used returning objects);
 

October, 28, 2020 - version: 1.4.2
  • Changes:
     
    • FPC: The BGRABitmap package support added on the compiler level and graphics library level: the option added /$BGRABITMAP. When it is on, the environment variable BGRABitmap_units is used access units of that package in a project;
    • It is disallowed to assign a result of a function returning a structure to the pseudo-variable NONE (ignoring the result);
  • Fixes:
     
    • Delphi/FPC: objects leaks are fixed (and memory/resources connected them too, certainly): when using as parameters of functions expressions which are calls to functions returning objects, and also when "assigning" results of such functions to the pseudo-variable NONE;
    • {Form}.mouse_wheel: speed makes similar for different platforms (C#/Delphi-KOL/VCL, FPC-Windows/Linux);
 

October, 25, 2020 - version: 1.4.1
  • Changes:
     
    • While declaring a local variable (even an array) it is allowed now to apply a function to it in the same line of code, e.g.:
      INT a|rray_of_numbers[].Allocate(20)
      STR cat|alog_files[].Get_catalog(path)
      etc.;
  • Fixes:
     
    • Compiling of visual applications under Linux restored, with Free Pascal/Lazarus/CodeTyphon, including problem fixed using DateTimePicker in case of CodeTyphon distributive;
    • IDE AL4 code adopted to last changes in the language (fixed and can be compiled and work);
    • IDE AL4 - can be compiled and running in Linux;
 

October, 21, 2020 - version: 1.4.0
  • Changes:
     
    • While scanning a numeric constant with a dot symbol, the next character is checked if it s a digit before deciding that the number is a real number. Now it is allowed to write 1.ShiftL(n) in expressions, e.g.;
    • It is allowed to use 4th level block statements CASE/FOR without adding the 'BAD' modifier to a class module. But only if it contains a single simple statement like in case:
      CASE condition ? BREAK i ;
    • It is not more allowed to use bitwise operations (&, |, ^) on the same level with arithmetic operations (+, -, *, /, %) without explicit priority specifying by parentheses;
    • {Gif} class improved and has now its non-native AL4-implementation of frames extraction/drawing (platform independent);
    • Android: The class {Global_var} has implemented for the Android platform;
    • A construction LIKE ... , EXCEPT is abandoned; The syntax and the semantics of the statement LIKE ..., BUT is changed completely: following the BUT a list of replacements should be added (comma separated in form
      (from ==> to) [* N] where N is exact amount of patterns 'from' to replace;
  • Fixes:
     
    • Declaring a local structure variable without assigning a value to it led to assigning a NONE value (in case when the structure was implemented as a dynamic object because it has some string fields, object fields or other dynamic structure fields). Now, in such cases a new instance is created and assigned;
    • C#: fixed arrays (which are fields of classes / structures) initialization was generated with the 0 size instead of specified in code;
    • Delphi/FPC: a rounding error fixed leading to drawing image offset by one pixel (in the functions Points converting points to pixels);
 

October, 11, 2020 - version: 1.3.9
  • Changes:
     
    • Additional requirements added for obligate import of classes which functions are called;
    • While overriding a method it is possible to add (via || or | symbols) additional identifiers as usual for all newly declared names;
    • The class {Gif} added to load and show animated gif-files (for this moment, C#/.NET, Delphi/VCL and Delphi/KOL are supported);
  • Fixes:
     
    • C#: if in a multi-thread application while the /debug option was on then indexing errors occur accessing the Stack_functions array;
    • Delphi: while calling a function from a class which was not imported, a code was generated which could not be compiled with Delphi. An error message was added requesting to fullfill the import list with the required class;
    • C#: loading icons and cursors (including colored cursors) provided;
 

October, 2, 2020 - version: 1.3.8
  • Changes:
     
    • C#, Delphi: a class {Array_str} added to allow working with parts of arrays of strings in threads;
    • Android: classes {Thread}, {Array} (and its descendants) are implemented;
    • A demo-application to view images added: AL4View.
  • Fixes:
     
    • IDE AL4: disappearing a single 'CLIENT' aligned column on a form in the Form Designer (if a fixed custom width was not set for the column);
    • Delphi: generating code for STRUCTURE initialyzing in some cases;
    • Delphi: resource leakage (TEvent) in the {Thread} implementation;
 

September, 19, 2020 - version: 1.3.7
  • Changes:
     
    • C#, Delphi: a class {Array} added to allow working with parts of arrays in threads (and to refuse from {Slice} + low level support of array slicing in native system code);
  • Fixes:
     
    • C#: RotateL, RotateR;
    • C++(gcc): EnumAsInt;
 

September, 3, 2020 - version: 1.3.6
  • Changes:
     
    • Help on classes: while creating html docs, formatting improved: adding images provided, prepared earlier with the Tools\Diagram_draw and inserted into a source code comments with supported IDE in format //[diagram: <diagram-name>]
      Also: fixing references to a base class in a help generated.
  • Fixes:
     
    • Gcc/Windows: console output;
    • Compiling overloaded functions: now all the errors fired while skipping not actual branches of CASE ? {{... statements in which branch selection depends on types of function's parameters signature currently compiling;
    • C#, Delphi: generating code for TRAP a field in an operation of creating a new object (with the field trapping);
 

August, 14, 2020 - version: 1.3.5
  • Changes:
     
    • Still Working under the Pascal-like syntax;
    • {Console}.Console_ANSI_colors, Fg, Bg - commands to set RGB colors are implemented/used (for Windows, nearest available console color is searching); so influence of the foreground color brightness onto a background color is removed;
    • Searching static functions was not implemented in base classes of all the imported classes. Now, this is done, so it is enough to import a descendant class to access its ancestor static functions too;
    • IDE AL4:
       
      • in the popup list of tabs, these are sorted now lexicographically rather then in the same order as in tabs;
      • dialogs on files changed/removed on disk are improved;
      • typing in lines of comments works faster (searching auto-completion variants in such case is not used);
      • loading source codes in utf-8 encoding without BOM improved;
    • {Paint_turtle}: commands nnnC, nnnA added to rotate on an arbitrary angle (with the accuracy to 1 degree);
    • Help on classes: while creating html docs, formatting improved, and definitions for classes? methods etc. is extracted from comments in source, taking into account the destination locale (if a desired locale did not found, the English comments starting from //-EN are used);
  • Fixes:
     
    • Gcc/Windows: console output;
    • Compiling overloaded functions: now all the errors fired while skipping not actual branches of CASE ? {{... statements in which branch selection depends on types of function's parameters signature currently compiling;
 

August, 4, 2020 - version: 1.3.4
  • Changes:
     
    • Still Working under the Pascal-like syntax;
  • Fixes:
     
    • C#: mouse_wheel returned too low value of vertical wheel in case of high-density mouse (Microsoft);
    • Gcc: fixes in code generation (structures, arrays of structures);
 

July, 28, 2020 - version: 1.3.3
  • Changes:
     
    • System functions (like Clear, Count, Index, ...) now can be recognized when typed in upper case and used in classic "prefix" notation ( Count(A[]), CLEAR(A[]), INDEX(S), Delete(A[], N) etc.);
    • System function added: ALLOCATE(A[], INT New_size);
    • Adding visual components {Paint_tree} (similar to TreeView) and {Paint_table} (similar to ListView in the detailed mode);
    • Working under the Pascal-like syntax and on migrating the old projects to the AL-IV using such mode:
       
      • The capability added in an arbitrary expression to replace an arbitrary identifier onto another one in form
        Ident1{@Ident2};
      • The capability added to extend a unit name with additional names providing the possibility to the main unit class to have a name different from its unit name, e.g.:
        unit unitMainSF{@||FormMain|SF};
      • A class type itself can also be found in class functions including the case of the Pascal-syntax (without case sensitivity);
      • Functions, fields, constants can be found without case sensitivity both in cases when the using unit is written in Pascal and things are used from such unit;
      • Working started on adding capabilities to migrate KOL/MCK projects to the AL-IV;
 

July, 20, 2020 - version: 1.3.2
  • Changes:
     
    • Improvements in recognizing the Pascal syntax;
       
      • conditional compiling directives (*$ifdef al4*) and ... (*$else*) ... (*$endif*) can now be used in almost any statements and even in expressions (but directives itselves must be placed in separate lines of code);
      • Fixes in conversion of statements if ... else if ... else if ... and case ... of ...;
      • The uses clause in the implementation part is also handling;
    • Real instructions added on conversion of an existing Delphi project to the AL-IV using new feature allowing Pascal syntax recognizing with the AL-IV compiler (see How to start programming on AL-IV, APPENDIX 2. AL-IV: Gradual switching to AL-IV in an existing project)
 

July, 15, 2020 - version: 1.3.1
  • Changes:
     
    • Changes in recognizing the Pascal syntax;
       
      • conditional compiling directives are used: (*$ifdef al4*) and (*$ifdef al4code*) ... (*$else*) ... (*$endif*) to switch between the Pascal code, The Pascal code for the AL-IV final project, and The AL-IV code inserted as is to the final AL-IV code of the unit converted;
      • Definitions Delphi_units_to_al4.convert and Delphi_types_to_al4.convert are moved to files (and all such files are used from all the source directories);
      • Amount of warnings are reduced a lot for the code created from the Pascal while converting it to the AL-IV automatically;
      • The small student game project "Glazomer" was converted from the Delphi/VCL to to AL-IV (but without sound support and not completed for the Android - though it can be uploaded and started there);
    • {Bitmap}: loading images not from files only but from {Stream} too (bmp, png, jpg, gif - set of formats supported yet depends on a destination platform);
  • Fixes:
     
    • Some fixes in automatic code transform from Pascal to AL-IV;
    • Delphi/VCL: {File_path}.Recycle;
 

July, 3, 2020 - version: 1.3.0
  • Changes:
     
    • A capability added to define constant arrays with items of base types (BOOL, BYTE, INT, REAL, STR);
    • Syntax: "clean" declaration of a local variable in a function no more accounted as a simple statement, so it does not affect the count of simple statements which is restricted by 7 for a block of code;
    • A capability added to recognize the syntax very like to the Pascal (by adding a specification [SYNTAX="PASCAL"]. The Pascal code is converted almost mechanically to the AL-IV syntax and then it is compiled as usual. Some ease rules are working which allow to use earlier written Delphi/Free Pascal units (may be slightly modified though, in a manner allowing still to compile it in frames of an existing project, so it became possible to migrate progressively legacy projects from the Delphi/FPC to AL-IV and to all supporting by AL-IV platforms);
      Note: these works are not yet finished: it is required to add a form designer, improve the translation on real projects, draw the documentation etc.
  • Fixes:
     
    • Optimizations: union of two local variables makes not possible if the second (later) variable first is used (assigned) in a CASE / FOR statement (otherwise it could be possible that it is not correctly initialized, i.e. it is initialized by the last value of the first variable in the pair);
    • Dok_sources\make_docs: generating help on classes fixed/improved;
 

June, 21, 2020 - version: 1.2.0
  • Changes:
     
    • IDE/Project wizard: the capability added to use the option /[section] and to place options for all the compilers in a single configuration file;
    • The small revision for the statement CASE ? {{...}}: ... ... of conditional compiling depending on a parameters type signature for an overloaded function: it is required to specify not only a number of a signature but entire signature '/'-separated, e.g. {{1/INT/INT, 2/REAL/REAL}};
    • It is disabled to use a FOR loop variable a STRUCTURE variable, i.e. it disallowed to use in FOR statements arrays of structures to enumerate on it: it is required to convert such loops to usual FOR loops on a range of indexes and to extract a structure item using either Clone or Discard function;
  • Fixes:
     
    • C#: compiling Clone() functions for fields of STRUCTUREs which are "CLUMPed" arrays;
    • Delphi: compiling code for fields of STRUCTUREs, which are fixed arrays (including very dangerous bug with indexing in fixed arrays based on other fixed or dynamic arrays and on native arrays);
    • Problems compiling X.Y...Z = W operators (fixing target object X.Y for further assignments to its fields in form ...Z2 = W2 etc.);
    • Compiling functions with the DEBUG modifier: while searching functions imported classes with the DEBUG modifier did not looking for;
    • Delphi/FPC: some memory leaks fixed while working with STRUCTUREs and secondary fixed arrays;
 

June, 10, 2020 - version: 1.1.1
  • Changes:
     
    • Class {Socket} added (supporting TCP/UDP protocols for all the platforms and languages - tested for TCP already - UDP partially is not implemented or tested);
    • Gcc: new option /$L=name added allowing to link with additional libraries (such as wsock32);
    • Android: options added : /$permission.INTERNET, /$permission.CAMERA and more (totally about 100 permission options), to request certain options for the application compiled (and additional options can be added to the code generation class is necessary);
  • Fixes:
     
    • Delphi: generating RTTI code fixed;
    • {File_path}: mismatch between different platforms code fixed;
    • FPC/Lazarus: compiling {File_path}.Recycle for elder versions of the Lazarus (1.6);
    • Gcc/Linux: compiling the compiler;
 

June, 4, 2020 - version: 1.1.0
  • Changes:
     
    • A requirement to restrict function parameters amount by 3 is cancelled (it is not required to add the 'BAD' modifier to a class using non-native functions with more then 3 parameters);
    • A requirement introduced while calling non-native function with large amount of parameters to use starting at least from the 4th parameter an assignment form Name = value to pass those parameters (and it is allowed to use such form starting from any earlier parameter);
    • A capability to create overloaded functions having parameters with several data types, e.g. FUN Find_index_max({BYTE,INT,REAL,STR} A|rray_to_search_max, INT Start|_from, INT Last|_index_where) ==> INT или FUN Max({INT,REAL,STR} A|_parameter1, {INT,REAL,STR} B|_parameter1) ==> {INT,REAL,STR};
      To allow to write a bit different code depending on a types signature, a conditional statement provided in a special form, e.g. CASE ? {{1}}: ... {{2,3}}: ... ;
  • Fixes:
     
    • C#: working with {Bitmap} loaded from an indexed pixels format image (gif). The functions GraphicsFromImage did not work, fixed by recreating the Bitmap object of the same size and drawing the image loaded on it;
 

May, 31, 2020 - version: 1.0.11
  • Changes:
     
  • Fixes:
     
    • C#/Interpreter: while creating an object, there was no taken into account that some values could be assigned to intermediate variables, in result such values mistakenly were assigned to the first field of an object/structure;
    • C#/Iterpreter: parameters passed in the option /param [...] were not passing to the application interpreting, it mistakenly used parameters passed to the interpreter itself;
    • Compiler: if the variable type (which was a structure or an enumeration) was specified in form {Class}.{type}, then the compiler did not check if such type and class are exist, in result the embedded type BOOL was assigned if the class {Class} was not imported or there was not a type {type} defined in it;
    • {Bitmap}.Bitmap_from_clipboard: Width and Height for the image object obtained from the clipboard were not set to correct value (value 1 was returning - though the image could be drawn on a canvas, saved to a file etc.);
    • IDE AL4/Class wizard: some garbage in the IMPORT section;
    • IDE AL4/Form Designer: generating parameters for the menu_item event handler - not needed, the remnant of the abandoned "menu" event;
    • Compiling of the self-compiling compiler chain is restored (again: after some last re-structure in the library code compiling chain [ALIV.csproj in the MSVStudio] ==> [_1_compile_cs_(by_Primary).cmd] ==> [_1a_compile_CSharp_build_(by_Compiled).cmd] became not working - though this was not preventing to use the compiler from the archive distributed).
 

May, 24, 2020 - version: 1.0.10
 

May, 21, 2020 - version: 1.0.9
 

May, 20, 2020 - version: 1.0.8
  • Changes:
     
    • Delphi/VCL: code of the class {AL4_form} is cleaned from {$ifdef / ifndef FMX, ANDROID, MOBILE_...};
    • Delphi: small code generation optimizations (smaller size of resulting executable);
    • {String_functions|_common} part united from different paltforms, where these are replaced with {NATIVE_String_functions} containing only different stuff there;
    • ABSTRACT classes not having descendants or ancestors do not more require initializing NONE-objects (usually these are classes just having functions and not purposed to have instances);
  • Fixes:
     
    • C#, Delphi: {Fake_parameters}: compiling problems for projects using file associations and \ or files drop from the explorer-like applications;
    • IDE: when file was changed on disk by anorther application, the IDE saved its own version overriding those changes (though it shown a dialog to load changed variant therefore its own version was reloaded again);
    • {Checkbox}: a problem compiling with radio-groups used (the radio_select method was moved from the class {Form} but it was not checked for compiling it;
 

May, 16, 2020 - version: 1.0.7
  • Changes:
     
    • All the functions and types concerning console are moved to the separate class {Console} (from {System_functions});
    • Functions added: {Console}.Console_ANSI_colors(BOOL), Support_console_ANSI_colors ==> BOOL, Fg|Foreground_color_console|Escape_sequence({colors}), Bg|Background_color...({colors}), Con|sole_special_color_control({special_con}). The last 3 are to use in the right side of the << statement, e.g.:
      << 'SAVE'.Con 'RED'.Fg 'YELLOW'.Bg "ERROR!" 'PREV'.Con #NL
      (But there is not supported in the Android);
    • All the functions and data types to work with low level hardware (processor, memory, disks, power) are moved from the {System_functions} to the (new) class {Hardware};
    • Delphi/FPC: code generator reworked, in result output executable size became smaller several Kbytes;
  • Fixes:
     
    • Delphi/KOL: forced attaching {System_functions} unit abandoned, executable size starting again from 9 Kbytes;
    • Free Pascal: Replace - fixed for case of inconsistent values like 0xA0;
    • Free Pascal: the {Button} is creating with AutoSize=true, if the parent column is aligned 'TOP' / 'BOTTOM' (this fixes buttons with long text);
    • Compiling project with option /$ALLTESTS did not work if there were no tests in project modules;
 

May, 7, 2020 - version: 1.0.6
  • Changes:
     
    • Compiler: a parameter /[section] added, allowing to filter from the specified (given by the option /@ path) configuration file only certain section; If not used, only the first not named section is used; This option allows to shorten amount of configuration files used to launch compilers;
    • It is allowed in names in enumeration items to use the character "-":
      'some-item-with-minus-in-name';
    • It is allowed to use empty parentheses to call a function not having parameters (or its single parameter became a prefix):
      foo()
    • Compiler: it is allowed to a friend class (FRIENDS) to write / append values to "read-only" fields of an object of the source class;
    • Compiler: it is disabled to pass a structure to a native function as parameters / return as results;
    • Compiler: the NEW modifier for a function returning not an object class is treated as an error;
    • Delphi/VCL, Free Pascal/LCL (Windows): centering file open/close dialogs, {Form}.message dialog;
  • Fixes:
     
    • Interpreter: running some projects was fixed (the problem was due to native functions with STRUCTURE parameters);
 

April, 22, 2020 - version: 1.0.5
  • Changes:
     
    • {Scene|2D} - actually finished (the Test_paintbox is moved to use it);
  • Fixes:
     
    • Delphi/Free Pascal: code generation for creation of STRUCTUREs - fields referencing objects were not initialized, cloning of arrays of simple structures did not work;
    • Java/Android: initialization of structure fields fixed in objects and structures;
 

April, 21, 2020 - version: 1.0.4
  • Changes:
     
    • {Bitmap}: function Bitmap_from_clipboard ==> {Bitmap} was added;
    • A control added: {Scene|2D} to draw "offline" (creating "objects" which are graphic primitives which further are shown without calling the paint event of the {Form}); additionally, the animation is also can be figured out there specifying for primitives their time range of existing, initial and final coordinates, sizes and rotation, and its moving is performed automatically; this time working under the {Scene} still is in the beta stage and continuing;
  • Fixes:
     
    • Delphi/KOL: additional checks was added on validity of a Bitmap / Canvas in {AL4_drawing} native implementation;
    • Java/Android: projects compiling is restored (some new functions required changes in {AL4_form}, {AL4_drawing});
 

April, 15, 2020 - version: 1.0.3
  • Changes:
     
    • The {Zlib} class was added to compress / decompress files (only C# now, using its DeflateStream embedded class, available from the Framework 4.5);
    • C#: recognizing in options of values $FRAMEWORK=4.5 / 4.5.1 /4.6.1 was added;
  • Fixes:
     
    • Delphi/KOL: multiple handling of the {Form}.mouse_wheel event;
    • CONST REAL: in case of an integer (in form) value, actually 0.0 was used;
    • Delphi/VCL, Delphi/FPC: problems with forms minimizing to taskbar rather then iconifying them (like in windows 3.x);
    • Free Pascal: {Bitmap}.Load_png (though w/o transparency);
 

April, 4, 2020 - version: 1.0.2
  • Changes:
     
    • As a demonstration & practical (and useful these days) the open source project started Draft Notes to help students listening online lectures / courses / seminars / web conferences etc. The application allows to capture a specified area of a screen, store it as an image via just a click/tap and quickly add notes in form of sketch drawings, lines, text writings. It is supporting both working on a big monitor or in multi-monitor configuration, and on a single monitor using keyboard, touch screen, graphics tablet, mouse etc. The final application contains about 1200 lines of code on the AL-IV and can be compiled with all the supported target compilers (including the FPC for Linux and Java for Android - but in the last case it is necessary to work additionally to implement it working with a camera rather with the screenshots).
          In case of C# it works slower a bit. In case of Delphi works faster and supports all the Windows platforms. In different configurations (depending on a target language/platform) different sets of graphic file formats are supported  (not for all platforms supporting of gif, png are provided yet, and in case of non-Windows supporting its .bmp is doubting).
          For this moment the application is published as a separate open-source project by the reference:
      https://sourceforge.net/projects/draft-notes
    • The capability added to compile with the FPC under Linux via fpc gained after installing the CodeTyphon IDE. To do so:
       
      • in the compiling options (while compiling AL4FPCCompiler for the Linux OS) on the Windows side it is necessary to specify the parameter:
        /$LINUX_LAZARUS_HOME=/usr/local/codetyphon/typhon/
      • as usual on the Linux side it is necessary to create the environment variable $LAZARUS_HOME with the same path as the value
      • and additionally to append to the environment variable $PATH the path to the fpc from the CodeTyphon:
        PATH=$PATH:/usr/local/codetyphon/fpc/fpc64/bin/x86_64-linux/
        export PATH
  • Changes:
     
    • Small additions:
       
      • {Form}.Set_mouse_cur|sor_position;
  • Fixes:
     
    • Delphi: small fixes in libraries (like in the function {Form}.Client_size);
    • Delphi/VCL: minimizing forms only to the taskbar, not to a corner of a screen;
 

March, 29, 2020 - version: 1.0.1
  • Changes:
     
    • The rule ignoring "empty" input >> while testing is abandoned.
    • Generating applications for the Linux using gcc:
       
      • the compiler AL4->gcc can be built on Windows and Linux using the compiler AL4->gcc created with AL4->C# compiler;
      • it is now possible to create console applications from 34 Kbytes in size;
 

March, 20, 2020 - version: 1.0.0
  • Changes:
     
    • A prohibition was added to use on the same level in an expression to call functions with potential side effects (including recursive functions), and to use object fields (i.e. it is disabled to call two such functions or one such function and to access a field at the same time). And this rule is extending on the case when a value is added to an array which is a field of an object, and the value adding is calculated using mentioned functions. This evil rule is guaranteeing that the final code will working correctly independently of a target language preferences in operands order calculation.
  • Fixes:
     
    • Compiling for Delphi/Free Pascal with optimization on (using dynamic arrays could not be detected);
       
 

March, 18, 2020 - version: 0.99.9
  • Changes:
     
    • Compiling to C++ partially restored (with gcc: under Windows only console applications can be compiled, under linux both console and GUI(X11) applications are planned to work). Minimal sizeof the application Hello_world is about 85KB (MinGW/Windows). For this moment, only console applications for Windows can be compiled yet;
    • IDE/Designer: a capability added to drop dragging controls as the first control in the target column (before the first existing one);
    • An utility Tools\File2Hex to translate binary file to lines in a hex format (to insert into a class code after the END statement and using at running time to extract the binary file from hex lines e.g. to restore graphical resources used in the application);
  • Fixes:
     
    • IDE/Designer: drawing made better in modes "Show control names", "Show aliases";
    • IDE: translation to Russian language fixed/completed;
 

March, 3, 2020 - new version: 0.99.8
  • Changes:
     
    • {Form}.new_column: a capability added to create a column nested to already created column (in a position of a an arbitrary component); The support of the feature can depend on a target platform. If the feature is not supported on a platform then the column is therefore created as usual, based on its creation disposition and the aligning specified. At the current moment, C#, Delphi/VCL, Free Pascal and partially Android are supported only. But Delphi/KOL is not yet;
    • IDE/Designer: a capability added to control parameters Nested and After_control which allow to specify after which component on the form the nested column should be inserted;
  • Fixes:
     
    • IDE: fixed reloading file changed on disk by another program or another instance of the IDE;
    • IDE/Designer: the combo to select visually column aligning was disappearing by unknown reason, restored;
 

March, 1, 2020 - version: 0.99.7
  • Changes:
     
    • IDEAL4: totally separated from the compiler code (less size, faster compiling); a lot of changes followed in directories structure of the entire AL-IV project, so do not forget to clear the directory before unpacking the distributive);
  • Fixes:
     
    • Free Pascal/Linux: slow working fixed for case when the compiler is working on a shared (from another PC) directory;
    • {Form}, {Dialog}: while a modal dialog is shown in result of handling 'menu_item' event, all the events in the parent form received an incorrect 'sender' [in IDE this leaded to not correct drawing of the Editor window while the About dialog is shown or the font select dialog];
    • Interpreter: capability to be compiled/to run restored including working on visual projects (like Lines, OpenGL demo);
    • IDE/Designer: incorrect string could be generated in the CONSTRUCT code while editing multi-line values of comboboxes;
 

February, 27, 2020 - version: 0.99.6
  • Changes:
     
    • IDE/Designer: a capability added to select several components on form (not columns though) using SHIFT + click or SHIFT + drag; and to move selected components to another place on a form using mouse;
  • Fixes:
     
    • IDE/C#: even less flicks in the Form Designer;
    • Free Pascal/Linux: a possibility to compile the compiler for the Linux is restored (again), and it is can be used to compile existing demo applications under Linux directly;
 

February, 25, 2020 - version: 0.99.5
  • Changes:
     
    • IDE/Designer: a capability added to create an automatic class extension for a form/dialog to simplify initial form components setup or getting its resulting values to a structure. And to save form's data into a {Configuration} and restore those back from a {Configuration}. After creating the extension class (in the Designer menu: File|Create {Ex_ class), it is further automatically updated together with all the changes in components in the Designer;
    • {Dialog}.Show_modal -- it works now in the classic style of the modality returning a resulting string immediately at the call point. This works so now for all the supported platforms (C#, Delphi/FPC, Android). And the event method {Form}.answer is not required. If it is necessary to provide compatibility with the old code with minimal efforts, it is sufficiently to turn the answer OVERRIDE to the METHOD and call it following the Show_modal call;
    • {Dialog_file}/Android: a minimal dialog provided to select a file to open or write (in an area available for the application, in the internal device memory, or on external SD-card);
    • Syntax changes: Parts of a string constant, bounded with double apostrophes can now be placed in any place of a long string, everywhere in place of a usual substring in quotations "..." (the only difference that a substring ''...'' can contain quotation " symbols treated as usual characters);
  • Fixes:
     
    • {Long_operation} restored for C#, Delphi/Free Pascal;
    • IDE/C#: less flicks in the Form Designer;
    • C#/compiler: a problem fixed with scanning a multi-line string constant containing strings in double apostrophes ''....'';
 

February, 21, 2020 - version: 0.99.4
  • Changes:
     
    • Delphi/Free Pascal: structures having only simple data fields, are implemented via records (higher speed, less memory consumption);
  • Fixes:
     
    • Optimizations: some optimizations fixed concerning in-lining functions;
 

February, 19, 2020 - version: 0.99.3
  • Changes:
     
    • Compiler (speedy): testing is provided only for classes changed from the last successful testing (or importing such changed classes); If there are no classes to test, the testing stage is skipping;
    • Compiler (slowing): the option /$ALLTESTS added which requires compiling and running all the tests;
    • Scenarios was removed from the language (SCENARIO, WAIT, GOTO, CALL);
    • Separate FRIENDS statement was removed; the modifier FRIENDS was added for the IMPORT statement;
  • Fixes:
     
    • Delphi: code generator could split too long lines onto parts ignoring presence of line ending comments //...;
    • Delphi: class name is now adding to the end of a final structure name to provide its uniqueness in the project ending code;
    • Delphi: memory leaks fixed while working with structures;
    • Free Pascal: with the optimization turned on too long variable names could be created for temporary variables preventing the compiler from correct working;
 

February, 15, 2020 - version: 0.99.2
  • Changes:
     
    • Adaptation of the compiler to new STRUCTURE finished. Elder declarations RECORD / OBJECT do not supported from now. All the code which is not yet adopted will be adopted by the time;
    • The MAXLEN|GTH modifier also is not more supported for string fields of structures;
    • IDE: With the CTRL+Enter, it is now possible to jump to the referenced block directly;
    • IDE: showing a name of a current function (or another top level declaration) added which header is out of view due scrolling the code (in place of the top line but only if the caret is not in that line);
  • Fixes:
     
    • IDE: Undo operation could undo "all";
    • IDE: jumping to data type declarations, enumeration items by CTRL+Enter;
 

February, 12, 2020 - version: 0.99.1
  • Changes:
     
    • Working under adaptation existing demo-, test- and tool projects to the STRUCTURE declaration which soon will replacing RECORD and OBJECT declarations totally; For now, almost in all projects both RECORD and OBJECT declarations are replaced with the STRUCTURE;
    • For expressions containing new objects creations it is provided a temporary variable into which a new object is assigned first. But in case of multi-branch CASE it is disabled to create new objects (both of classes and structures) in its branch conditions;
  • Fixes:
     
    • Optimizations:
       
      • when turned off (/op -) all the optimizations could be applied therefore;
      • inline optimization turned off for << statement (appending to an array);
      • inline optimization turned off for assignments in which the left side variable is used also in the right side expression;
      • Delphi: removing classes containing structures, cancelled;
      • Java: renaming local variables while merging (the V5 optimization) was creating not enough unique names;
 

February, 08, 2020 - version: 0.99.0
  • Changes:
     
    • The STRUCTURE declaration introduced into the AL-IV language to declare structures which are similar to OBJECT but guarantees only a single reference to it allowing to use it like a RECORD. In near future the STRUCTURE will replacing both RECORD and OBJECT, and then these two will be removed).
      The project Demo_projects\100 is using as a probe, together with used in it classes/structures;
  • Fixes:
     
    • IDE (designer):
       
      • problems generating an Alias with text in quotations separated in different lines;
      • setting the checkbox "Custom size" when a component or column is selected on a form;
 

February, 04, 2020 - version: 0.98.9
  • Fixes:
     
    • C#/Interpreter: compiling of the Interpreter restored (there was a mistype in the DB.al4 file, absence of appending a new object to an array specified >>, incorrect working with RECORDs leading to overwriting the initial record, some other fixes);
 

February, 03, 2020 - version: 0.98.8
  • Fixes:
     
    • Android: {Dialog} -- working of modal dialogs restored; Also: correct ending a modal dialog via the (hardware) BACK button also provided (with the negative answer by default);
       
  • Changes:
     
    • {Edit}, {Memo}, {Paint_lines}: options added which control on a component creation its additional functions of input in the Android (suggesting words while typing, entering only numbers and phone numbers, entering the caret return symbol in {Memo});
    • IDE: Correspondent options are added in the Form Designer for {Edit}, {Memo} and {Paint_lines} classes;
 

February, 02, 2020 - version: 0.98.7
  • Fixes:
     
    • Android: {Form}.popup_menu did not work in case of the last active (or created) column aligned 'TOP'/'BOTTOM';
    • Android/Java: real numbers representation using function Str or S_float was cutting to 5 decimals in any case;
    • Android/Java: setting size for functional visual components (based on TextView) was implemented via functions Set_width, Set_height, Set_size;
    • Android/Java: scrolling now works for {Listbox};
    • Android/Java: the selection_change for the {Listbox} component is implemented;
    • Android/Java: in {Memo} it is provided entering caret return character;
    • Android/Java: {Form}.popup_menu - a visual checkmark is provided for "checked" menu items (having ",checked" before ":" in the item definition);
    • Android/Java: working of "console" applications improved (see Demo_projects\15);
       
  • Changes:
     
    • Android/Java: the option /$NOTHREADS was added - when specified, all the events are running in the UI thread directly. This option is designed for use in applications which either have not high processor load calculation or providing separate threads for those by themselves;
    • Android/Java: functions implemented: Get_char, Char_ready.
 

January, 30, 2020 - version: 0.98.6
  • Fixes:
     
    • Java/Android:
       
      • onPause() is handled calling the {Form}.closed event  (allowing to save state);
      • in the AL4_form.java function was lost: Is_keyboard_key_pressed - the stub was added;
      • Console_app.al4 was copying not in UTF-8 encoding so if classes were not named in Latin, the compiler failed to compile a project. (Now test project _Russian_code works);
      • _Test_clipboard did not work due failing accessing the Clipboard from non-UI thread, solved now;
      • in the internal implementation of the class FixAByte method copy() was not implemented, in result ComplexTest could not compile;
      • the optimizer successfully removed pop-methods (of methods used in the PUSH statements), in result code could not be compiled when the optimization was on;
      • the optimizer successfully removed local variables of inlined functions without taking into account that these can be in use. In result, code could not compile sometime;
      • references onto data type of kind OBJECT and to NoneObj variables of such types, so code was incorrect and could not compile in case of presence of such variables in the code;
      • mouse_double_click event calling was added for case of a double tap (with less then 400 ms between two taps);
      • clearing old the forms list added in the event onStart (of the Androind activity lifecycle): this removes those old forms from the system menu and prevents application crash when calling those forms;
      • Java/Android: implementing of calling of several system functions added which earlier were not implemented (for a time without testing it deep);
      • Same place: calling of the system method Insert was fixed for case of arrays of RECORDs;
      • Same place: calling EnumAsInt fixed (calling Int for an enum value);
      • scenarios are implemented too (demo game Tic-Tac-Toe is working on Android now);
      • the value_change event (and correspondently Any_change) did not call if there was no such event handler overridden in a user form;
      • {Form}.key_press - result returned by the event handler was interpreted incorrectly (filtering input contrary to the desired);
      • {Form} - the height of a column can not be less then the bottom position of the most bottom nested component on it (at least the form becomes to be scrollable down);
    • Optimization: inline insertion foxed for array parameters;
    • The compiler: while creating an instance of a class (or object), it could not be possible to specify an object of the OBJECT kind as an owner;
    • The compiler: there was no a check of ending point in case of a short function in the assignment form:
      FUN square|_of_X(REAL X|_argument) ==> REAL : = X * X .
    • C#: generating code for a CASE statement placed in a LIKE block;
    • C#: {File_path}.Catalog_detailed - sub-directory names were not stored in a resulting list of {file_detail} items;
  • Changes:
     
    • Java/Android, mode /$CONSOLE: soft keyboard now shown only by click, not in result of scroll/pan operation;
    • Java/Android: debug output removed from the stab Console_app code;
    • Java/Android, {Paintbox}: red frame removed while showing pan status (by white thin rectangles on the box edges);
    • Java/Android: it is possible now to specify a png icon for an application (the option /$ICON=file.png);
    • Java/Android: big re-mastering of the visual support: all the events now working in the background thread allowing normal UI functioning during extensive calculations in the code;
    • Java/Android: option /$ORIENTATION=... implemented for values in the android manifest android.orientation (portait/landscape);
    • C#: {Bitmap}.Capture_screen now allows to capture semi-transparent windows (this option is not available in Windows for Delphi/Free Pascal);
 

January, 18, 2020 - version: 0.98.5
  • Changes:
     
    • Working under the visual components library to run applications on the Android and for the compiler AL-IV -> Java/Android is continued. Now basic functions of the {OpenGL} are working OK on the Android devices. Test application GL_program_demo - 227 KBytes.
    • IDE: popup menu on tabs (by RMB) contains groups by words from class names of loaded files allowing to switch to a desired tab quickly;
  • Also:
     
    • the instruction on using compilers AL4\about compilers - read me!.txt was fixed and completed, and any text about no more supported platforms (C++, Java/awt, DelphiRADStudio, Python) was removed.
 

January, 15, 2020 - version: 0.98.4
  • Changes:
     
    • Working under the visual components library to run applications on the Android and for the compiler AL-IV -> Java/Android is continued. Now {OpenGL} is working partially on the Android devices.
    • {Form}: internal changes in provision of the 'sender', 'sender_alias' to events: in the 'paint' event when the sender is of the class {OpenGL}, the sender==NONE, sender_alias=="Alias" of the source {OpenGL} component (since the asynchronous nature of the opengl on the Android platform);
    • Syntax: there is no more warning about parameter names starting from lower case letter in non-public (private) functions.
  • Fixes:
     
    • Delphi: operation of data type casting object.{Class} did not work correctly in case of more then one derived classes in an inheritance chain;
    • FPC: {Bitmap}.Capture_screen in Windows now can capture any part of entire desktop in multi-monitor configuration;
  • Also:
     
    • Mass testing / fixing problems for all the (visual) projects on all the supported platforms (C#, Delphi/KOL, FPC, partially Java/Android), since there were serious changes in the low level code ({Form}, {AL4_form}, {AL4_drawing} etc._).
 

January, 7, 2020 - version: 0.98.3
  • Changes:
     
    • Working under the visual components library to run applications on the Android and for the compiler AL-IV -> Java/Android is continued. Now visual applications can already work, with saving/restoring it state (using event 'closed' of the main form to store state and restoring the state in the after_construct method). The main menu (called on button '≡' is overridden using the PopupMenu (still standard system menu sometimes is not shown for some reasons). 
    • Small changes in {Long_operation} class:
       
      • Its method Indicate has now a BOOLean parameter (when TRUE, all the window messages in queue are processed);
      • The {Long_operation} form is initially created hidden and shows only if more then 2 seconds occur still last call of the Indicate;
  • Fixes:
     
    • Delphi: temp local variable of type OBJECT were not initialized;
    • More checks of accessing to (already or yet) not  existing controls;
 

January, 4, 2020 - version: 0.98.2
  • Fixes:
     
    • Problems typecasting OBJECT to {Object}, comparing OBJECT with NONE;
    • Optimization problems:
       
      • optimization by merging local variables (assignments internal to expressions were not  taking into account);
      • undesirable removing CALLBACK-functions (and its overrides) could occur;
    • C#/{File_path}: small fixes in Create_dir (checking for empty name)
    • C#, Delphi: File_detail (time is corrected to the new format used: milliseconds from the epoch time);
    • IDE AL4:
       
      • Class wizard: Incorrect base class name checking;
      • Form designer: incorrect analyzing layout 'CENTER' for the new_column (in result, centered columns were removed appending all its controls to the previous column);
      • Operation Ctrl+' fixed (enclosing selected lines into quotes/contrary operation removing quotes from selected lines): since syntax was changed and double apostrophes are allowed to enclose a separate line (allowing to use double-quote symbol directly), and formatting improved while operating;
 

January, 02, 2020 - version: 0.98.1
  • Changes:
     
    • Working under the visual components library to run applications on the Android and for the compiler AL-IV -> Java/Android is continued.
       
      • Compiling and executing of console applications provided. Actually the stub application Console_app is embedding as the main class of a resulting console applications, creates the text window on base of the {Paint_lines}, redirects console output and input onto its own functions and launches the console application in a separate thread. There is a color text output provided, automatic layout changing in case of screen rotations, automatic scroll to the last line of text output etc. Console applications can be used to run tests (the option /$TEST of the compiler);
  • Fixes:
     
    • Compiling and running applications and the compiler the Lazarus/Free Pascal is provided both for Windows 32/64 and Linux 32/64;

 

 

Previous versions history (2019)

See here  

 

Previous versions history (2018)

See here  

 

Previous versions history (2016-2017)

See here  

 

 


Home