Copyright: Quick Editor 3.00


Quick Editor 3.0h The miniature TEXT Missile

and

Number One Son, TheGun

The Original Concept

Plain Language Licence

How it works

Advanced Search & Replace

Menu Syntax

Add In Text Menu

Programming Notation

Plug In DLLs

Hex Editing

Quick Editor Scripting

Simple Installation

TheGun


The Original Concept

Quick Editor started life as a working tool with an emphasis on minimum size, maximum loading speed, the capacity to handle large files quickly and a set of text processing functions that would take a lot of the hack work out of editing and formatting text. It differs from many programs in that it was not designed to be sold and it has not been compromised with flashy gimmicks and other useless additions.

Version three is a complete rewrite to obtain additional capacity while maintaining the original concept of being a small memory footprint program that does not require high end hardware to run it properly. It will comfortably run on a 120 meg pentium with 32 meg of memory and will work on Windows operating system versions from win95b upwards.

The current build of Quick Editor is about 35k in size yet for the increase in size, it will handle much larger files than the earlier version, it now has its own internal script engine, a wide range of text processing functions, it has full true type font support that can be set directly from the editor, programmable menus that can also be changed directly from the editor for users who need to have a wide range of facilities at hand, the capacity to save and close all instances, "goto line" number support for more technical users, advanced search and replace which extends to ascii characters with a number of preset combinations like carriage return/line feed pairs, it can both save a selection from the editor as a file and merge an existing file into the text in the editor and it will both read and write binary files in HEX notation.

Quick Editor is progressively configurable, it will run by itself with default settings yet it is extendable simply by adding the support dynamic link libraries that come with it. If you add the settings DLL, you can edit and save the settings for Quick Editor. Adding the menu editing DLL extends the capacity so that the programmable menus can be set up and used. There is a seperate DLL for extended printing capacity. If the printing DLL is not in the same directory as Quick Editor, it will print using a default setting, if the DLL is present, the user has the option of changing fonts and further editing the text before sending it to the printer.

This method of handling extended capacity is very efficient in terms of memory usage as it only loads a DLL on demand and when it finishes, it is unloaded from memory. As with the earlier version, Quick Editor is a single document interface that is designed to run multiple instances. Each instance has the full facilities of the editor yet differing from the older Windows 3.1 interface design of a multiple document interface, each instance can be minimised when not being used, drag and drop is fully supported between instances and all instances can be saved and closed from any single instance.

Quick Editor has a published plugin DLL interface for programmers who wish to further customise the capacity of the editor and add the DLLs to the programmable menus.

Performance is measured in terms of capacity to size ratio, for an editor that builds at 35k, it has extended capacity, it will load files in excess of 10 megabytes if the machine has the available memory and it is genuinely fast in its operations as many of the internal functions are written directly in assembler.

Just be careful, performance is addictive. Use it and you may end up hooked.

Steve Hutchesson

Sydney

Australia

www.movsd.com

hutch@movsd.com


Plain Language Licence

Quick Editor, its accessories and other attached files are programs that have the status of being private property. The files have not been and will not be placed in the public domain and are subject to the conditions set out below

They are available to any person, company, organisation, institution, government agency or department to use as they see fit without any form of cost whatsoever. Quick Editor is not for sale and must not be sold or included in or with any commercial software. This restriction is clearly aimed at software vendors who should write their own software, end user are welcome to use the software in any manner that they find convenient. Note that Quick Editor is not available for commercial licencing under any circumstances.

Distribution fees are exempt as long as the charges are reasonable and there is no inference that the software is being sold. The programs are unconditionally freeware and are not to be distributed in any other manner. Personal distribution is within the conditions of the licence but the preferred method is the original ZIP file. This is to protect other users from viral infection or tampering. Any of the programs may be included in any freeware package.

The right to install the software and use the software is extended to the end user by the author under copyright. For the purpose of protecting the user from auditing, no person is authorised under copyright to remove this software from any user's computer unless the user explicitly instructs them to do so. Failure to protect this right of the user by any authority under any jurisdiction is a violation of the users rights extended to the user under copyright from the author.

The only class of individual excluded from using these programs are those who would wish to take any form of legal action against the author for any reason whatsoever including the use or suitability of the programs. Such persons are licensed to delete the programs from their computer and NOTHING else. The continued use of the software under these conditions is a violation of copyright.

The programs are offered freely across many legal jurisdictions without being committed to any jurisdiction or any single authority. No jurisdiction is afforded any rights whatsoever with the control or use of this software apart from those that are set out in this licence for users. Where there is conflict between the rights of the user extended under copyright and the exercise of authority under any jurisdiction, the rights of the user have priority.

Reverse Engineering

The Digital Millenium Copyright Act legislation in the United States makes it illegal in that jurisdiction to reverse engineer any software that is encrypted. The compression technology used in Quick Editor constitutes encryption under this legislation so under normal circumstances, it would be illegal to reverse engineer Quick Editor or any of the associated programs that come with it. To address the situation where a computer user wishes to see and/or understand how Quick Editor works and how it interacts with the operating system on their computer, this licence specifically allows the interested party to reverse engineer the software for research purposes only. This licence does NOT extend to any form of distribution of a modified executable file and such distribution is prohibited under this licence.

I hope you like the programs and I hope they are useful to you.

Quick Editor.

Copyright © S.L.Hutchesson 1998 - 2002.

All Rights Reserved.

Steve Hutchesson

Sydney

Australia

hutch@movsd.com

www.movsd.com


How it works

Quick Editor is a fully self contained executable file that will run by itself without any other form of support files yet when any of the dynamic link libraries designed for Quick Editor are added to the same directory, Quick Editor has extended capacity. The DLLs listed below are the standard one supplied with Quick Editor.

1. The settings editor. (setini.dll) This is in the form of a dynamic link library and all that needs to be done is to place the DLL in the same directory as Quick Editor. When you place the settings editor DLL in the same directory as Quick Editor, it will appear on the "Edit" menu and when you select the option, you can change settings that effect the appearance and functionality of the editor. When you click "Save", the settings editor saves the settings to disk, updates the settings and closes.

2.Quick Editor has the capacity to run custom menus that are set up by the user. If the DLL (menuedit.dll) is placed in the same directory as Quick Editor, an entry will appear on the Edit menu with the text "Edit Menus". By using the menu editor, the user can add as many topics and items to the menu as they like. The limit is 500 items which should not be a problem as it would exceed available screen space..

3. By default Quick Editor will print the whole document in the font that is selected in the editor. If the DLL (printtxt.dll) is added to the same directory as Quick Editor, a seperate window will appear that has either the selected text or the whole file. It is displayed in the format that is sent to the printer. You can change the font type and size and you can edit the text before you send it to the printer.

4. Different people have different uses for a text editor, some need the more advanced text processing capacity where some do not. To cater for this, Quick Editor has a DLL called (addmenu.dll) that has some additional text processing functions available. A new entry will be appended to the menu bar topic "Selection" using the entry name "More Text Functions" and it has additional function that work on selected text in the editor.

5. For people who have a technical background, Quick Editor has a scripting engine built into it that can be used to automate and simplify certain tasks that are common to a text editor. To use the scripting engine built into Quick editor, you must write the scripts and then load them on the custom menu or alternatively, you can load one at a time from the "File" menu or the hotkey. When a script is loaded from the menu, it is executed on load. It can be repeated as often as required by using the F12 hotkey.

6. For programmers who need to extend the capacity of Quick Editor, there is a published interface for plug in DLLs that are called from the custom menus.


Advanced Search & Replace

There are instances where searching for a specific BYTE pattern is useful in a text editor, especially when there are combinations of unprintable characters like tabs, carriage returns and line feeds combined with normal printable characters. Quick Editor has a syntax for dealing with this type of usage.

At any place in the text that is entered in either the Search dialog or the Replace dialog, the user can specify ascii byte patterns with the following syntax.

{32,13,10} where the numbers that are comma delimited are the actual ascii codes for the characters that are being searched for or replaced. This syntax can be freely mixed with normal characters that can be typed in the normal manner. A left or right brace can be added to the search or replace pattern by using the ascii number enclosed in braces.

There are a number of useful preset characters that are supported as well.

{t}	tab
{cr}	carriage return
{lf}	line feed
{crlf}	carriage return and line feed

Replace Operation

The "Replace" function in Quick Editor has two (2) modes of operation, it either works on the selected text or it works on the whole text. This allows the user to target the area that requires text replacement if it is needed.

The "Replace" dialog can be used to "Remove" sections of text. If you type the text you wish to remove from either the selection or the whole document into the first edit box and type nothing in the second, the target text will be replaced with no text which is the same as removing the text.


Menu Syntax

With Quick Editor, you can set up menus to have the tools and accessories you require. This is done by starting the Menu Editor on the "Edit" menu and making the entries that you require. Below is the syntax for setting up the menus with the tools and programs you require.

There are 2 types of entries for the menu, headings and individual entries. A heading is denoted by square brackets around text on a separate line.

[&Tools]

This line will place the heading "Tools" on the menu bar. To place entries on the popup menu "Tools", you use the following syntax.

The syntax for each menu entry is a 3 part syntax,

1. 	The text for the item as it appears on the menu.

2. 	A comma [ , ] seperator.

3. 	The full path and file name of the program to run.

EXAMPLE : My&Menu Item,Drv:\path\program.exe /parameters

You can use as many headings with subsequent entries as you like up to the limit of screen space or a total of 500 entries.

The heading [Help] marks the end of new headings and no others will be treated as headings. Any entries added after the "Help" heading are appended to the Help menu.

To make a menu bar seperator, put a single minus sign on a line by itself, this will display a menu bar seperator at the position on the menu popup where the minus sign is.

Use the Get File button to find the file that is needed for the menu item. If you type the text item and a comma first, after you find the file with the dialog box that appears, it will be placed at the caret position in the menu section editor.

Tip

Using the ampersand character [ & ] before any character in the text for the menu item underlines it as it appears on the menu and it becomes the menu hotkey for that item.

Menu Editor Notes

The menu option "Check" is designed to test the paths of any files that are listed in the menu.ini file. When using file names that are only available in a particular directory, the file will be displayed as a missing path if the editor is not in the directory where the file is. It also checks basic syntax like having a seperating comma between the menu entry and the file name and it checks for matching braces.


Add In Text Menu

This menu contains additional text processing capacity for some of those not so common tasks.

1. Strip HTML tags.

This function will strip any information between opening and closing angle brackets including the angle brackets.

EXAMPLE : text <HTML tag> more text

    After processing with this function,

text  more text

2. HTML to text.

This function not only strips the HTML tags but replaces any HTML notation with it ascii equivalent.

3. Rebreak Paragraph.

This function changes the line length of blocks of selected text to a value that can be edited when the function is called. It removes carriage returns and line feed characters, converts tabs to spaces and then removes any repeated spaces so that only single spaces seperate words in the text. It then rebreaks the line length to the maximum value set at the beginning of the function. This function is primarily designed for people who have to fix and use text from a range of different sources and platforms where the form of the text may not display correctly on a PC.

4. Remove CRLF.

This function removes carriage return/line feed pairs from a selected block of text so that it can be displayed in anorther editor in work wrap format.

5. MAC to PC Text.

This function tests if the text is in the format used on MAC computers and if it is, it changes the carriage return to a carriage return/linefeed for PC usage.

6. UNIX to PC Text.

This function tests if the text is in standard UNIX format of a single line feed character and if it is, it converts it to PC carriage return/linefeed format.


Programming Notation

There is a specific notation with the programmable menus so that programmers can run assemblers or compilers directly from Quick Editor.The notation works by getting the name of the file loaded in the editor and parsing the full path and file name in a range of formats that can be used with compilers, linkers, assembler and batch files.

When you use this notation, the menu run internal function expands each notation into its full text format so that a variety of names or paths can be passed to the compiler or linker.

If you have the following file loaded in Quick Editor,

c:\masm\bin\myprog.asm

The following notation is expanded by Quick Editor into the various components of the files path and filename.

full path and name with extension

{a} => c:\masm\bin\myprog.asm

full path and name with NO extension

{b} => c:\masm\bin\myprog

name with extension

{f} => myprog.asm

name with NO extension

{n} => myprog

full path with NO name

{p} => c:\masm\bin\

EXAMPLES

To run a compiled EXE file, the menu entry would be like this,

&Run EXE File,{b}.exe

This option is expanded by Quick Editor into,

c:\masm\bin\myprog.exe

If you need to run a file in the same directory as the file loaded in the editor, the menu entry would look like this,

Run &Other File,{p}otherfile.exe

This is expanded by Quick Editor into,

c:\masm\bin\otherfile.exe

Please note that the syntax is not tolerant, it must be lower case or it will not work.


Plug In DLLs

Setting Up a Plugin DLL

To use a plug in DLL, the syntax is the same for a menu as any other file except that the extension MUST be DLL. Quick Editor determines the file extension internally and passes the name to the internal interface.

DLL Function,Drv:\Path\DllName.DLL

DLL Details

Quick Editor has an internal interface that will call a specially written type of DLL if it find a DLL set up in the menus. The interface is both stable and reliable but it requires reasonably advanced programming skills to produce the DLLs.

Internally Quick Editor tests if the DLL set up on the user defined menus exists, then it checks if the EXPORT function has the correct name and if both conditions are met, it calls the DLL and passes a set of internal "handles" to it. The nature of the DLL determines what function it will perform. If either condition fail, Quick Editor displays an error message and the DLL is not loaded.

The function called in the DLL MUST be named "QePlugIn".

The handles that are passed are,

1. The INSTANCE handle

2. The main window handle

3. The rich edit control handle

4. The tool bar handle

5. The status bar handle

The calling convention is STDCALL and each parameter is a 32 bit unsigned INTEGER (DWORD). The correct data type is an unsigned 32 bit INTEGER but you can generally use 32 bit signed INTEGERS (LONG). The programmer who writes a DLL for Quick Editor should use the correct data types for the compiler/assembler being used to write the DLL.

Below are examples of the called functions starting code.

PowerBASIC

FUNCTION QePlugIn ALIAS "QePlugIn"(ByVal hInst as LONG, _

                                   ByVal hMain as LONG, _

                                   ByVal hEd   as LONG, _

                                   ByVal hTool as LONG, _

                                   ByVal hStat as LONG) EXPORT as LONG

MASM

QePlugIn proc hInst:DWORD,hMain:DWORD,hEd:DWORD,hTool:DWORD,hStat:DWORD

General

Any programming language that can write a dynamic link library is suitable to write a Quick Editor plugin.

Quick Editor uses the earlier Rich Edit control version 1 as it is faster than the later version. A plugin DLL can do many things as all of the relevant handles are passed to the DLL but in most instances, a plugin DLL is used for some form of text processing and this will mean interacting with the Rich Edit control in Quick Editor. The handle for the control is available so any text based function can be performed, selection, text replacement and many other text based operaions. The programmers need will dictate what the task will be for the DLL.

It is possible to subclass the main WndProc function in Quick Editor but it needs to be done with considerable caution as it can crash other instances that are already running if it is not done correctly. The problem will be that any other instance is not notified and will usually GP fault when the subclass address is reset to the original proc address.


Hex Editing

Hex editing

The editor has the capacity to open a binary file as hex for editing and saving the hex back as a binary file. This capacity is designed for people who need to edit file headers, repair virus damaged files, remove appended bytes on files from certain types of file transfer protocols or customise their own files in binary.

When a file is opened as hex, it is a plain ascii text file that can be edited in the same way as any text file.

Commenting the hex dump

There is a syntax for putting comments in the text of the hex dump which is the same as assembler comments, ( ; ).

The comment can be placed on a single line or it can be placed at the end of a line but it cannot be mixed with hex otherwise there will be an error in the written byte length.

Splitting lines

Lines can be split as long as the line has a colon at the start ( : ). If the line is not prefixed with a colon, it will not be read and there will be an error in the binary image.

Example

; C:\prog\app\testprog.exe  68096 bytes

; MZ header

00000000: 4D 5A 0A 00 02 00 00 00 - 04 00 0F 00 FF FF 00 00

00000010: C0 00 00 00 00 00 00 00 - 40 00 00 00 00 00 00 00

00000020: 00 00 00 00 00 00 00 00 - 00 00 00 00 00 00 00 00

00000030: 00 00 00 00 00 00 00 00 - 00 00 00 00 80 00 00 00

00000040: B4 09 BA 10 00 0E 1F CD - 21 ; << int 21h

:B8 01 4C CD 21 90 90

00000050: 54 68 69 73 20 69 73 20 - 61 20 57 69 6E 33 32 20

00000060: 70 72 6F 67 72 61 6D 2E - 0D 0A 24 00 00 00 00 00

00000070: 00 00 00 00 00 00 00 00 - 00 00 00 00 00 00 00 00

; PE header

00000080: 50 45 00 00

:4C 01 05 00 - 39 30 00 00 00 00 00 00

00000090: 00 00 00 00 E0 00 0E 03 - 0B 01 02 34 A5 BA 00 00

000000A0: 00 0E 00 00 F4 02 00 00 - 50 99 00 00 00 10 00 00

000000B0: 00 D0 00 00 00 00 40 00 - 00 10 00 00 00 02 00 00

000000C0: 04 00 00 00 00 00 00 00 - 04 00 00 00 00 00 00 00

000000D0: 00 40 01 00 00 04 00 00 - 00 00 00 00 02 00 00 00

000000E0: 00 00 10 00 00 20 00 00 - 00 00 10 00 00 10 00 00

000000F0: 00 00 00 00 10 00 00 00 - C0 FA 00 00 9B 00 00 00


Quick Editor Scripting

Script Commands

Scripts are used to automate certain type of repetitive tasks. At its simplest the scripting capacity in Quick Editor can output text at the current location of the caret with the following.

text Hi, I will be inserted into Quick Editor{lf}

The command is "text" and anything that follows it is text that will be placed in the editor. The trailing {lf} inserts a carriage return and line feed which is the same effect as pressing the enter key.

Loop code is supported and procedures are supported using very similar commands to the way assembler handles this type of code. You can use "jump" to a label, you can use "call" to call a procedure and "retn" to return from it.

There are dialog boxes that can take text input, get file names, display text and display text with a choice.

The scripts can use variables of both TEXT and INTEGER form. An important thing to understand when using the variables is that when you wish to display the CONTENT of the variable in one of the commands, you must place it in braces. IE : {var25}

EXAMPLE: text {var25} {str3}

If the variable var25 has the number 36 in it and the string variable str3 has the message "is the count", the text that is displayed would be,

36 is the count

There are file IO commands that can both load files into a string variable and can create and write data to a file.

Currently there are 64 commands that can be used in the scripting language.

NOTE : There is very little error checking in Quick Editor scripting. Some very basic errors are tested at load time and some other error conditions are checked at runtime but overhead and speed considerations restrict what can contained in the runtime engine.

Commands that require more than one piece of text are seperated by two ** characters. This is unintuitive at first but it allows common sections of text that contain quotes and commas to be worked on directly and it saves on notation that has to be written in the scripts.

Some characters are used as notation in Quick Editor Scripting so if they are required in normal text, the following replacements are needed.

{comment} is used to replace	";"

{lbrace} is used to replace 	"{"

{rbrace}  is used to replace	"}"

{lf} can be inserted or appended to a line of text to avoid using the seperate command.

=============================

Quick Editor script commands

=============================

escape      pressing the escape key will stop the execution

            of the script with the option of terminating

            the script. this is useful when an infinite

            loop needs to be closed down

debug       0 / other number    0 = off, other is ON

            use debug 1 to run the messagebox that

            displays the command and line number

delay       milliseconds delay between the execution

            of each command, useful for debugging and

            for animation of text actions. set to zero

            for no delay.

            EXAMPLE: delay 125

;           comment and text terminator for trailing text

cls         clear the edit window

exit        exit script

            ===================

            file menu emulation

            ===================

newfile     emulate New option on file menu

fileopen    filename

            open a file in the editor

filesave	emulate Save option on file menu

savefileas  emulate Save As option on file menu

writefile   filename

            write text in editor directly to disk

settitle    text

            file name on title bar

            ==============

            key emulation

            ==============

linestart   go to start of line

lineend     go to end of line

newline     insert CRLF into editor at current location

starttext   go to beginning of editor

endtext     go to end of editor

linecount   returns the number of lines in the editor.

            this is useful for designing loops that

            process the whole content of the editor.

            return value is in var0

left        repeat count

right       repeat count

up          repeat count

down        repeat count

back        repeat count

spaces      repeat count

            =================

            run applications

            =================

run         filename                    ; synchronous operation

start       filename                    ; asynchronous operation

plugin      filename                    ; run a QE plugin DLL

            EXAMPLE: plugin f:\pb\bblockc.dll

            ============

            Insert text

            ============

text        any text

            The following rules apply to all text based parameters

            ";" use {comment}

            "{" use {lbrace}

            "}" use {rbrace}

            {lf} can be used in any location in the

                 text to add a carriage return/line feed

            {var#} inserts that value in the variable as characters

            EXAMPLE: text Loop count is {var16}

                     If the value in in var16 = 25

                     the output to the editor will be

                     Loop count is 25

            Note that leading and trailing blank spaces are treated

            like any other character and are part of the parameter.

            You can terminate trailing blanks with a comment

            EXAMPLE: text 10 spaces          ;

duplicate   characters seperator count

            duplicate is used for repeated sequences of characters

            EXAMPLE: duplicate MyText**10

            =======================

            text selection commands

            =======================

selectline  select current line

selectall	select all text in the editor

setsel      2 numeric parameters

            set selection from starting position to number of characters

            1/ number of keystrokes from start of line

            2/ number of characters to select

            EXAMPLE: setsel 4 8

            parameters are delimited by a space

cursel      1 numeric parameter, positive OR negative number

            set selection from the current position to the

            number of characters set in the parameter

            positive number selects text to the right of

            the current position

            negative number selects text to the left of

            the current position

            EXAMPLE: cursel 8

                     cursel -4

getsel       get the current selection and copy it to str0

              WARNING this command should not be used on a Quick Editor script

              that contains the variable {str0}. the editor will lock up as

              the script engine keeps dynamically replacing the variable with

              its content.

            ===================================

            commands that work on selected text

            ===================================

ucase       convert selected text to upper case

lcase       convert selected text to lower case

ltrim       trim left blank spaces from selected text

rtrim       trim trailing blanks from selected text

replace     text1 with text2 in selection

remove      text1 from selection

            =====================================

            clipboard operations on selected text

            =====================================

cut         remove selected text and place it on the clipboard

copy        copy selected text

paste       paste text from the clipboard to the current caret position

clear       delete the selected text

undo        undo the last text operation

            =============================

            string and integer variables

            =============================

str##       string variable with numeric suffix

            str0 to str1023 range of different variables

var##       integer variable with numeric suffix

            var0 to var1023 range of different variables

inc         increment a numeric variable        ; inc var10

            and set ZERO flag if result is zero

dec         decrement a numeric variable        ; dec var10

            and set ZERO flag if result is zero

add         add a number to a numeric variable and set

            ZERO flag if result is zero

sub         subtract a number from a numeric variable

            and set ZERO flag if result is zero

            =========================================

            conditional testing of numeric variables

            =========================================

if          runtime comparison [variable operator number]

            operator description

            ~~~~~~~~ ~~~~~~~~~~~

                =       equals

                !       not equal

                <       less than

                >       greater than

            If evaluation is TRUE, execute following line

            else jump to next line

            EXAMPLE:  if var27 = 10 ; ----.------>------.

                      jump label    ; <---' if TRUE     |

                      next_line     ; <---- if FALSE -<-'

            ======================================================

            Code branching that changes the following instruction

            ======================================================

jump jmp    jump to a label

call        call a procedure start label

retn        return to next instruction after previous CALL

            ================================

            comparison and conditional jumps

            ================================

cmp         compare either numbers or variables and set the ZERO

            flag if result is equal, else clear the ZERO flag

            an internal flag is also set to indicate if the first

            variable is greater or less than the second variable

            EXAMPLE: cmp var1, 0

                     cmp var3, var2

                     cmp 25, var1

            NOTE: seperator is a comma [ , ] as

            with the normal assembler mnemonic

            comparison can be between 2 variables,

            2 numbers of one of each

jz   je     jump to label if ZERO flag is set

jnz  jne    jump to label if ZERO flag is NOT set

            the alternate mnemonics je jne are for

            clear coding with the cmp instruction

            NOTE: the ZERO flag is also changed by the

            following instructions, inc dec add sub

            if the result is zero it is set else

            it is cleared if it is non zero

jg          jump if first parameter in cmp instruction

            is greater than the second parameter

jl          jump if first parameter in cmp instruction

            is less than the second parameter

            NOTE: If the comparison in the cmp instruction

            is between two variables that are equal, the

            flag that jg and jl reads is not changed

            ========================================

            file operations

            Only 1 file can be open at a time and it

            must be closed before it can be deleted

            ========================================

fcreate     create a file

            EXAMPLE: fcreate filename.ext

fclose      close the open file

fprint      print to open file

            EXAMPLE: fprint any text

fkill       delete a file that is NOT open

            EXAMPLE: fkill filename.ext

            =========================================

insertfile  filename    insert file into editor (same as merge file)

loadfile    filename    load a file into string variable str0

openfile    filename    opens a disk file in the editor

            ====================

            variable assignment

            ====================

assign      assign a string to a string variable or

            another string variable to a string variable

            EXAMPLE: assign str1 Text Data

                     assign str4 {str5}

                     assign str4 {str0} {str1} {str2} {str3};

set         set a number TO a numeric variable or another variable

            to a numeric variable ; set var10 64  set var5 {var6}

            ===========================

            dialogs

            ===========================

getfilename displays a file open dialog. Selected file is

            returned in 'str0'

            file pattern is an optional parameter, default is

            *.* if no parameter is supplied.

input       Dialog box to get text

            Parameters:

            1. optional text for title bar

            2. optional default text for edit control in dialog

            EXAMPLES:

            a. input

            b. input dialog caption

            c. input dialog caption**default text in edit conrol

            typed text is returned in text variable 'str0'

            NOTE: The text delimiter between the two parameters

            must be in the form ** . Spaces are treated like characters

msgbox      Text_Message**[optional title]

yesno       text message**[optional title]

            a message box is displayed with the option of

            yes or no. selecting yes will execute the

            following line, selection no will jump to the

            next line after the following line.

            EXAMPLE:  yesno Finish Now ? ;-.------>------.

                      jump label    ; <----'  if YES     |

                      next_line     ; <------ if NO --<--'


Technical data and credits

Joergen Ibsen

Quick Editor is a self unpacking executable file that uses Joergen Ibsen's compression technology in his aPLib libraries. The smaller disk image and unpacking in memory improve the load time of Quick Editor. The technology is commercially available from Jeremy Collake in his program PEcompact which can be obtained from the following URL.

http://collakesoftware.com/pecompact.html

Bob Zale

Quick Editor is written in Bob Zale's latest hybrid compiler PBWIN70 and takes advantage of many of the intrinsic capacities that this compiler has available. Dynamic string functions, dynamic arrays, a very good inline assembler, full API style coding and a very grunty dialect of basic. You can find the details at the following URL.

http://www.powerbasic.com

Technical

Quick Editor is a stand alone portable executable file that does not require any form of runtime DLL for its operation. The DLLs supplied with Quick Editor have been written specifically for it and they are designed to be loaded on demand and unloaded when finished.

This version has again been written to use RICHED32.DLL rather than the later RICHED20.DLL as the older version is both faster and a true ascii text control. The later version has multi-level undo which is a useful feature in a word processor but it has a much higher memory demand which is not within the original design criterion of Quick Editor of being a minimum memory footprint text editor.

The technique for loading and saving files has been changed with the result that Quick Editor can load much larger files that it could before. There is still an effective limit imposed by the rich edit control when there are a very large number of lines in the file but this version can comfortably load in excess of 10 megabytes if the computer has the available memory.

Most of the text functions are written in assembler so the execution speed is acceptable even on large files. Quick Editor maintains a number of DLL interfaces for different add ins that it uses. All of the DLLs that work with Quick Editor are loaded using the two API functions,

LoadLibrary()

GetProcAddress()

This method is far more efficient in terms of memory usage and it allows the DLLs to be loaded and unloaded on a demand basis. It also allows a more flexible design with the main executable.


Simple Installation

When Quick Editor is unpacked, it contains all of the plugin DLLs that were written for it but not all users will want or need all of its capacity so Quick Editor has the option of only recognising the add in DLLs that are in the same directory as the main executable, "qeditor.exe". For users who prefer a simple interface that is free of additional capacity that they do not need, simply place the "qeditor.exe" file in a directory by itself and it will run with its default settings.

Note that you do not have to change any settings to dial in the capacity that you require, all you need do is add in the DLLs that give you the capacity you need.

Quick Editor does not store any setting in the registry but instead uses INI files that are in the same directory. You can completely re-install or upgrade the Windows version you are using and Quick Editor will run as normal.

If you prefer to have the capacity to adjust the settings, add the dynamic link library "setini.dll" to the same directory as the "qeditor.exe" file.

If the work you do with editors requires extended text processing, add the dynamic link library called "addmenu.dll" to the same directory as the "qeditor.exe" file.

If you require the extra capacity of the custom menus in Quick Editor, add the dynamic link library "menuedit.dll" to the same directory as the "qeditor.exe" file.

If you want to have additional adjustments to printed output, add the dynamic link library "printtxt.dll" to the same directory as the "qeditor.exe" file.

Note that Quick Editor will use both the "qeditor.ini" file and the "menus.ini" file independently from the dynamic link libraries that modify them being installed so if you have a use for such a configuration, you can set up the settings files using the DLLs that are designed for that purpose and then remove them so that the settings are not easily available. The INI files can be modified by opening them as text files with Quick Editor but it is probably not an easy option for non technical users.


TheGun

TheGun is the "kick ass" no front, minimum size text editor written in Microsoft Assembler (MASM). It was written as a accessory for Quick Editor as it supports word wrap that Quick Editor cannot for technical reasons. At 6k in size, it is near the absolute minimum for a text editor of its capacity yet it will open text files in excess of 10 megabytes, it will run multiple instances, it has operating system search enabled, it can toggle between word wrap and normal mode, it is drag and drop enabled between instances of itself and Quick Editor and you can drop files into it from either Explorer or File manager.