[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4. Detailed description of some parts of RHIDE

4.1 Selecting a window  
4.2 How the editor works  
4.3 Some hints and problems  
4.4 Project window  
4.5 Builtin compiler specs  
4.6 Builtin variables  
4.7 Change the defaults of RHIDE  
4.8 Message window  
4.9 Syntax highlighting  
4.10 Checking the dependencies  
4.11 What is Turbo Vision  
4.12 How the dialogs work  
4.13 Defining macros  
4.14 The INFO Viewer  
4.15 RCS and RHIDE  


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.1 Selecting a window

To select a window you can do the following. If the window has a number, this is right on the top-frame, you can select this window by pressing Alt and this number (but only if the number is a single digit). Or you click anywhere in the window or on the frame of the window with your mouse.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.2 How the editor works

This section should describe the work of the editor. But because the editor is now so complex and, not my own work, there is now separate documentation with more detailed and better description see section `Top' in SETs Editor. But you can read also more from my doc, which describes the most common (for me) usage of the editor.

Here I describe most of the editor commands. If there is a key command like Ctrl+Q+Y, press Ctrl and Q simultaneously and after this press Y.

I strongly recommend not to use the technique by holding down the Ctrl key when pressing the second key in such key combinations, because for instance when you press Ctrl+K and then Ctrl+C you will be prompted if you want to interrupt RHIDE (because you pressed the interrupt key). But if you really want to use this methode, you should use the `-C' commandline switch when starting RHIDE to disable the handling of SIGINIT.

4.2.1 Erasing commands  
4.2.2 Cursor moving commands  
4.2.3 Text selecting and searching commands  
4.2.4 Block commands  
4.2.5 Other commands  


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.2.1 Erasing commands


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.2.2 Cursor moving commands


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.2.3 Text selecting and searching commands


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.2.4 Block commands


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.2.5 Other commands

If you have set some markers, they will be stored, so you can use them later when restarting RHIDE.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.3 Some hints and problems

To compile only a single file, you don't need to include it in a project. You only have to open it and do a compile. If a file is in your project, you can compile it, if you are in its editor-window or if you are in the project-window and this file is selected.

Warnings and errors from compiling a file are listed in the message-window. If there are warnings or errors, you can jump to the corresponding source by hitting ENTER on this message. If this file wasn't already opened, it will be opened.

4.3.1 Problems with automatic dependencies  


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.3.1 Problems with automatic dependencies

Most checking of the dependencies works correctly, but there are some few situations, where this checking gets confused. The first results in the fact that I implemented a cache function for getting the modification time of files, that means, most files are 'stat'ed only once, after starting RHIDE. But if someone modifies one of the files, which are in the cache, (this can be another program, when you run RHIDE in a multitasking environment, such as Windows) or if you run your project and it modifies some of these files, the internal cache is after this not up to date.

Here is another situation. Your source files are not in the current directory. You have opened a source file for editing and successfully built your project. Now you leave RHIDE, because you want to debug your program with `FSDB', you copy the source file (in this case it is the file, which you have opened in the IDE) to the current directory. Now you debug it and there are some errors. You restart RHIDE to make the changes in the file. The previously opened file will be opened automatically and you edit it. If you do now a Make, RHIDE tells you, that your project is up to date, because it searches for source files at first in the current directory, and there is the unmodified file.

In this chapter I will give you for some special parts a more detailed description of what they do.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.4 Project window

The project window shows you every file, which you have included in your project. Most time you work with RHIDE this window should be visible, but you can also close it see section 3.10.7 Close.

4.4.1 Items of your project  
4.4.2 Open a project item  
4.4.3 Dependencies of project item  
4.4.4 Local options for a project item  


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.4.1 Items of your project

The items in the project window, and therefore also in your project, are sorted in alphabetical order. This has the effect of faster finding an item and you can also move the selecting bar to a specified item by typing the name of this item.

Normally, the alphabetic order of the project items causes no problems because the linker searches at first every object file for unresolved symbols before any library. The statement, the the GNU linker is a one pass linker makes sense only for libraries, because they are checked only once for unresolved references. That means, if you include libraries in your project you must know about the order, where this library is put on the command line when linking your program.

If you have problems with that order, or if you really want to have one object file (or library) before some others, you must rename them, to get the right position from the name.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.4.2 Open a project item

To open an editor window with the selected item press either ENTER or SPACE. If there was already a window with this file opened on the desktop, this window will be selected. This works only if the selected item has a known suffix see section 2.1 Known suffixes. If the selected item is a project file, that project will be opened with the side effect that if you close this project, the previous one will be reopened.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.4.3 Dependencies of project item

If you have compiled a file already in RHIDE, you bring up a list with all dependencies of that file. In this list the files are show by their basename followed by the directory and they are also sorted in alphabetical order. From here you can also open an editor window with the selected dependency by pressing SPACE or ENTER on that item.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.4.4 Local options for a project item

You can change many options for a project item, which are in effect only for this file. To do this, hit Ctrl+O on the selected item and a dialog is shown, where you can change the options.

At this time you can change the following options.

Local commandline options  
exclude from link  
rebuild seldom  
Name of the output file  
Compiler type  
User defined compiler  
Error checking  
Error program  

Local commandline options

Here you can give some additional defines or any other commandline options, when compiling this item.

exclude from link

This is a switch to tell RHIDE, that this file should not be linked with your program, but it is compiled and it is checked to determine if your program is up to date.

rebuild seldom

When you select this option the item is compiled only if it does not already exist. For most project items this is not usefull but if you have included in your project other projects which create a library this might be usefull, especially if the library has many source files and you know, that they change very seldom.

Name of the output file

Here you can specify another name as the compiled file. Put here only the basename of the file (without any directory)

Compiler type

From that list you can select exactly one type of the compiler, which is used to create your output file. Possible values are:

`Auto'
This is the default and should be used in most cases. When this type is selected, RHIDE selects the correct compiler depending on the suffixes of your source and output file.

`User'
If you have any special compiler, which is not known to RHIDE, to create your output file, you must select this and give RHIDE also the calling syntax of that compiler (see below)

`None'
If you don't want to compile this item select this.

`GNU C compiler'
Tell RHIDE to compile this file like a normal GNU C source file.

`GNU C++ compiler'
Tell RHIDE to compile this file like a normal GNU C++ source file.

`GNU assembler'
Tell RHIDE to compile this file like a normal GNU assembler file.

`GNU Pascal compiler'
Tell RHIDE to compile this file like a normal GNU Pascal file.

User defined compiler

If you have selected the User compiler type, you have to put in the next input line the specs on how to call the compiler. These specs can use any variables that are known to RHIDE see section 4.6 Builtin variables together with normal text. As an example I show here, how the builtin C compiler is defined (the backslashes at the end of the lines are used only here to show, that the line is continued, they are NOT part of the specs):

 
$(RHIDE_GCC) $(INCLUDE_DIRS) $(C_DEBUG_FLAGS) $(C_OPT_FLAGS) \
$(C_WARN_FLAGS) $(C_C_LANG_FLAGS) $(C_EXTRA_FLAGS) $(LOCAL_OPT) \
-c $(SOURCE_NAME) -o $(OUTFILE)

Error checking

Here you can select how errors or warnings that are produced by the compiler, are checked. Possible values are:

`Auto'
Let RHIDE select the correct way for checking the errors

`User'
Use your own external program to check the output of the compiler to stderr

`None'
Do not check any errors, assume that the compiler does it's job every time successfully.

`builtin C'
Check the errors like when compiling a C file

`builtin assembler'
Check the errors like when compiling an assembler file

`builtin linker'
Check the errors like when linking

`return value'
Determine only if the compiling was successful or not by checking the return value of the compiler (zero for success)

Error program

If you have selected above the User error checking, type here the program, which should check for errors and/or warnings. What the external error checking program should do:


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.5 Builtin compiler specs

WARNING: THE LIST OF VARIABLES AND STRINGFUNCTIONS DESCRIBED BELOW MIGHT NOT BE UPTODATE. IF YOU WANT TO GET INFORMATION ABOUT ALL FEATURES PLEASE LOOK IN THE SOURCES FOR RHIDE.

RHIDE uses for compiling, linking, and the other stages of generating a file also specs, like you can change in the local options for a project item see section 3.8.5 Local options. Here the specs, which are used currently:

$(RHIDE_COMPILE_C)
For compiling C source files

$(RHIDE_COMPILE_CC)
For compiling C++ source files

$(RHIDE_COMPILE_ASM)
For compiling assembler source files

$(RHIDE_COMPILE_PASCAL)
For compiling Pascal source files

$(RHIDE_COMPILE_OBJC)
For compiling objective C source files

$(RHIDE_COMPILE_LINK)
For linking

$(RHIDE_COMPILE_LINK_PASCAL)
For linking when the project contain Pascal source files

$(RHIDE_COMPILE_LINK_PASCAL_AUTOMAKE)
This spec is used only, when you have set the see section 3.8.8 Primary file, to tell RHIDE, not to check for dependencies but to use the 'automake' feature of GPC.

$(RHIDE_COMPILE_ARCHIVE)
For creating a library

$(RHIDE_FSDB)
For calling FSDB.

$(RHIDE_GDB)
For calling GDB.

$(RHIDE_GPROF)
For calling GPROF.

$(RHIDE_GREP)
For calling grep.

All of these specs have a default content in RHIDE, but they can be overwritten by setting the environment variable with the same name and any other contents.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.6 Builtin variables

This section describes, which variables can be used within RHIDE to get values from some of the configurations, which you have made inside RHIDE.

All of these variables are referenced by a name enclosed in parentheses preceeded by a dollar sign. Example: `$(RHIDE_GCC)'. You can overwrite any of the following variables, if you define in your environment the same variable with any contents you want.

When RHIDE tries to get the contents of such a variable, it searches at first if it is found in it's internal database. If it was not found, the environment is checked for such a variable and if that fails, the resulting value is the variable itself.

In addition to the use of variables, RHIDE has a limited ability of using string manipulating functions. I have implemented some of the functions, which are available with GNU make. They have the same name and should work exactly like the GNU make counterpart.

`$(strip arg)'
This function removes any leading and trailing whitespace and converts all multispaces to single spaces from the (whitespace separated list) `arg'.

`$(addsuffix arg1\\\,arg2)'
These functions append on each argument from the whitespace separated list `arg2' the string `arg1'.

`$(addprefix arg1\\\,arg2)'
This is the same as `$(addsuffix arg1\,arg2)', except that it puts the string `arg1' before each argument from `arg2'.

`$(notdir arg)'
This removes any directory part from the argument `arg'.

`$(dir)'
This extracts only the directory part from the argument `arg'. If there was no directory in `arg', an empty string is returned. (The directory contains also the drive letter, if there was one)

`$(subst arg1\\\,arg2\\\,arg3)'
This replaces every occurrence of `arg1' in `arg3' with `arg2'

The following variables have a special meaning in RHIDE with the default contents:

$(RHIDE_GCC)
GCC

$(RHIDE_AS)
GCC

$(RHIDE_GXX)
GCC

$(RHIDE_GPC)
GPC

$(RHIDE_AR)
ar

$(RHIDE_LD)
GCC

$(RHIDE_LD_PASCAL)
GPC

$(RHIDE_ARFLAGS)
rcs

$(RHIDE_INCLUDES)
$(SPECIAL_CFLAGS) $(addprefix -I,$(INCLUDE_DIRS))

$(RHIDE_LIBDIRS)
$(addprefix -L,$(LIB_DIRS))

$(RHIDE_LIBS)
$(addprefix -l,$(LIBS))

$(RHIDE_LDFLAGS)
$(SPECIAL_LDFLAGS) $(addprefix -Xlinker ,$(LD_EXTRA_FLAGS))

$(RHIDE_COMPILE_C)
 
$(RHIDE_GCC) $(RHIDE_INCLUDES) $(C_DEBUG_FLAGS) \
$(C_OPT_FLAGS) $(C_WARN_FLAGS) $(C_C_LANG_FLAGS) \
$(C_EXTRA_FLAGS) $(LOCAL_OPT) -c $(SOURCE_NAME) \
-o $(OUTFILE)

$(RHIDE_COMPILE_C_FORCE)
 
$(RHIDE_GCC) $(RHIDE_INCLUDES) $(C_DEBUG_FLAGS) \
$(C_OPT_FLAGS) $(C_WARN_FLAGS) $(C_C_LANG_FLAGS) \
$(C_EXTRA_FLAGS) -x c $(LOCAL_OPT) -c $(SOURCE_NAME) \
-o $(OUTFILE)

$(RHIDE_COMPILE_CC)
 
$(RHIDE_GXX) $(RHIDE_INCLUDES) $(C_DEBUG_FLAGS) \
$(C_OPT_FLAGS) $(C_WARN_FLAGS) $(C_C_LANG_FLAGS) \
$(C_CXX_LANG_FLAGS) $(C_EXTRA_FLAGS) $(LOCAL_OPT) \
-c $(SOURCE_NAME) -o $(OUTFILE)

$(RHIDE_COMPILE_CC_FORCE)
 
$(RHIDE_GXX) $(RHIDE_INCLUDES) $(C_DEBUG_FLAGS) \
$(C_OPT_FLAGS) $(C_WARN_FLAGS) $(C_C_LANG_FLAGS) \
$(C_CXX_LANG_FLAGS) $(C_EXTRA_FLAGS) -c c++ $(LOCAL_OPT) \
-c $(SOURCE_NAME) -o $(OUTFILE)

$(RHIDE_COMPILE_ASM)
 
$(RHIDE_AS) $(RHIDE_INCLUDES) $(C_DEBUG_FLAGS) \
$(C_OPT_FLAGS) $(C_WARN_FLAGS) $(C_EXTRA_FLAGS) \
$(LOCAL_OPT) -c $(SOURCE_NAME) -o $(OUTFILE)

$(RHIDE_COMPILE_ASM_FORCE)
 
$(RHIDE_AS) $(RHIDE_INCLUDES) $(C_DEBUG_FLAGS) \
$(C_OPT_FLAGS) $(C_WARN_FLAGS) $(C_EXTRA_FLAGS) \
-x assembler $(LOCAL_OPT) -c $(SOURCE_NAME) \
-o $(OUTFILE)

$(RHIDE_GPC_FLAGS)
 
$(RHIDE_INCLUDES) $(C_DEBUG_FLAGS) $(C_OPT_FLAGS) \
$(C_WARN_FLAGS) $(C_P_LANG_FLAGS) $(C_EXTRA_FLAGS)

$(RHIDE_COMPILE_PASCAL)
 
$(RHIDE_GPC) $(RHIDE_GPC_FLAGS) $(LOCAL_OPT) \
-c $(SOURCE_NAME) -o $(OUTFILE)

$(RHIDE_COMPILE_PASCAL_FORCE)
 
$(RHIDE_GPC) $(RHIDE_GPC_FLAGS) -x pascal \
$(LOCAL_OPT) -c $(SOURCE_NAME) -o $(OUTFILE)

$(RHIDE_COMPILE_LINK)
 
$(RHIDE_LD) $(RHIDE_LIBDIRS) $(C_EXTRA_FLAGS) \
$(RHIDE_LDFLAGS) -o $(OUTFILE) $(OBJFILES) \
$(LIBRARIES) $(RHIDE_LIBS)

$(RHIDE_COMPILE_LINK_PASCAL)
 
$(RHIDE_LD_PASCAL) $(RHIDE_LIBDIRS) $(C_EXTRA_FLAGS) \
$(RHIDE_LDFLAGS) -o $(OUTFILE) $(OBJFILES) \
$(LIBRARIES) $(RHIDE_LIBS)

$(RHIDE_COMPILE_LINK_PASCAL_AUTOMAKE)
 
$(RHIDE_LD_PASCAL) $(RHIDE_LIBDIRS) $(RHIDE_LDFLAGS) \
-o $(OUTFILE) \
--automake=\"$(strip $(RHIDE_GPC_FLAGS))\" \
$(RHIDE_GPC_FLAGS) $(SOURCE_NAME) $(LIBRARIES) $(RHIDE_LIBS)

$(RHIDE_COMPILE_ARCHIVE)
 
$(RHIDE_AR) $(RHIDE_ARFLAGS) $(OUTFILE) $(OBJFILES)

$(RHIDE_FSDB)
 
fsdb $(OUTFILE) $(addprefix -p ,$(SRC_DIRS)) $(PROG_ARGS)

$(RHIDE_GDB)
 
gdb $(OUTFILE) $(addprefix -d ,$(SRC_DIRS))

$(RHIDE_GREP)
 
grep -n $(prompt arguments for GREP)

$(RHIDE_GPROF)
 
gprof $(OUTFILE)

The following are not used as real variables, but they are used to get the contents of options from RHIDE. But you can override them also by setting them as an environment variable.

$(INCLUDE_DIRS)
All the include directories

$(LIB_DIRS)
All the library directories

$(SOURCE_NAME)
The actual compiled source file

$(OUTFILE)
The actual created file

$(C_DEBUG_FLAGS)
All the debugging flags

$(C_OPT_FLAGS)
All the optimization flags

$(C_WARN_FLAGS)
All the warning flags

$(C_C_LANG_FLAGS)
All the C language flags

$(C_CXX_LANG_FLAGS)
All the C++ language flags

$(C_P_LANG_FLAGS)
All the Pascal language flags

$(LIBS)
All the libraries, which are given in the libraries options

$(LD_EXTRA_FLAGS)
All the additional linker options

$(LOCAL_OPT)
All the local options for that project item

$(OBJFILES)
All the destination files, which are part of the project and which are not a library and not excluded from linking

$(LIBRARIES)
All the libraries, which are explicitly included in the project and not excluded from linking

$(SPECIAL_CFLAGS)
Some special flags for `GCC'. Currently only the `-nostdlib' switch.

$(SPECIAL_LDFLAGS)
Some special flags for `GCC' when linking. Currently only the switches `-pg' and `-nostdlib'.

$(prompt TITLE)
RHIDE prompts for arguments which get the title `TITLE' and insert the parameters here.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.7 Change the defaults of RHIDE

If you have special wishes for compiling your source files, you can configure for RHIDE mostly everything. For adding support for other than the builtin known file types see section 4.6 Builtin variables. If you want to change the behavior of RHIDE for compiling all the known file types you should know at first really what you do. If you think, this is a good idea or if you only want only check if it works you can do it.

Before RHIDE compiles any file (this includes also linking and building a library) it searches the environment for a variable after the following scheme: When compiling a file with suffix `.c' to a file with suffix `.o' RHIDE checks for the variable $(RHIDE_COMPILE.c.o). If this variable is defined the contents of this variable is taken as the compile spec.

If you want to change the specs for linking you must take as destination suffix `.exe' or `.' and as source suffix the suffix of your object files. Example:

 
$(RHIDE_COMPILE.o.)


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.8 Message window

This window shows every time you compile a file the resulting messages, which GCC produces. These messages were converted in a special format to show them in the window. Some of the messages contain a file eventually combined with a line number. If you press ENTER on such a message, the corresponding source line in the file will be highlighted and the window with this file will be selected. If this file is not already on the desktop, it will be opened.

If the file, to which the messages refer, is already in the foreground you can see the selected source line for your messages directly on the screen.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.9 Syntax highlighting

Syntax highlighting is now supported directly by the editor. It should work in mostly every situation for all the supported types. Currently (in RHIDE) only the C/C++ style syntax highlight and the Pascal style syntax highlight are supported.

With which style a file is highlighted is chosen by RHIDE by checking the suffix of the file and determining the file type from that suffix See section 2.1 Known suffixes.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.10 Checking the dependencies

This is one of the main parts of RHIDE. To speed up the work, I have added a cache for checking the modification time of a file and for finding a file (computing the full name of a file). But sometimes the data in the cache isn't valid, especially when running under Windows. If you see this, you can clear the cache by leaving RHIDE and starting again.

If you didn't do any special things but have problems with it, please run RHIDE with the `-df' switch and try to find out, where the problem is and post it to me so I can fix it.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.11 What is Turbo Vision

The Turbo Vision library is part of Turbo C++ version 3.1. I have ported this library to use with DJGPP because I think it is the most powerful text windowing library, which is available for MS-DOS. With the help of this library you can write a front end application which looks very well and has an interface that is easy to use.

The Turbo Vision library is not only a window based text user interface, it is also a very good event handling mechanism. It supports the use of the mouse and keyboard with the ability of defining and using of hotkeys. That means, you can assign to some key or combinations of keys, which function should be executed.

The main parts of an application, which is using this library, are the desktop, the menu bar and the status line. The menu bar is usually shown as the topmost line of the screen. There are shown the main parts of the pull down menus, from where you can select the most functions, which are implemented in an application.

To use the menu you can use the mouse as well the keyboard. With the mouse you can click every where on a menu entry and the corresponding function will be executed. There are some different actions, which a menu entry can have. At first some of them, these are, for example, all the entries in the menu bar, open a submenu with more menu entries which are related to the name of this main entry. And the others, most in such a submenu, execute a definite function of the application.

With the keyboard you can walk through the menu very simply. Press F10 to activate the menu bar. In the pull down menus you can use the cursor keys to move the highlighted bar up and down and with the cursor right and left keys you can switch to next or previous menu. With the ENTER key you activate the function, which corresponds to this entry. If this was a submenu, which is indicated with a symbol like a small right arrow, this will be opened.

If you walk through the menu with the cursor keys or the mouse (hold the left mouse button down and move the mouse) in the status line will be shown for each entry a short hint for the function of this menu entry.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.12 How the dialogs work

In a dialog, like the file open dialog, are many things which you can select or where you can type in some data. At first some general functions. If you press ESC the dialog will be closed and nothing will be changed. The same can be done with the mouse by clicking on the close symbol (this is the small symbol on upper left frame of the dialog).

In the next paragraphs I will describe the most used elements of a dialog. For selecting each element of a dialog you can use the Tab key to select the next element in the dialog or the Shift+Tab key, to select the previous element.

A button is a rectangle with some text on it. If you activate such a button a specified action is executed. To select a button you can use the Tab key, until the button is specially highlighted and press ENTER then. Most times a character of the text on this button has a different color. So you can press Alt plus this character to activate the button. With the mouse you can simply click on a button to activate it.

A Listbox is a collection of some strings in one or more columns and rows as needed. The project window see section 4.4 Project window is such a Listbox with the names of the project items. You can use the cursor keys to move the focus bar in the list, or if it is a sorted Listbox, you can also type some characters and the focus will move to the item, which starts with these characters. To select a item in a list box, press SPACE or ENTER or double click with mouse on it.

In an input line you can type some text which can be edited with the usual editing keys.

A checkbox is a collection of options, which can be turned on or off. Each option has in front of it a small indicator, if it is turned on (an X is shown) or not (the X is not shown). To toggle such an option, use the cursor keys to move the focus to the option you want and press SPACE or, if a character in an option string is highlighted you can press this key and the option will be turned on or off or click with the mouse on the option.

Radiobuttons are similar to Checkboxes, but there you can select only one of all the shown options.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.13 Defining macros

Please look for a detailed documentation here: section `Pseudo Macros' in SETs Editor.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.14 The INFO Viewer

The integrated help system of RHIDE is based on the INFO Viewer written by salvador@inti.gov.ar. It gives you access to all the INFO files which you have installed in the correct directories as is done for `info.exe'.

To get help about the INFO Viewer hit F1 when the help-window is opened or follow this link to section `Top' in SETs Info Viewer.

In addition to getting help with this system you can also copy text from the help screen to the clipboard. This is useful if you want for instance to copy an example from the libc reference in your program. This feature is not so powerful as in the editor, but it is good enough. To mark some text use the Shift and cursor keys and copy the selected text with Ctrl+Ins to the clipboard.

In RHIDE you have also the possibility to get help about a specific function. Currently this works only for functions, which are documented in the libc reference. For doing this, move the cursor to the function and hit Ctrl+F1 or click with the right button of the mouse on that word.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

4.15 RCS and RHIDE

RHIDE knows a little bit about RCS, the Revision Control System. Since RCS is available also for DJGPP I enabled now some features to use RHIDE also on packages which use RCS.

RHIDE can handle RCS files in the way, that it searches for a checked in source file if the normal source file was not found. The complicatest part here was to determin the correct RCS file name from the source name. (Especially under DJGPP this is a problem since under raw DOS it is not possible to use names like 'foo.c,v').

So I decided to use the external program `rlog' which comes with the RCS package to determine the actual correct RCS source name. I did so because the DJGPP implementation knows enough about the DOS limitation and how to solve them.

This help here is not ment to be a RCS introduction. If you don't know what RCS is or what can be done with it, please look in the manuals wich come with RCS.

Here now what RHIDE knows about the RCS files. If a source file was not found, it's RCS name is computed with the spec `$(RHIDE_RLOG)' which defaults to `$(shell rlog -R $(rlog_arg))' where `$(rlog_arg)' is substituted at runtime with the actual wanted source file.

This spec can be overwritten to speed it up. An example for this can be found in the distributed sample environment file `rhide_.env'.

When RHIDE only wants to compile the file or only to get the modification time it is temporary checked out (without locking it) and after the needed operation (compiling) it is removed (for checking the modification time it is not checked out, but the time form the RCS file is taken).

If you want to open that file for editing the same is done but now it is checked out with setting a lock and it is not checked in after closing the window. The spec for checking the file out is `$(RHIDE_CO)' which can be overwritten also and it defaults to `$(shell co -q $(co_arg))' where the switch `-l' is added when it is checked out for edititing otherwise `$(co_arg)' is substituted at runtime only with the wanted source file.


[ << ] [ >> ]           [Top] [Contents] [Index] [ ? ]

This document was generated by Robert Hoehne on February, 16 2003 using texi2html