Mouse_BreakPoints .
Dynamic BreakPoints
When you Double-Left-Click in the Editor margin -on the very first space- a Float Menu offers you one or several Items, depending on the existence of previous Mouse-Defined-BreakPoints.
Set BreakPoint
Delete BreakPoint
Delete all BreakPoints
(You can also get this Float Menu by [F4]).
When you Set a BreakPoint that way, a Mark is shown in the Left Margin. Such Marks are used by the Debugger to insert an INT3 at the matching position, into your Code. The effect is nothing but what you would get, when writting some 'INT 3' or 'INT3', by yourself, but the corresponding 0CC Byte(s), for INT3(s) are not in your Source. Instead, the Debugger entirely manages them.
You can delete an existing Static BreakPoint individualy, by Double-Clicking again on the margin Mark.
Once you have set BreakPoints that way, you can move inside you source as usual, during the debug session, after execution of the BreakPoint. You can also insert/remove BreakPoints, but you can not edit your Source.
For more, see: Debugger.
~~~~~~~
Tag feature .
The Tag implementation's purpose is to execute pre-defined actions from inside the Source Editor, by a simple Right-Click on a Tag Comment. This feature is only valid as a comment, in order to not add any reserved word into RosAsm's syntax. It is case insensitive and the Numbers are Decimal only.
Any kind of instant actions can be implemented that friendly and easy way. Actually implemented:
; Tag Dialog 1000
We suppose, here, that you have some Dialog in PE Resources, with an ID value set to 1000.
In the Source, you can insert a comment like the one above . Once done, if you Right-Click on ''Tag'', the desired Dialog will directly be launched into the Dialog Editor. It might be a good idea, when you write your 'Proc DialogProc: ', for example, to insert such a comment right above. This will save you from having to recall the Dialog ID, from having to search (in cases of many other Dialogs, in the Application), and to quickly and simply switch, in the Click time, from the Source Edition to the associated Resource Edition.
; Tag Wizard Form 'Path...........'
This Tag is built automatically by a Wizard (actually, only the Form Wizard), when it pastes back the Wizard Edition into your Source.
Once the Wizard Edition Source is pasted, a simple Right-Click on 'Tag' will re-run the Wizard, for a re-Edition.
; Tag End
Is just an End-Mark, used by the Wizard to know where the Wizard Edited Source ends.
; Tag Unicode LabelName
RosAsm sources Editor is Ascii only. Right-Clicking upon this Tag runs a Dialog devoted to the Unicode String Declarations.
If no Data matching with LabelName is found inside your Source, this feature will paste it, when back from Edition. If some matching Data is found, it is loaded into the Unicode Editor, for re-edition, and the substitution is done automatically, when you close the Dialog. This dialog offers a Button for defining the display Font. Do not forget to select the proper Script, at the bottom of the ChooseFont Dialog, if required.
When back from editon, the Data looks like this:
; Tag Unicode LabelName
[LabelName: U$ 0xxxx, 0xxxx, 0xxxx,..., 0 LabelNameNchars: D$ 027]
... where LabelNameNchars is the number of Unicode Chars in the Data Block, not considering the trailing zero.
; Tag Menu 1000
Runs the Menu Editor for the given Menu ID. The Dialog shows, then, a Button saying [Replace in Source], instead of [Store Equates to ClipBoard] so that, when leaving the Edition, the previous Menu Equates Declarations Set could be replaced automatically by the new one.
~~~~~~~
Code completion ...
The Code Completion Feature comes under 3 different forms, in order to try to adapt its functionality to the real everyday usage. They are:
1. User Defined Symbols Completion
2. Api Calls Completion
3. OS Equates Completion
In the [Configuration] Tab [Source Editor], you may choose to enable the Code Competion feature.
Once this Flag is set on, you initially will, in all cases, have the OS Equates and Api Completions. After the first successful Compilation, you will also have the Completion for the symbols as defined in your actual Source.
The Code Completions attempts begin when the 3rd Character is entered.
User defined Symbols Completion
In the Completion mode, a Symbols Table is built, after each Compilation, with all the Equates, Code and Data Labels, and Macros Declarations found in your Source. This Functionality is effective after a successful Compilation only.
When typing in, a Routine checks the table for a matching Symbol. If a matching Symbol is found, your typed name prefix is underlined. Once underlined, if you hit [Ctrl]/[Space], the Completion is performed.
There is no ListBox coming out with this form of Completion because, if your symbols are correctly choosen, you should not, usually have many Symbols beginning with the same Prefix. In most cases, the ListBox would not even come out, because it would hold only one Symbol.
Another good reason for not having a ListBox, with this form of Completion, is that the Names inside the Compiled List are under the cooked form the Assembler requires before parsing, this is to say entirely upper-case with underscore ripped off. It would be a bit confusing, for you, when seeing your symbols in that form.
This is why, for this form of Completion, the underlinement is proposed only in cases of univoque Item.
The final replacement takes its model from the first identical name found inside your Source, in order to take care of the Cases and of the underscores, if any. This enables you to have an easy and quick way for having clean, consistent and standardized Cases and underscores used all throughout your Source. Example:
Say, you have in your Source:
[M00_File 2001 ... ]
Now, you type in:
.... m00f
The feature detects the fitting Symbol:
.... m00f
Then, if you hit [Ctrl]/[Space], it becomes:
.... M00_File
The underlining occurs only in case a possible choice is ensured. For Example, if you have (like we do have in ''Base3.exe'' File), 3 Symbols like these:
Hexprnt // Hexprint // HexprintString
When you type in:
hexpr
... nothing happens because there are two or more conflicting solutions. But if you type:
hexpri
It is then underlined, and [Ctrl]/[Space] will perform:
Hexprint
Then, if you hit an 's', you get a one an alternate choice:
Hexprints
and, if you hit [Ctrl]/[Space] again, the completion will turn it into:
HexprintString
Api calls Completion
When typing a call to some Api Function, the underlining does not wait for a univoque option, the way it does it for your own Symbols (it would be of little help, given the number of Functions beginning, for example, by 'Create....'.). So, in case of multiple choices, when you hit [Ctrl]/[Space], a ListBox is run, instead, offering the various matching Functions Names. In case of univoque option, the replacement is done, the same discrete and quick way it is done for the user defined Symbols.
To open the Api ListBox, you just hit [Ctrl]/[Space] when your inputted prefix is underlined.
While the ListBox is open, you can go on typing your Prefix, in your Source, in order to reduce the choices number accordingly. You can, of course, choose an Item by any of the usual methods, in the ListBox, or go on typing in, up to the point when there will only remain one single possible choice. To enable the List Box with the Arrow and Return Key actions, you have, first, to give the Focus to the ListBox, otherwise, Arrow and Return Key, while you are typing in, in the Source Editor, will only affect the Source Editor.
Just like the OS Api, this feature is case sensitive (as opposed to the User Symbols version).
If the DLL Name is also found by the replacement Routine, it becomes part of the replacement. This is to say that, in such cases (actually not all cases, because our List is not yet complete), if your writing does not have any DLL name, or a wrong DLL Name, the proper DLL name will be provided for free by this magic Functionality.
This feature will not work, if the Location for the Functions.api File is missing in the your Configuration of RosAsm.
OS Equates Completion
When you start some input with ''&'', the Completion considers it to be for an OS Equate, in all cases.
No matter if this input fits with some effective Equate or not, because of the size of this List: In all cases, the underlinement will come out. Then, when you hit [Ctrl]/[Space], the feature's behavior will depend on the situation:
One single Item fits with you input: The replacement is done.
Several Items fit with you input: The ListBox is run, with the same behavior as for Api.
No symbol found: You are proposed to load the whole List for a search. This Functionality is optional because, on older Computers, given the time required to recreate and to load such a huge list, it would be utterly unusable. Also, it is not desirable to keep such a huge list in Memory, for such infrequent use.
As all OS Equates are upper case, this feature is case insensitive. You may as well input your OS Equates Names lower case, and you will have them upper case after Completion.
~~~~~~~
Blinking Caret ..
In the [Configuration] Tab [Source Editor], you may choose to have a blinking Caret. The default state is 'Off'.
You may also define the Caret Blinking Time. A value betwwen 800 and 300 is recommended.
~~~~~~~
TITLE .
TITLE is to be used only for real huge Sources. Consider it as some 'Chapter' concept in a book, not as a paragraph concept. TITLE is not at all designed for Modular programming style organization.
If a TITLE division is only for a couple of lines, it is not considered, and is merged with the previous TITLE part, so that the Editor's view could, at least, be of one Screen height.
The TITLE features purpose is to solve some problems one might encounter when, for example, wanting to save one third of a huge Source. Then, the Copy/Paste operation would be a true pain in the ass. Also, on slow Computers, the Source Editor may become a bit slow, with Sources above 1 Mega size.
Once a Source is divided in TITLEs, a Tabbed Control is made visible, each time you move the mouse on the StatusBar, at the bottom, that enables you with instant selection of the TITLE part to be edited.
TITLE syntax is:
TITLE TitleName
It must be stated exactly this way, beginning at the first row of a line, upper case required for TITLE, one space before the Title-name, all alone on a line. Zero flexibility, because we need full speed there, in order to give no penality to a huge Source without TITLE.
Once a Source is divided in as many parts by TITLE statements, the Editor behaves in a slightly different manner:
[Ctrl] [PgUp/PgDown] apply upon the Partial source (no longer upon the full Source).
All KeyBoard moves are limited to the activated Part.
The Vertical ScrollBar (if activated), concerns the partial Source too, and so does the Status Bar.
All the Search features (Search Box / Right-Click / Tree View / ...) work the same as they did with a non-enTitled Source. This is to say that there is no problem for moving all along the real Source out of the KeyBoard moves limitations. Once a jump has been done by a Search feature, the activated Part is the new accessed one.
[Ctrl] [S], instead of saving the full Source opens a Dialog offering the choice between Full and Part savings. If Full-Saving is chosen, as in Non-enTitled Sources, the asm saved File name is the current File Name. If Partial-Source-Saving is choosen, the asm saved File name is the one of the Current activated Part.
If the first line of an enTitled Source is not a TITLE Line, the Routine that builds the TITLEs Table, adds a default 'Top' one, in order to allow the Tab selection of this first Source Part, that, without this, it would be impossible to access.
One given Source may have up to 50 TITLEs.
For Memory saving, the size of each TITLE Part is arbitrarily limited to 500_000 Bytes. While dividing a huge Source in Parts with TITLEs, if you raise the TITLE Tab (by moving the Mouse Cursor down to the StatusBar area), you will see a MessageBox telling you the Name of the Part which is too large to fit..
~~~~~~~
Auto-deletions of selected Blocks ..
Blocks Auto Deletions is a traditional feature of all Text Editors. The RosAsm Sources Editor is not a Text Editor: It is a particular Tool designed for Source inputting. Sources Edition needs particular features and excludes some of the traditional ones. The fact, for example, of replacing a Selected Block by any new typed Character is utterly incompatible with the high level of security required in a Source Editor. This is why there is no such feature available.
Nevertheless, as I am bored with explaining this again and again to guys who do not want to understand what I am saying, I have implemented the required Instructions for this incompatible feature.
Their executions depend on a Flag called 'BlockAutoDelete'.
Please ! ! ! , Once you set this flag on, never come back and say to me something like:
'Hey! What's going on? I had a perfectly working Source. I changed nothing, and now, it does not work any more... Why did >>> RosAsm <<< kill my App???!!!...'.
~~~~~~~
BackUp feature ..
[Ctrl] [K]
BackUp Functionality: When you depress these Keys, the actual Application is saved into a Folder, from the current Path. If this Directory does not yet exist, it is created, with the Name of the Application plus ''BackUp'' (''...\MyFileBackUp\''). A Number is appended to the PE Name, which is incremented accordingly with the existing Files already saved that way (''...\MyFileBackUp\MyFile00xx.exe''). You can fix the maximum number of BackUp Files to be kept on the Disk in the [Configuration] Tab [Source Editor]. Once the Files Numbering comes over this limit, the older file (''MyFile0000.exe'') is deleted and all of the saved Files are renamed one step down in the numbering.
~~~~~~~
Line suppression ..
[Ctrl][Y]
If you set it in the [Configuration] Tabbed Dialog, you can delete a whole line at once. I added this feature because it was requested by a user. This is a dangerous feature that you should never use. Editing of Mono-Files Source is a particular thing, with particular requirements, the first one being full security and heavy prevention from undesired user actions. [Ctrl][Y] is incompatible with this requirement.
~~~~~~~
Undo .
The undo feature holds up to 2046 events in a rotary table. Undo is achieved by [Ctrl][Z]. Redo is achieved by [Ctrl][Shift][Z].
~~~~~~~
Indentations ..
The Idents Size may be defined in the [Configuration] Tabbed Dialog. Four spaces is highly recommended.
Traditional Idents work with [Tab] (forward) and [Shift][Tab] (back).
Also, [Shift][Tab], applied when the Caret is somewhere inside a valid text, first moves the Caret to the first valid Character in the line (spaces are deleted up to a Tab boundary, before entering the normal delete mode).
If a Block of Instructions is properly selected (complete Lines), Block Indent is also possible, back and forth. If Local Labels are part of the targeted Block, they are not affected by the transformations.
~~~~~~~