Next Previous Contents

6. List of function not covered

BRUSH::BRUSH()

        PUBLIC BRUSH::BRUSH(
                const char *_color,
                GBRUSH_STYLE _style)
        

BRUSHES::getitem()

        PUBLIC BRUSH *BRUSHES::getitem(
                int no) const
        
        

BUTTONS_INFO::BUTTONS_INFO()

        PUBLIC BUTTONS_INFO::BUTTONS_INFO(
                void)
        

BUTTONS_INFO::addhelp()

        PUBLIC void BUTTONS_INFO::addhelp(
                HELP_FILE&help,
                const char *title)
        

BUTTONS_INFO::bid2status()

        PUBLIC MENU_STATUS BUTTONS_INFO::bid2status(
                int id)

BUTTONS_INFO::delbutinfo()

        PUBLIC void BUTTONS_INFO::delbutinfo(
                void)
        

BUTTONS_INFO::dokey()

Process one key. This function is called when the focus is in the button section. It will process the help button by itself. It return -1 is nothing special happened. It return the number of the selected button otherwise. The called generally terminate then.

        PUBLIC MENU_STATUS BUTTONS_INFO::dokey(
                WINDOW *dialog,
                int key,
                int &selected,
                int other_focus)        // Is there something other that buttons
                // or something that require specific focus
        

BUTTONS_INFO::draw()

Draw all buttons

        PUBLIC void BUTTONS_INFO::draw(
                WINDOW *dialog,
                int button)     // Which buttons is currently selected
                // or -1 if none
        

BUTTONS_INFO::evalwidth()

Evaluate the horizontal space needed to draw the buttons

        PUBLIC int BUTTONS_INFO::evalwidth(
                void)
        

BUTTONS_INFO::gui_draw()

Defines all button in the GUI

        PUBLIC void BUTTONS_INFO::gui_draw(
                bool onside)
        

BUTTONS_INFO::help()

        PUBLIC void BUTTONS_INFO::help(
                WINDOW *win)
        

BUTTONS_INFO::html_draw()

        PUBLIC void BUTTONS_INFO::html_draw(
                void)
        

BUTTONS_INFO::set()

        PUBLIC void BUTTONS_INFO::set(
                int _but_options,       // MENUBUT_xxxx | MENUBUT_xxxx | ...
                HELP_FILE&_helpfile)
        

BUTTONS_INFO::setbutinfo()

        PUBLIC void BUTTONS_INFO::setbutinfo(
                int id, // MENU_xxxx (Not MENUBUT_xxxx)
                const char *title,      // Name that goes in the button
                const char *icon)       // Icon to use in html mode
        

BUTTONS_INFO::setcursor()

Set the screen cursor on the active button

        PUBLIC void BUTTONS_INFO::setcursor(
                WINDOW *dialog,
                int button)     // Which buttons is currently selected
                // or -1 if none
        

BUTTONS_INFO::setup()

Setup the coordinate of each button in the dialog

        PUBLIC void BUTTONS_INFO::setup(
                int _y, // Line where the buttons will be drawn
                int width)      // Width of the window
        

BUTTONS_INFO:: BUTTONS_INFO()

        PUBLIC BUTTONS_INFO::~BUTTONS_INFO(
                void)
        

CMDSOCK::CMDSOCK()

Ouverture d'un socket en mode listen pour serveur.

        PUBLIC CMDSOCK::CMDSOCK(
                const char *portname,
                int reuseaddr)
        

CMDSOCK::addcli()

Ajoutte un handle de plus au serveur.

        PUBLIC void CMDSOCK::addcli(
                int fd)
        

CMDSOCK::closecli()

Close the connection with a client

        PUBLIC void CMDSOCK::closecli(
                int fd)
        

CMDSOCK::forgetcli()

Forget a handle (without closing it)

        PUBLIC void CMDSOCK::forgetcli(
                int fd)
        

CMDSOCK::getnbcli()

Retourne le nombre de connexion courramment monitoré. Cette fonction est généralement utilisée pour décider si on doit terminer le service

        PUBLIC int CMDSOCK::getnbcli(
                void)
        

CMDSOCK::init()

        PRIVATE void CMDSOCK::init(
                int port,
                int reuseadr)   // set SO_REUSEADDR
        

CMDSOCK::is_ok()

Retourne != 0 si le serveur est correctement initialise

        PUBLIC int CMDSOCK::is_ok(
                void)
        

CMDSOCK::listen()

Attend de l'activite sur un handle parmi plusieurs ou une connection sur un socket. Return -1 if any error. Return 0 if the timeout was met. Return > 0 if something is available (or simply a new connexion). In that case, readnext() should be called to get some work.

        PUBLIC int CMDSOCK::listen(
                long timeout,   // seconds
                // -1 = no timeout
                //  0 = pollmode
                int &newclient)
        

CMDSOCK::process_select()

Must be called after a select(), even if it is a timeout Then readnext() is called repeatedly to process each socket as needed.

        PUBLIC int CMDSOCK::process_select(
                int sel,        // Value returned by select()
                fd_set&set,
                int &newclient,
                long timeout)
        

CMDSOCK::readnext()

Lit une transaction du prochain client actif. Retourne 0 si le client a fermé la connexion. Retourne -1 s'il n'y en a plus. Retourne le nombre de byte placé dans buf. fd contiendra le handle du client qui sera utilisé pour transmettre la reponse.

        PUBLIC int CMDSOCK::readnext(
                void *buf,
                int size,
                int &cli)
        

CMDSOCK::set_timeout()

Set a maximum idle time on a connection

        PUBLIC void CMDSOCK::set_timeout(
                int fd,
                int timeout)
        

CMDSOCK::setup_select()

Insert the various handle on which it is listening in the 3 sets. Return the largest handle inserted (or maxhandle if none were larger) CMDSOCK::process_select() is generally called after the select()

        PUBLIC int CMDSOCK::setup_select(
                fd_set&set, // set for input
                int max_handle) // Largest handle in the sets so far
        

CMDSOCK:: CMDSOCK()

        PUBLIC CMDSOCK::~CMDSOCK(
                void)
        

DIALOG::auto_newline()

This function only affects the GUI mode. Normally, after every field, a DIALOG::newline() is appended, placing every fields in a single column. When enhancing a complex dialog, one may want to place several fields on a single line. To do this, it issues several fields and then a DIALOG::newline(). This tells the layout manager to turn off auto-newline. On small dialogs, this is ok. If there is a single DIALOG::newline (or DIALOG::gui_passthrough in fact) then auto-newline is off. On more complex dialog, it becomes cumbersome. Just for one area of the dialog, you are forced to issue DIALOG::newline() all over the place. This function record the operation mode for the next fields. You can set auto-newline on or off and you can call this function several time.

        PUBLIC void DIALOG::auto_newline(
                bool mode)

DIALOG::getoffset()

Return the number of the first visible field (text mode) This function is used along with setoffset to preserve and restore the exact dialog state.

        PUBLIC int DIALOG::getoffset(
                void) const
        
        

DIALOG::gui_form()

        PUBLIC void DIALOG::gui_form(
                void)
        

DIALOG::gui_groupfit()

        PUBLIC void DIALOG::gui_groupfit(
                const char *title)
        

DIALOG::gui_labelv()

Record a label command. This only affect the GUI. Accept a va_list.

        PUBLIC void DIALOG::gui_labelv(
                const char *args,
                va_list list)
        

DIALOG::keymove_scroll()

Interpret key for horizontally scrollable dialog return -1 if the key was not processed.

        PROTECTED int DIALOG::keymove_scroll(
                WINDOW *dialog,
                int key,
                int &nof)
        

DIALOG::new_inputgrid()

Add an input grid. See samples.cc: sample_inputgrid()

        PUBLIC void DIALOG::new_inputgrid(
                int x,
                int y,
                int cellwidth,
                int cellheight,
                int nbcellh,
                int nbcellv,
                PRIVATE_MESSAGE&msg)

DIALOG::newf_chkm_str()

        PUBLIC FIELD_CHECK_MULTI *DIALOG::newf_chkm_str(
                const char *prompt,
                int &var,
                SSTRING&bufstr,
                const int vals[],       // Value corresponding to the options
                const char *options[])

DIALOG::newf_clist()

        PUBLIC FIELD_CLIST *DIALOG::newf_clist(
                const char *prompt,
                int nbvisible,
                PRIVATE_MESSAGE&msg,
                int &sel)

DIALOG::newf_ipnum()

Define a field to input an IP number

        PUBLIC FIELD_SSTRING *DIALOG::newf_ipnum(
                const char *prompt,
                SSTRING&ip)

DIALOG::newf_sheet()

        PUBLIC void DIALOG::newf_sheet(
                const char *prompt,
                const char *titles[],
                SSTRINGS&tb)

DIALOG::request_dump()

Request a dump from the dialog (even if no button was hit bu the user). This function send the request and return immediatly. Later, the dummy action MENU_DUMP will be returned by the DIALOG::edit() function. The application must be ready to process other request from the front-end, which happened just about the dump.

        PUBLIC void DIALOG::request_dump(
                void)

DIALOG::reset_guidone()

Set the DIALOG GUI state to "not done". This means that the dialog will have to be transmitted again to the GUI front-end. This is generally called when something important has changed in the dialog (a new field for example) and it can't be fixed using the GUI protocol. So the dialog will be deleted on the GUI side and redone.

        PUBLIC void DIALOG::reset_guidone(
                void)
        

DIALOG::sendintro()

        PRIVATE void DIALOG::sendintro(
                void)
        

DIALOG::set_button_on_side()

For the GUI to place the dialog buttons on the right side

        PUBLIC void DIALOG::set_button_on_side(
                void)
        

DIALOG::set_donotcheckold()

Apply FIELD::set_donotcheckold() on the last entered field

        PUBLIC void DIALOG::set_donotcheckold(
                void)
        

DIALOG::set_formparms()

Set the extra GUI parameter for form holding fields. The parameters are expressed as a sequence of var=value ...

        PUBLIC void DIALOG::set_formparms(
                const char *parms,
                ...)
        

DIALOG::set_guiparms()

Set the extra GUI parameter for the last field entered. The parameters are expressed as a sequence of var=value ...

        PUBLIC void DIALOG::set_guiparms(
                const char *parms,
                ...)
        

DIALOG::set_helpdia()

Set the help dialog trigger message on the last entered field See dialog/samples.cc for an example.

        PUBLIC void DIALOG::set_helpdia(
                PRIVATE_MESSAGE&msg)
        

DIALOG::set_nextfield()

Specify the position of the next field added to the dialog. You call this function and then newf_something() and the field will be inserted at the position you specified. Every field added from now on will be inserted one after the other at this position. You call the function again and set the position to -1 to disable to behavior.

        PUBLIC void DIALOG::set_nextfield(
                int no)
        

DIALOG::set_registry_id()

Record a unique string to identify the dialog. Combining this string with a prompt, we can uniquely identify a field of a given dialog. We use this only when two or more dialogs are sharing the same fields and we want to address those field using the registry. The string content does not matter much. Only its address matters. It is a static string.

        PUBLIC void DIALOG::set_registry_id(
                const char *id)
        

DIALOG::set_registry_key()

Set the registry key of the last entered field Registry keys are used to identify field when there is no prompt or the prompt is formatted dynamicly.

        PUBLIC void DIALOG::set_registry_key(
                const char *key)
        

DIALOG::set_selected_button()

        PUBLIC void DIALOG::set_selected_button(
                int button)
        

DIALOG::vhtml_body()

Use this function to record preformat HTML information. This function may be called several times and will override the normal formatting of dialog. This is a bypass for dialog which are HTML aware and want to do something "nicer". Using this function once will disable all other field formatting.

        PUBLIC void DIALOG::vhtml_body(
                const char *ctl,
                va_list list)
        

DIALOG::vhtml_end()

Use this function to record preformat HTML end of document which will be append after the body of the dialog.

        PUBLIC void DIALOG::vhtml_end(
                const char *ctl,
                va_list list)
        

DIALOG::vhtml_intro()

Use this function to record preformat HTML introduction which will be insert at the beginning of the dialog.

        PUBLIC void DIALOG::vhtml_intro(
                const char *ctl,
                va_list list)
        

DIALOG::vhtml_top()

Use this function to record preformat HTML top (including <body) which will override most of the top of the html dialog

        PUBLIC void DIALOG::vhtml_top(
                const char *ctl,
                va_list list)
        

DIALOG::vset_formparms()

        PUBLIC void DIALOG::vset_formparms(
                const char *parms,
                va_list list)
        

DIALOG::vset_guiparms()

Set the extra GUI parameter for the last field entered. The parameters are expressed as a sequence of var=value ...

        PUBLIC void DIALOG::vset_guiparms(
                const char *parms,
                va_list list)
        

DIALOG::vsetsidetitle()

        PUBLIC void DIALOG::vsetsidetitle(
                const char *ctl,
                va_list list)
        

DIALOG_LISTE::set_menuitem()

        PUBLIC void DIALOG_LISTE::set_menuitem(
                int no,
                const char *prompt1,
                const char *prompt2)

DIALOG_LISTE:: DIALOG_LISTE()

        PUBLIC DIALOG_LISTE::~DIALOG_LISTE(
                void)
        

DIALOG_MENU::editmenu()

Edit a menu

        PUBLIC VIRTUAL MENU_STATUS DIALOG_MENU::editmenu(
                const char *title,
                const char *prompt,
                HELP_FILE&helpfile,
                int &sel,   // Will hold the selection or -1 if escape
                // It must already contains the initial selection
                int options)    // MENUBUT_ADD | MENUBUT_INS | MENUBUT_DEL | MENUBUT_SAVE
        

DIALOG_MENU::setmenu()

Request that modules add various entries to this menu

        PUBLIC void DIALOG_MENU::setmenu(
                MENU_CONTEXT ctx)
        

DIALOG_MENUPOPUP::DIALOG_MENUPOPUP()

        PUBLIC DIALOG_MENUPOPUP::DIALOG_MENUPOPUP(
                void)

DIALOG_MENUPOPUP::editmenu()

Present a Popup menu. title may be NULL. Return MENU_OK if a selection was made. sel contain the entry selected.

        PUBLIC MENU_STATUS DIALOG_MENUPOPUP::editmenu(
                const char *title,
                int &sel)
        

DIALOG_RECORDS::DIALOG_RECORDS()

        PUBLIC DIALOG_RECORDS::DIALOG_RECORDS(
                void)
        

DIALOG_RECORDS::editmenu()

        PUBLIC MENU_STATUS DIALOG_RECORDS::editmenu(
                const char *title,
                const char *prompt,
                HELP_FILE&helpfile,
                int &sel,   // Will hold the selection or -1 if escape
                // It must already contains the initial selection
                int options)    // MENUBUT_ADD | MENUBUT_INS | MENUBUT_DEL | MENUBUT_SAVE
        

DIALOG_RECORDS::keymove()

        PROTECTED int DIALOG_RECORDS::keymove(
                WINDOW *dialog,
                int key,
                int &nof)
        

DIALOG_TEXTBOX::DIALOG_TEXTBOX()

        PUBLIC DIALOG_TEXTBOX::DIALOG_TEXTBOX(
                void)
        

DIALOG_TEXTBOX::keymove()

        PROTECTED int DIALOG_TEXTBOX::keymove(
                WINDOW *dialog,
                int key,
                int &nof)
        

DIALOG_TEXTBOX::newf_text()

Add many non editable field to a textbox Normally a dialog will contain only fields of this type. This is used to display helps and textual reports.

        PUBLIC void DIALOG_TEXTBOX::newf_text(
                const char *,   // prompt
                const SSTRINGS&strs)
        

ELM_STR::ELM_STR()

        PUBLIC ELM_STR::ELM_STR(
                const char *_value,
                const char *_shown,
                const char *_verbose)
        

ELM_STR:: ELM_STR()

        PUBLIC ELM_STR::~ELM_STR(
                void)
        

ELM_STR_V::ELM_STR_V()

        PUBLIC ELM_STR_V::ELM_STR_V(
                const char *_str,
                char &_selected)
        

FIELD::FIELD()

        PUBLIC FIELD::FIELD(
                const char *_prompt)
        

FIELD::draw()

Draw the field with the prompt and the surrounding box

        PUBLIC void FIELD::draw(
                WINDOW *dialog,
                int offset)
        

FIELD::format_htmlkey()

Build a key that uniquely identify this field in the dialog

        PUBLIC VIRTUAL void FIELD::format_htmlkey(
                char *key,
                int nof)
        

FIELD::formatpath()

        PROTECTED const char *FIELD::formatpath(
                char tmp[1000],
                const char *diapath)
        

FIELD::get_registry_key()

        PUBLIC VIRTUAL const char *FIELD::get_registry_key(
                void)
        

FIELD::getflags()

        PUBLIC VIRTUAL bool FIELD::getflags(
                unsigned &)
        

FIELD::getmenuicon()

        PUBLIC VIRTUAL const char *FIELD::getmenuicon(
                void) const
        
        

FIELD::getmenustr()

Return the second string of a menu item

        PUBLIC VIRTUAL const char *FIELD::getmenustr(
                void) const
        
        

FIELD::getnotepadlevel()

Return the notepad level. 0 for no notepad. Normal edit field return 0. FIELD_TITLE return their level. This allows DIALOG::editgui() to tell where are the FIELD_TITLE field and create a special form at the beginning of the dialog.

        PUBLIC VIRTUAL int FIELD::getnotepadlevel(
                void) const
        
        

FIELD::getwidths()

Get the width of the columns of a field. This is generally used by menu item and title field.

        PROTECTED VIRTUAL int FIELD::getwidths(
                int [], // Will contain the width
                int &)      // Will contain the 1 if this field is starting
                // a new disposition set
                // It already contain 0 so no need to touch it
        

FIELD::guisendprompt()

Transmit the prompt of a field to the GUI front-end

        PROTECTED void FIELD::guisendprompt(
                void)
        

FIELD::is_passthrough()

Return true if this field is a passthrough

        PUBLIC VIRTUAL bool FIELD::is_passthrough(
                void)
        

FIELD::is_readonly()

Is the field editable or is it write protect. Title field do use this feature.

        PUBLIC bool FIELD::is_readonly(
                void)
        

FIELD::is_selectable()

Return true if this field is selectable

        PUBLIC VIRTUAL bool FIELD::is_selectable(
                void)
        

FIELD::popup_draw()

Draw a component of a popup menu in GUI mode By default, does nothing.

        PUBLIC VIRTUAL void FIELD::popup_draw(
                int,    // ID
                int &)      // level
        

FIELD::post_validate()

This function is called when the user quits the dialog (with accept) each field may return -1 if something is not appropriate. The field is responsible to signal the error and it will become the current field immediatly.

        PUBLIC VIRTUAL int FIELD::post_validate(
                void)
        

FIELD::processmsg()

Process conditionnally a message and conditionnally redraw yourself if needed. See radio.c for the intended application.

        PROTECTED VIRTUAL void FIELD::processmsg(
                WINDOW *,
                FIELD_MSG&,
                int)
        

FIELD::return_prompt()

        PUBLIC VIRTUAL const char *FIELD::return_prompt(
                void)
        

FIELD::sendval()

Send the value to the front end if needed

        PROTECTED void FIELD::sendval(
                const char *dianame,
                int nof,
                char type,
                const char *val)
        

FIELD::set_donotcheckold()

Tell that this field value is evolving over time, so it is not possible to check the current value of the field against the one originally send with the web form. Use mainly for the clock dialog.

        PUBLIC void FIELD::set_donotcheckold(
                void)
        

FIELD::set_guiparms()

Record the extra GUI parameters for field. See ../doc/guiapi.sgml to learn which parameter are available. In general, you have dc=drawing_context

        PUBLIC void FIELD::set_guiparms(
                const char *_parms)
        

FIELD::set_guipath()

        PUBLIC void FIELD::set_guipath(
                const char *_path)
        

FIELD::set_helpdia()

        PUBLIC void FIELD::set_helpdia(
                PRIVATE_MESSAGE&_msg)
        

FIELD::set_noempty()

Indicate that this field may not be empty. This does not apply to all field. For checkbox, it is meaningless.

        PUBLIC VIRTUAL void FIELD::set_noempty(
                void)
        

FIELD::set_readonly()

Set the readonly status of a field.

        PUBLIC void FIELD::set_readonly(
                void)
        

FIELD::set_registry_key()

        PUBLIC VIRTUAL void FIELD::set_registry_key(
                const char *key)
        

FIELD::set_selectable()

Indicate that this field may be selected or not.

        PUBLIC VIRTUAL void FIELD::set_selectable(
                bool _may_select)
        

FIELD::setcursor()

Position the cursor in the field

        PUBLIC VIRTUAL void FIELD::setcursor(
                WINDOW *dialog,
                int)
        

FIELD::setwidths()

Set the width of the first column of a field. This is only meaningful for a Menu item.

        PROTECTED VIRTUAL void FIELD::setwidths(
                int,
                int [])
        

FIELD::unselect()

Called when the field loose selection. This was done mostly for menu entries which is a very special case. The default behavior does nothing.

        PUBLIC VIRTUAL void FIELD::unselect(
                WINDOW *,
                int)
        

FIELD:: FIELD()

        PUBLIC VIRTUAL FIELD::~FIELD(
                void)
        

FIELD_BUTTON::FIELD_BUTTON()

        PROTECTED FIELD_BUTTON::FIELD_BUTTON(
                const char *_str,
                const char *_icon,
                const char *_help,
                PRIVATE_MESSAGE&_msg,
                bool enter_action,
                DIALOG *_dia)
        

FIELD_BUTTON::dokey()

        PUBLIC MENU_STATUS FIELD_BUTTON::dokey(
                WINDOW *,
                int key,
                FIELD_MSG&,
                bool&)
        

FIELD_BUTTON::drawtxt()

        PUBLIC void FIELD_BUTTON::drawtxt(
                WINDOW *win,
                int)
        

FIELD_BUTTON::get_registry_value()

        PUBLIC const char *FIELD_BUTTON::get_registry_value(
                void)
        

FIELD_BUTTON::getidprefix()

        PUBLIC char FIELD_BUTTON::getidprefix(
                void)
        

FIELD_BUTTON::gui_draw()

        PUBLIC void FIELD_BUTTON::gui_draw(
                int nof,
                SSTRINGS&)
        

FIELD_BUTTON::gui_get()

        PUBLIC MENU_STATUS FIELD_BUTTON::gui_get(
                int nof,
                const char *,
                const char *actionid)
        

FIELD_BUTTON::html_draw()

        PUBLIC void FIELD_BUTTON::html_draw(
                int)
        

FIELD_BUTTON::html_validate()

        PUBLIC int FIELD_BUTTON::html_validate(
                int)
        

FIELD_BUTTON::reload()

        PUBLIC void FIELD_BUTTON::reload(
                const char *,
                int)
        

FIELD_BUTTON::restore()

        PUBLIC void FIELD_BUTTON::restore(
                void)
        

FIELD_BUTTON::save()

        PUBLIC void FIELD_BUTTON::save(
                void)
        

FIELD_BUTTON::sendval()

        PROTECTED void FIELD_BUTTON::sendval(
                const char *val)
        

FIELD_BUTTON::set_registry_value()

        PUBLIC void FIELD_BUTTON::set_registry_value(
                const char *)
        

FIELD_BUTTON:: FIELD_BUTTON()

        PUBLIC FIELD_BUTTON::~FIELD_BUTTON(
                void)
        

FIELD_BUTTON_ICON::FIELD_BUTTON_ICON()

        PUBLIC FIELD_BUTTON_ICON::FIELD_BUTTON_ICON(
                const char *_icon,
                const char *_help,
                PRIVATE_MESSAGE&_msg,
                bool enter_action,
                DIALOG *_dia)
        

FIELD_BUTTON_ICON::seticon()

Change the icon of button. If the GUI dialog is drawn, the change is made immediatly.

        PUBLIC void FIELD_BUTTON_ICON::seticon(
                const char *_icon)
        

FIELD_BUTTON_TEXT::FIELD_BUTTON_TEXT()

        PUBLIC FIELD_BUTTON_TEXT::FIELD_BUTTON_TEXT(
                const char *_str,
                const char *_help,
                PRIVATE_MESSAGE&_msg,
                bool enter_action,
                DIALOG *_dia)
        

FIELD_BUTTON_TEXT::settext()

Change the text of a button. If the GUI dialog is drawn, the change is made immediatly.

        PUBLIC void FIELD_BUTTON_TEXT::settext(
                const char *_str)
        

FIELD_CHECK::FIELD_CHECK()

        PUBLIC FIELD_CHECK::FIELD_CHECK(
                const char *_prompt,
                char &_var,
                const char *_title)
        

FIELD_CHECK::dokey()

        PUBLIC MENU_STATUS FIELD_CHECK::dokey(
                WINDOW *dialog,
                int key,
                FIELD_MSG&,
                bool&)
        

FIELD_CHECK::drawtxt()

Draw only the input part of a field

        PUBLIC void FIELD_CHECK::drawtxt(
                WINDOW *dialog,
                int)
        

FIELD_CHECK::getidprefix()

Get the letter use to define the ID of a field in GUI mode.

        PUBLIC char FIELD_CHECK::getidprefix(
                void)
        

FIELD_CHECK::gui_draw()

        PUBLIC void FIELD_CHECK::gui_draw(
                int nof,
                SSTRINGS&)
        

FIELD_CHECK::gui_get()

        PUBLIC MENU_STATUS FIELD_CHECK::gui_get(
                int nof,
                const char *,
                const char *)
        

FIELD_CHECK::html_draw()

        PUBLIC void FIELD_CHECK::html_draw(
                int nof)
        

FIELD_CHECK::html_validate()

        PUBLIC int FIELD_CHECK::html_validate(
                int nof)
        

FIELD_CHECK_BASE::FIELD_CHECK_BASE()

        PUBLIC FIELD_CHECK_BASE::FIELD_CHECK_BASE(
                const char *_prompt,
                char &_var)
        

FIELD_CHECK_BASE::get_registry_value()

        PUBLIC const char *FIELD_CHECK_BASE::get_registry_value(
                void)
        

FIELD_CHECK_BASE::set_registry_value()

        PUBLIC void FIELD_CHECK_BASE::set_registry_value(
                const char *v)
        

FIELD_CHECK_MULTI::FIELD_CHECK_MULTI()

        PUBLIC FIELD_CHECK_MULTI::FIELD_CHECK_MULTI(
                const char *_prompt,
                char &_var,
                const char *_options[])
        

FIELD_CHECK_MULTI::dokey()

        PUBLIC MENU_STATUS FIELD_CHECK_MULTI::dokey(
                WINDOW *dialog,
                int key,
                FIELD_MSG&,
                bool&)
        

FIELD_CHECK_MULTI::drawtxt()

Draw only the input part of a field

        PUBLIC void FIELD_CHECK_MULTI::drawtxt(
                WINDOW *dialog,
                int)
        

FIELD_CHECK_MULTI::getidprefix()

Get the letter use to define the ID of a field in GUI mode.

        PUBLIC char FIELD_CHECK_MULTI::getidprefix(
                void)
        

FIELD_CHECK_MULTI::gui_draw()

        PUBLIC void FIELD_CHECK_MULTI::gui_draw(
                int nof,
                SSTRINGS&)
        

FIELD_CHECK_MULTI::gui_get()

        PUBLIC MENU_STATUS FIELD_CHECK_MULTI::gui_get(
                int nof,
                const char *,
                const char *)
        

FIELD_CHECK_MULTI::html_draw()

        PUBLIC void FIELD_CHECK_MULTI::html_draw(
                int nof)
        

FIELD_CHECK_MULTI::html_validate()

        PUBLIC int FIELD_CHECK_MULTI::html_validate(
                int nof)
        

FIELD_CHECK_MULTI::reload()

        PUBLIC void FIELD_CHECK_MULTI::reload(
                const char *dianame,
                int nof)
        

FIELD_CHECK_MULTI::restore()

        PUBLIC void FIELD_CHECK_MULTI::restore(
                void)
        

FIELD_CHECK_MULTI::save()

        PUBLIC void FIELD_CHECK_MULTI::save(
                void)
        

FIELD_CHECK_MULTI_COL::FIELD_CHECK_MULTI_COL()

        PUBLIC FIELD_CHECK_MULTI_COL::FIELD_CHECK_MULTI_COL(
                const char *_prompt,
                char &_var,
                const char *_options[])
        

FIELD_CHECK_MULTI_COL::drawtxt()

Draw only the input part of a field

        PUBLIC void FIELD_CHECK_MULTI_COL::drawtxt(
                WINDOW *dialog,
                int)
        

FIELD_CHECK_MULTI_COL::getwidths()

        PUBLIC int FIELD_CHECK_MULTI_COL::getwidths(
                int tb[],
                int &)
        

FIELD_CHECK_MULTI_COL::gui_draw()

        PUBLIC void FIELD_CHECK_MULTI_COL::gui_draw(
                int nof,
                SSTRINGS&)
        

FIELD_CHECK_MULTI_COL::html_draw()

        PUBLIC void FIELD_CHECK_MULTI_COL::html_draw(
                int nof)
        

FIELD_CHECK_MULTI_COL::setwidths()

        PUBLIC void FIELD_CHECK_MULTI_COL::setwidths(
                int max_width,
                int tb[])
        

FIELD_CHECK_MULTI_VAL::FIELD_CHECK_MULTI_VAL()

        PUBLIC FIELD_CHECK_MULTI_VAL::FIELD_CHECK_MULTI_VAL(
                const char *_prompt,
                int &_var,
                const int _defvar,
                const int _vals[],      // Value corresponding to the titles
                const char *_options[],
                bool _hexmode)
        

FIELD_CHECK_MULTI_VAL::dokey()

        PUBLIC MENU_STATUS FIELD_CHECK_MULTI_VAL::dokey(
                WINDOW *dialog,
                int key,
                FIELD_MSG&,
                bool&)
        

FIELD_CHECK_MULTI_VAL::drawtxt()

        PUBLIC void FIELD_CHECK_MULTI_VAL::drawtxt(
                WINDOW *dialog,
                int offset)
        

FIELD_CHECK_MULTI_VAL::get_registry_value()

        PUBLIC const char *FIELD_CHECK_MULTI_VAL::get_registry_value(
                void)
        

FIELD_CHECK_MULTI_VAL::getcurval()

Compute the current value of the field. It is using either the value associated with the checkbox or the text input field

        PRIVATE int FIELD_CHECK_MULTI_VAL::getcurval(
                void) const
        
        

FIELD_CHECK_MULTI_VAL::gui_draw()

        PUBLIC void FIELD_CHECK_MULTI_VAL::gui_draw(
                int nof,
                SSTRINGS&)
        

FIELD_CHECK_MULTI_VAL::gui_get()

        PUBLIC MENU_STATUS FIELD_CHECK_MULTI_VAL::gui_get(
                int nof,
                const char *,
                const char *)
        

FIELD_CHECK_MULTI_VAL::html_draw()

        PUBLIC void FIELD_CHECK_MULTI_VAL::html_draw(
                int nof)
        

FIELD_CHECK_MULTI_VAL::html_validate()

        PUBLIC int FIELD_CHECK_MULTI_VAL::html_validate(
                int nof)
        

FIELD_CHECK_MULTI_VAL::post_validate()

        PUBLIC int FIELD_CHECK_MULTI_VAL::post_validate(
                void)
        

FIELD_CHECK_MULTI_VAL::reload()

        PUBLIC void FIELD_CHECK_MULTI_VAL::reload(
                const char *dianame,
                int nof)
        

FIELD_CHECK_MULTI_VAL::restore()

        PUBLIC void FIELD_CHECK_MULTI_VAL::restore(
                void)
        

FIELD_CHECK_MULTI_VAL::save()

        PUBLIC void FIELD_CHECK_MULTI_VAL::save(
                void)
        

FIELD_CHECK_MULTI_VAL::set_registry_value()

        PUBLIC void FIELD_CHECK_MULTI_VAL::set_registry_value(
                const char *value)
        

FIELD_CHECK_MULTI_VAL::setcursor()

        PUBLIC void FIELD_CHECK_MULTI_VAL::setcursor(
                WINDOW *dialog,
                int offset)
        

FIELD_CHECK_MULTI_VAL_STR::FIELD_CHECK_MULTI_VAL_STR()

        PUBLIC FIELD_CHECK_MULTI_VAL_STR::FIELD_CHECK_MULTI_VAL_STR(
                const char *_prompt,
                int &_var,
                SSTRING&_bufstr,
                const int _vals[],      // Value corresponding to the titles
                const char *_options[])
        

FIELD_CHECK_MULTI_VAL_STR::dokey()

        PUBLIC MENU_STATUS FIELD_CHECK_MULTI_VAL_STR::dokey(
                WINDOW *dialog,
                int key,
                FIELD_MSG&,
                bool&)
        

FIELD_CHECK_MULTI_VAL_STR::drawtxt()

        PUBLIC void FIELD_CHECK_MULTI_VAL_STR::drawtxt(
                WINDOW *dialog,
                int offset)
        

FIELD_CHECK_MULTI_VAL_STR::gui_draw()

        PUBLIC void FIELD_CHECK_MULTI_VAL_STR::gui_draw(
                int nof,
                SSTRINGS&)
        

FIELD_CHECK_MULTI_VAL_STR::gui_get()

        PUBLIC MENU_STATUS FIELD_CHECK_MULTI_VAL_STR::gui_get(
                int nof,
                const char *,
                const char *)
        

FIELD_CHECK_MULTI_VAL_STR::html_draw()

        PUBLIC void FIELD_CHECK_MULTI_VAL_STR::html_draw(
                int nof)
        

FIELD_CHECK_MULTI_VAL_STR::html_validate()

        PUBLIC int FIELD_CHECK_MULTI_VAL_STR::html_validate(
                int nof)
        

FIELD_CHECK_MULTI_VAL_STR::reload()

        PUBLIC void FIELD_CHECK_MULTI_VAL_STR::reload(
                const char *dianame,
                int nof)
        

FIELD_CHECK_MULTI_VAL_STR::restore()

        PUBLIC void FIELD_CHECK_MULTI_VAL_STR::restore(
                void)
        

FIELD_CHECK_MULTI_VAL_STR::save()

        PUBLIC void FIELD_CHECK_MULTI_VAL_STR::save(
                void)
        

FIELD_CHECK_MULTI_VAL_STR::setcursor()

        PUBLIC void FIELD_CHECK_MULTI_VAL_STR::setcursor(
                WINDOW *dialog,
                int offset)
        

FIELD_CHECK_RADIO::FIELD_CHECK_RADIO()

        PUBLIC FIELD_CHECK_RADIO::FIELD_CHECK_RADIO(
                const char *_prompt,
                char &_var,
                const char *_title)
        

FIELD_CHECK_RADIO::drawtxt_check()

Draw only the input part of a field

        PUBLIC void FIELD_CHECK_RADIO::drawtxt_check(
                WINDOW *dialog,
                char openchar,  // Code to draw the left side of the button
                char closechar, // Right side
                char selchar)   // Interior of the button
        

FIELD_CHECK_RADIO::format_htmlkey()

Build a key that uniquely identify this field in the dialog

        PUBLIC void FIELD_CHECK_RADIO::format_htmlkey(
                char *key,
                int nof)
        

FIELD_CHECK_RADIO::reload()

        PUBLIC void FIELD_CHECK_RADIO::reload(
                const char *dianame,
                int nof)
        

FIELD_CHECK_RADIO::restore()

        PUBLIC void FIELD_CHECK_RADIO::restore(
                void)
        

FIELD_CHECK_RADIO::return_prompt()

        PUBLIC const char *FIELD_CHECK_RADIO::return_prompt(
                void)
        

FIELD_CHECK_RADIO::save()

        PUBLIC void FIELD_CHECK_RADIO::save(
                void)
        

FIELD_CHECK_RADIO::setcursor()

Position the cursor in the field

        PUBLIC void FIELD_CHECK_RADIO::setcursor(
                WINDOW *dialog,
                int)
        

FIELD_CHECK_RADIO:: FIELD_CHECK_RADIO()

        PUBLIC FIELD_CHECK_RADIO::~FIELD_CHECK_RADIO(
                void)
        

FIELD_CLIST::FIELD_CLIST()

        PUBLIC FIELD_CLIST::FIELD_CLIST(
                const char *_prompt,
                int nbvisible,
                DIALOG *dia,
                PRIVATE_MESSAGE&_msg,
                int &sel)
        

FIELD_CLIST::addrecord()

Add a new record

        PUBLIC void FIELD_CLIST::addrecord(
                const char *s)
        

FIELD_CLIST::addrecordf()

        PUBLIC void FIELD_CLIST::addrecordf(
                const char *s,
                ...)
        

FIELD_CLIST::dokey()

        PRIVATE MENU_STATUS FIELD_CLIST::dokey(
                WINDOW *,
                int,
                FIELD_MSG&,
                bool&)
        

FIELD_CLIST::drawtxt()

        PRIVATE void FIELD_CLIST::drawtxt(
                WINDOW *,
                int)
        

FIELD_CLIST::get_registry_value()

        PUBLIC const char *FIELD_CLIST::get_registry_value(
                void)
        

FIELD_CLIST::getidprefix()

        PUBLIC char FIELD_CLIST::getidprefix(
                void)
        

FIELD_CLIST::getline()

Return one item of the list

        PUBLIC const char *FIELD_CLIST::getline(
                int no) const
        
        

FIELD_CLIST::getnb()

Return the number of record in the list

        PUBLIC int FIELD_CLIST::getnb(
                void) const
        
        

FIELD_CLIST::gui_draw()

        PRIVATE void FIELD_CLIST::gui_draw(
                int nof,
                SSTRINGS&tb)
        

FIELD_CLIST::gui_get()

        PUBLIC MENU_STATUS FIELD_CLIST::gui_get(
                int no,
                const char *field_id,
                const char *actionid)
        

FIELD_CLIST::html_draw()

        PUBLIC void FIELD_CLIST::html_draw(
                int)
        

FIELD_CLIST::html_validate()

        PUBLIC int FIELD_CLIST::html_validate(
                int)
        

FIELD_CLIST::insrecord()

Insert a new record at a specific position

        PUBLIC void FIELD_CLIST::insrecord(
                int pos,
                const char *s)
        

FIELD_CLIST::reload()

        PUBLIC void FIELD_CLIST::reload(
                const char *,
                int)
        

FIELD_CLIST::remove()

Remove one item from the list

        PUBLIC void FIELD_CLIST::remove(
                int n)
        

FIELD_CLIST::remove_last()

Remove all items after item N

        PUBLIC void FIELD_CLIST::remove_last(
                int n)
        

FIELD_CLIST::restore()

        PUBLIC void FIELD_CLIST::restore(
                void)
        

FIELD_CLIST::save()

        PUBLIC void FIELD_CLIST::save(
                void)
        

FIELD_CLIST::set_registry_value()

        PUBLIC void FIELD_CLIST::set_registry_value(
                const char *)
        

FIELD_CLIST::setcursor()

Set the cursor on a specific line of the clist. If focus is true, the clist will have keyboard focus as well.

        PUBLIC void FIELD_CLIST::setcursor(
                int pos,
                bool focus)
        

FIELD_CLIST::setheader()

Record the heading of the table. Columns are separated by tabs

        PUBLIC void FIELD_CLIST::setheader(
                const char *s)
        

FIELD_CLIST::setrecord()

Replace the value of a record. If the record does not exist the value is added to the list.

        PUBLIC void FIELD_CLIST::setrecord(
                int no,
                const char *s)
        

FIELD_CLIST::setrecordf()

        PUBLIC void FIELD_CLIST::setrecordf(
                int pos,
                const char *s,
                ...)
        

FIELD_CLIST::vaddrecordf()

        PUBLIC void FIELD_CLIST::vaddrecordf(
                const char *s,
                va_list list)
        

FIELD_CLIST::vsetrecordf()

        PUBLIC void FIELD_CLIST::vsetrecordf(
                int pos,
                const char *s,
                va_list list)
        

FIELD_CLIST:: FIELD_CLIST()

        PUBLIC FIELD_CLIST::~FIELD_CLIST(
                void)
        

FIELD_COMBO::addopts()

Add several string options to the combo box pick list

        PUBLIC void FIELD_COMBO::addopts(
                const SSTRING_KEYS&lst)
        

FIELD_COMBO::getidprefix()

Get the letter use to define the ID of a field in GUI mode.

        PUBLIC char FIELD_COMBO::getidprefix(
                void)
        

FIELD_COMBO::gui_get()

        PUBLIC MENU_STATUS FIELD_COMBO::gui_get(
                int nof,
                const char *,
                const char *)
        

FIELD_COMBO_MANY::FIELD_COMBO_MANY()

Setup a combo box where the user is allowed to pick several option at once from the pick list (unlike FIELD_COMBO)

        PUBLIC FIELD_COMBO_MANY::FIELD_COMBO_MANY(
                const char *_prompt,
                SSTRING&_str)
        

FIELD_COMBO_MANY::addopt()

Add one string option to the combo box pick list. This time there is two string. The strings will be show in the pick list like this value verbose

        PUBLIC void FIELD_COMBO_MANY::addopt(
                const char *str,
                char &selected)
        

FIELD_COMBO_MANY::assist()

        PROTECTED void FIELD_COMBO_MANY::assist(
                WINDOW *dialog)
        

FIELD_DUMMY::FIELD_DUMMY()

        PUBLIC FIELD_DUMMY::FIELD_DUMMY(
                void)
        

FIELD_DUMMY::dokey()

        PUBLIC MENU_STATUS FIELD_DUMMY::dokey(
                WINDOW *,
                int,
                FIELD_MSG&,
                bool&)
        

FIELD_DUMMY::drawtxt()

        PUBLIC void FIELD_DUMMY::drawtxt(
                WINDOW *,
                int)
        

FIELD_DUMMY::get_registry_value()

        PUBLIC const char *FIELD_DUMMY::get_registry_value(
                void)
        

FIELD_DUMMY::getidprefix()

        PUBLIC char FIELD_DUMMY::getidprefix(
                void)
        

FIELD_DUMMY::gui_draw()

        PUBLIC void FIELD_DUMMY::gui_draw(
                int,
                SSTRINGS&)
        

FIELD_DUMMY::gui_get()

        PUBLIC MENU_STATUS FIELD_DUMMY::gui_get(
                int,
                const char *,
                const char *)
        

FIELD_DUMMY::html_draw()

        PUBLIC void FIELD_DUMMY::html_draw(
                int)
        

FIELD_DUMMY::html_validate()

        PUBLIC int FIELD_DUMMY::html_validate(
                int)
        

FIELD_DUMMY::reload()

        PUBLIC void FIELD_DUMMY::reload(
                const char *,
                int)
        

FIELD_DUMMY::restore()

        PUBLIC void FIELD_DUMMY::restore(
                void)
        

FIELD_DUMMY::save()

        PUBLIC void FIELD_DUMMY::save(
                void)
        

FIELD_DUMMY::set_registry_value()

        PUBLIC void FIELD_DUMMY::set_registry_value(
                const char *)
        

FIELD_ENUM::FIELD_ENUM()

We do a trick. The contructor for FIELD_LIST need a SSTRING. We give a dummy. Later when the addopt are done, we will fill the edit buffer

        PUBLIC FIELD_ENUM::FIELD_ENUM(
                const char *_prompt,
                int &_sel)
        

FIELD_ENUM::addopt()

        PUBLIC void FIELD_ENUM::addopt(
                const char *str)
        

FIELD_ENUM::reload()

        PUBLIC void FIELD_ENUM::reload(
                const char *dianame,
                int nof)
        

FIELD_ENUM::restore()

        PUBLIC void FIELD_ENUM::restore(
                void)
        

FIELD_ENUM::save()

        PUBLIC void FIELD_ENUM::save(
                void)
        

FIELD_FLAGS::FIELD_FLAGS()

        PUBLIC FIELD_FLAGS::FIELD_FLAGS(
                unsigned _flags)
        

FIELD_FLAGS::getflags()

        PUBLIC bool FIELD_FLAGS::getflags(
                unsigned &_flags)
        

FIELD_GAUGE::FIELD_GAUGE()

        PUBLIC FIELD_GAUGE::FIELD_GAUGE(
                const char *_prompt,
                int &_val,
                int _range)
        

FIELD_GAUGE::drawtxt()

        PUBLIC void FIELD_GAUGE::drawtxt(
                WINDOW *dialog,
                int)
        

FIELD_GAUGE::gui_draw()

        PUBLIC void FIELD_GAUGE::gui_draw(
                int nof,
                SSTRINGS&)
        

FIELD_GAUGE::html_draw()

Draw the gauge in html. I guess we can do something smart here. But so far, there is no big interest for a gauge in html. This will come at some point.

        PUBLIC void FIELD_GAUGE::html_draw(
                int)
        

FIELD_HEAD::FIELD_HEAD()

        PUBLIC FIELD_HEAD::FIELD_HEAD(
                const char *_prompt,
                const char *_msg,
                bool _is_list)
        

FIELD_HEAD::drawtxt()

        PUBLIC void FIELD_HEAD::drawtxt(
                WINDOW *win,
                int offset)
        

FIELD_HEAD::getwidths()

        PROTECTED int FIELD_HEAD::getwidths(
                int tb[],
                int &reset)
        

FIELD_HEAD::gui_draw()

Draw the head field with the prompt

        PUBLIC void FIELD_HEAD::gui_draw(
                int,
                SSTRINGS&tb)
        

FIELD_HEAD::html_draw()

Draw the field with the prompt

        PUBLIC void FIELD_HEAD::html_draw(
                int)
        

FIELD_HEAD::setwidths()

        PUBLIC void FIELD_HEAD::setwidths(
                int total_width,
                int tb[])
        

FIELD_INPUTGRID::FIELD_INPUTGRID()

        PUBLIC FIELD_INPUTGRID::FIELD_INPUTGRID(
                int _x,
                int _y,
                int _cellwidth,
                int _cellheight,
                int _nbcellh,
                int _nbcellv,
                PRIVATE_MESSAGE&_msg,
                DIALOG *_dia)
        

FIELD_INPUTGRID::gui_draw()

        PUBLIC void FIELD_INPUTGRID::gui_draw(
                int nof,
                SSTRINGS&)
        

FIELD_IPNUM::FIELD_IPNUM()

        PUBLIC FIELD_IPNUM::FIELD_IPNUM(
                const char *_prompt,
                SSTRING&ip)
        

FIELD_IPNUM::post_validate()

        PUBLIC int FIELD_IPNUM::post_validate(
                void)
        

FIELD_LIST::FIELD_LIST()

        PUBLIC FIELD_LIST::FIELD_LIST(
                const char *_prompt,
                SSTRING&_str)
        

FIELD_LIST::addopt()

        PUBLIC void FIELD_LIST::addopt(
                const char *value,
                const char *verbose)
        

FIELD_LIST::dokey()

        PUBLIC MENU_STATUS FIELD_LIST::dokey(
                WINDOW *dialog,
                int,
                FIELD_MSG&,
                bool&)
        

FIELD_LIST::post_validate()

        PUBLIC VIRTUAL int FIELD_LIST::post_validate(
                void)
        

FIELD_LIST::save()

        PUBLIC void FIELD_LIST::save(
                void)
        

FIELD_MENU::FIELD_MENU()

        PUBLIC FIELD_MENU::FIELD_MENU(
                const char *_icon,
                const char *_tag,
                const char *_str)
        

FIELD_MENU::dokey()

        PROTECTED MENU_STATUS FIELD_MENU::dokey(
                WINDOW *,
                int,
                FIELD_MSG&,
                bool&)
        

FIELD_MENU::drawgen()

Print menu item

        PUBLIC void FIELD_MENU::drawgen(
                WINDOW *win,
                bool selected,
                int offset)
        

FIELD_MENU::drawtxt()

        PUBLIC void FIELD_MENU::drawtxt(
                WINDOW *dialog,
                int offset)
        

FIELD_MENU::format_htmlkey()

Build a key that uniquely identify this field in the dialog

        PUBLIC void FIELD_MENU::format_htmlkey(
                char *key,
                int no)
        

FIELD_MENU::getidprefix()

        PUBLIC char FIELD_MENU::getidprefix(
                void)
        

FIELD_MENU::getmenuicon()

        PUBLIC const char *FIELD_MENU::getmenuicon(
                void) const
        
        

FIELD_MENU::getmenustr()

Return the second string of a menu item

        PUBLIC const char *FIELD_MENU::getmenustr(
                void) const
        
        

FIELD_MENU::getwidths()

Get the width of each sub-columns of the second column. Return the number of sub-columns.

        PROTECTED int FIELD_MENU::getwidths(
                int tb[],
                int &)
        

FIELD_MENU::gui_draw()

        PUBLIC void FIELD_MENU::gui_draw(
                int nof,
                SSTRINGS&)
        

FIELD_MENU::html_draw()

        PUBLIC void FIELD_MENU::html_draw(
                int nof)
        

FIELD_MENU::html_validate()

        PUBLIC int FIELD_MENU::html_validate(
                int)
        

FIELD_MENU::popup_draw()

        PUBLIC void FIELD_MENU::popup_draw(
                int id,
                int &)
        

FIELD_MENU::restore()

        PROTECTED void FIELD_MENU::restore(
                void)
        

FIELD_MENU::save()

A FIELD_MENU is not really a string editor. The following function are just there to prevent writing over constant string.

        PROTECTED void FIELD_MENU::save(
                void)
        

FIELD_MENU::setcursor()

        PUBLIC void FIELD_MENU::setcursor(
                WINDOW *dialog,
                int offset)
        

FIELD_MENU::setwidths()

Fix the final disposition of the menu item (The start of the second column)

        PUBLIC void FIELD_MENU::setwidths(
                int total_width,
                int tb[])
        

FIELD_MENU::unselect()

        PUBLIC void FIELD_MENU::unselect(
                WINDOW *dialog,
                int offset)
        

FIELD_MENU:: FIELD_MENU()

        PUBLIC FIELD_MENU::~FIELD_MENU(
                void)
        

FIELD_MSG::FIELD_MSG()

        PUBLIC FIELD_MSG::FIELD_MSG(
                void)
        

FIELD_NUM::FIELD_NUM()

        PUBLIC FIELD_NUM::FIELD_NUM(
                const char *_prompt,
                double *_dblval,
                int *_intval,
                FLDNUM_TYPE _type,
                int _nbdecimals)
        

FIELD_NUM::dokey()

        PROTECTED MENU_STATUS FIELD_NUM::dokey(
                WINDOW *w,
                int key,
                FIELD_MSG&msg,
                bool&grab)
        

FIELD_NUM::html_draw()

Draw the field with the prompt

        PUBLIC void FIELD_NUM::html_draw(
                int nof)
        

FIELD_NUM::post_validate()

        PUBLIC int FIELD_NUM::post_validate(
                void)
        

FIELD_NUM::reload()

        PUBLIC void FIELD_NUM::reload(
                const char *dianame,
                int nof)
        

FIELD_NUM::restore()

        PUBLIC void FIELD_NUM::restore(
                void)
        

FIELD_NUM::save()

        PUBLIC void FIELD_NUM::save(
                void)
        

FIELD_NUM::validchar()

        PRIVATE bool FIELD_NUM::validchar(
                char car)
        

FIELD_PASSTHROUGH::FIELD_PASSTHROUGH()

        PUBLIC FIELD_PASSTHROUGH::FIELD_PASSTHROUGH(
                int _command,
                const char *_args)
        

FIELD_PASSTHROUGH::gui_draw()

        PUBLIC void FIELD_PASSTHROUGH::gui_draw(
                int,
                SSTRINGS&tb)
        

FIELD_PASSTHROUGH::is_passthrough()

        PUBLIC bool FIELD_PASSTHROUGH::is_passthrough(
                void)
        

FIELD_PASSWORD::FIELD_PASSWORD()

        PUBLIC FIELD_PASSWORD::FIELD_PASSWORD(
                const char *_prompt,
                SSTRING&_str)
        

FIELD_RADIO::FIELD_RADIO()

        PUBLIC FIELD_RADIO::FIELD_RADIO(
                const char *_prompt,
                char &_var,
                char _instance_val,
                const char *_title)
        

FIELD_RADIO::dokey()

        PUBLIC MENU_STATUS FIELD_RADIO::dokey(
                WINDOW *,
                int key,
                FIELD_MSG&msg,
                bool&)
        

FIELD_RADIO::drawtxt()

Draw only the input part of a field

        PUBLIC void FIELD_RADIO::drawtxt(
                WINDOW *dialog,
                int)
        

FIELD_RADIO::getidprefix()

Get the letter use to define the ID of a field in GUI mode.

        PUBLIC char FIELD_RADIO::getidprefix(
                void)
        

FIELD_RADIO::gui_draw()

        PUBLIC void FIELD_RADIO::gui_draw(
                int,
                SSTRINGS&)
        

FIELD_RADIO::gui_get()

        PUBLIC MENU_STATUS FIELD_RADIO::gui_get(
                int,
                const char *,
                const char *)
        

FIELD_RADIO::html_draw()

        PUBLIC void FIELD_RADIO::html_draw(
                int)
        

FIELD_RADIO::html_validate()

        PUBLIC int FIELD_RADIO::html_validate(
                int)
        

FIELD_RADIO::locate_key()

        PRIVATE FIELD_RADIO *FIELD_RADIO::locate_key(
                char *key)
        

FIELD_RADIO::processmsg()

        PROTECTED void FIELD_RADIO::processmsg(
                WINDOW *dialog,
                FIELD_MSG&msg,
                int drawok)
        

FIELD_RADIO:: FIELD_RADIO()

        PUBLIC FIELD_RADIO::~FIELD_RADIO(
                void)
        

FIELD_SHEET::FIELD_SHEET()

        PUBLIC FIELD_SHEET::FIELD_SHEET(
                const char *prompt,
                const char *_titles[],
                SSTRINGS&_rows)
        

FIELD_SHEET::dokey()

        PUBLIC MENU_STATUS FIELD_SHEET::dokey(
                WINDOW *,
                int,
                FIELD_MSG&,
                bool&)
        

FIELD_SHEET::drawtxt()

        PUBLIC void FIELD_SHEET::drawtxt(
                WINDOW *,
                int)
        

FIELD_SHEET::get_registry_value()

        PUBLIC const char *FIELD_SHEET::get_registry_value(
                void)
        

FIELD_SHEET::getidprefix()

        PUBLIC char FIELD_SHEET::getidprefix(
                void)
        

FIELD_SHEET::gui_draw()

        PUBLIC void FIELD_SHEET::gui_draw(
                int nof,
                SSTRINGS&)
        

FIELD_SHEET::gui_get()

        PUBLIC MENU_STATUS FIELD_SHEET::gui_get(
                int nof,
                const char *,
                const char *)
        

FIELD_SHEET::html_draw()

        PUBLIC void FIELD_SHEET::html_draw(
                int nof)
        

FIELD_SHEET::html_validate()

        PUBLIC int FIELD_SHEET::html_validate(
                int nof)
        

FIELD_SHEET::reload()

        PUBLIC void FIELD_SHEET::reload(
                const char *,
                int)
        

FIELD_SHEET::restore()

        PUBLIC void FIELD_SHEET::restore(
                void)
        

FIELD_SHEET::save()

        PUBLIC void FIELD_SHEET::save(
                void)
        

FIELD_SHEET::set_registry_value()

        PUBLIC void FIELD_SHEET::set_registry_value(
                const char *)
        

FIELD_SLIDER::FIELD_SLIDER()

        PUBLIC FIELD_SLIDER::FIELD_SLIDER(
                const char *_prompt,
                int &_val,
                int _minval,
                int _maxval)
        

FIELD_SLIDER::gui_draw()

        PUBLIC void FIELD_SLIDER::gui_draw(
                int nof,
                SSTRINGS&tb)
        

FIELD_SSTRING::FIELD_SSTRING()

        PUBLIC FIELD_SSTRING::FIELD_SSTRING(
                const char *_prompt,
                SSTRING&_str,
                int field_width)
        

FIELD_SSTRING::html_draw()

Draw the field with the prompt

        PUBLIC void FIELD_SSTRING::html_draw(
                int nof)
        

FIELD_SSTRING::reload()

        PUBLIC void FIELD_SSTRING::reload(
                const char *dianame,
                int nof)
        

FIELD_SSTRING::restore()

        PUBLIC void FIELD_SSTRING::restore(
                void)
        

FIELD_SSTRING::save()

        PUBLIC void FIELD_SSTRING::save(
                void)
        

FIELD_STRING::FIELD_STRING()

        PUBLIC FIELD_STRING::FIELD_STRING(
                const char *_prompt,
                char *_str,
                int maxsiz)
        

FIELD_STRING::reload()

Reload the input buffer from the client variable value.

        PUBLIC void FIELD_STRING::reload(
                const char *dianame,
                int nof)
        

FIELD_STRING::restore()

Restore the original value of the field from the backup

        PUBLIC void FIELD_STRING::restore(
                void)
        

FIELD_STRING::save()

        PUBLIC void FIELD_STRING::save(
                void)
        

FIELD_STRING:: FIELD_STRING()

        PUBLIC FIELD_STRING::~FIELD_STRING(
                void)
        

FIELD_STRING_BASE::FIELD_STRING_BASE()

        PROTECTED FIELD_STRING_BASE::FIELD_STRING_BASE(
                const char *_prompt,
                const char *_str,
                int maxsiz)
        

FIELD_STRING_BASE::dokey()

        PUBLIC MENU_STATUS FIELD_STRING_BASE::dokey(
                WINDOW *dialog,
                int key,
                FIELD_MSG&,
                bool&)
        

FIELD_STRING_BASE::drawtxt()

Draw only the input part of a field

        PUBLIC void FIELD_STRING_BASE::drawtxt(
                WINDOW *dialog,
                int)
        

FIELD_STRING_BASE::get_registry_value()

Return the value of the field, usable by the registry

        PUBLIC const char *FIELD_STRING_BASE::get_registry_value(
                void)
        

FIELD_STRING_BASE::getidprefix()

Get the letter use to define the ID of a field in GUI mode.

        PUBLIC char FIELD_STRING_BASE::getidprefix(
                void)
        

FIELD_STRING_BASE::gui_draw()

        PUBLIC void FIELD_STRING_BASE::gui_draw(
                int nof,
                SSTRINGS&)
        

FIELD_STRING_BASE::gui_get()

        PUBLIC MENU_STATUS FIELD_STRING_BASE::gui_get(
                int nof,
                const char *,
                const char *)
        

FIELD_STRING_BASE::html_draw()

Draw the field with the prompt

        PUBLIC void FIELD_STRING_BASE::html_draw(
                int nof)
        

FIELD_STRING_BASE::html_validate()

Grab the user input received from the www browser. Check that the current value of the field matches the hidden (old) value of the field encoded in the HTML form. If there is a mismatch, it means this www form was too old and the input is refused.

        PUBLIC int FIELD_STRING_BASE::html_validate(
                int nof)
        

FIELD_STRING_BASE::init()

        PRIVATE void FIELD_STRING_BASE::init(
                int maxsiz)
        

FIELD_STRING_BASE::is_empty()

Return true if the field is empty

        PUBLIC bool FIELD_STRING_BASE::is_empty(
                void)
        

FIELD_STRING_BASE::post_validate()

        PUBLIC int FIELD_STRING_BASE::post_validate(
                void)
        

FIELD_STRING_BASE::set_registry_value()

Record the value of the field from the registry value

        PUBLIC void FIELD_STRING_BASE::set_registry_value(
                const char *value)

FIELD_STRING_BASE::setcursor()

        PUBLIC void FIELD_STRING_BASE::setcursor(
                WINDOW *dialog,
                int)
        

FIELD_STRING_BASE:: FIELD_STRING_BASE()

        PUBLIC FIELD_STRING_BASE::~FIELD_STRING_BASE(
                void)
        

FIELD_STRING_HELP::FIELD_STRING_HELP()

This class is a virtual class. This is the building block for combo-type widget. It edit like a string, but a hotkey may trigger a helper function which may bring a help dialog or a pick list. This class do the drawing of the little button at the end of the string (an arrow in popular GUI toolkit). It intercept the hotkey and trigger the assist function (which must be derived).

        PUBLIC FIELD_STRING_HELP::FIELD_STRING_HELP(
                const char *_prompt,
                SSTRING&_str)
        

FIELD_STRING_HELP::dokey()

        PUBLIC MENU_STATUS FIELD_STRING_HELP::dokey(
                WINDOW *dialog,
                int key,
                FIELD_MSG&msg,
                bool&grab)

FIELD_STRING_HELP::drawtxt()

Draw only the input part of a field

        PUBLIC void FIELD_STRING_HELP::drawtxt(
                WINDOW *dialog,
                int offset)
        

FIELD_TEXTAREA::FIELD_TEXTAREA()

        PUBLIC FIELD_TEXTAREA::FIELD_TEXTAREA(
                const char *prompt,
                SSTRING&_text,
                int _width,     // How many visible character horizontally
                // (a hint)
                int height)
        

FIELD_TEXTAREA::clearall()

        PROTECTED void FIELD_TEXTAREA::clearall(
                WINDOW *dialog)
        

FIELD_TEXTAREA::dokey()

        PUBLIC MENU_STATUS FIELD_TEXTAREA::dokey(
                WINDOW *dialog,
                int key,
                FIELD_MSG&msg,
                bool&grab)
        

FIELD_TEXTAREA::drawtxt()

        PUBLIC void FIELD_TEXTAREA::drawtxt(
                WINDOW *dialog,
                int)
        

FIELD_TEXTAREA::get_registry_value()

        PUBLIC const char *FIELD_TEXTAREA::get_registry_value(
                void)
        

FIELD_TEXTAREA::getidprefix()

        PUBLIC char FIELD_TEXTAREA::getidprefix(
                void)
        

FIELD_TEXTAREA::gui_draw()

        PUBLIC void FIELD_TEXTAREA::gui_draw(
                int nofield,
                SSTRINGS&)
        

FIELD_TEXTAREA::gui_get()

        PUBLIC MENU_STATUS FIELD_TEXTAREA::gui_get(
                int nofield,
                const char *,
                const char *)
        

FIELD_TEXTAREA::html_draw()

        PUBLIC void FIELD_TEXTAREA::html_draw(
                int nofield)
        

FIELD_TEXTAREA::html_validate()

        PUBLIC int FIELD_TEXTAREA::html_validate(
                int)
        

FIELD_TEXTAREA::insert_char()

        PROTECTED void FIELD_TEXTAREA::insert_char(
                char c)
        

FIELD_TEXTAREA::insert_point()

        PROTECTED int FIELD_TEXTAREA::insert_point(
                void)
        

FIELD_TEXTAREA::insert_string()

        PROTECTED void FIELD_TEXTAREA::insert_string(
                char *str)
        

FIELD_TEXTAREA::line_length()

        PROTECTED int FIELD_TEXTAREA::line_length(
                int line)
        

FIELD_TEXTAREA::move_cursor()

        PROTECTED bool FIELD_TEXTAREA::move_cursor(
                cursor_dir dir)
        

FIELD_TEXTAREA::reload()

        PUBLIC void FIELD_TEXTAREA::reload(
                const char *dianame,
                int nof)
        

FIELD_TEXTAREA::restore()

        PUBLIC void FIELD_TEXTAREA::restore(
                void)
        

FIELD_TEXTAREA::save()

        PUBLIC void FIELD_TEXTAREA::save(
                void)
        

FIELD_TEXTAREA::sendlines()

Send the text to the GUI front-end line by line

        PROTECTED void FIELD_TEXTAREA::sendlines(
                void)
        

FIELD_TEXTAREA::set_registry_value()

        PUBLIC void FIELD_TEXTAREA::set_registry_value(
                const char *v)
        

FIELD_TEXTAREA::setbuf()

        PRIVATE void FIELD_TEXTAREA::setbuf(
                const char *s)
        

FIELD_TEXTAREA::setcursor()

        PROTECTED void FIELD_TEXTAREA::setcursor(
                WINDOW *dialog,
                int)
        

FIELD_TEXTBOX::FIELD_TEXTBOX()

        PUBLIC FIELD_TEXTBOX::FIELD_TEXTBOX(
                const char *_prompt,
                const char *_buf)
        

FIELD_TEXTBOX::drawtxt()

Draw only the input part of a field

        PUBLIC void FIELD_TEXTBOX::drawtxt(
                WINDOW *dialog,
                int hoffset)
        

FIELD_TEXTBOX::gui_draw()

        PUBLIC void FIELD_TEXTBOX::gui_draw(
                int,
                SSTRINGS&)
        

FIELD_TEXTBOX::html_draw()

        PUBLIC void FIELD_TEXTBOX::html_draw(
                int)
        

FIELD_TEXTBOX::html_validate()

        PUBLIC int FIELD_TEXTBOX::html_validate(
                int)
        

FIELD_TITLE::FIELD_TITLE()

        PUBLIC FIELD_TITLE::FIELD_TITLE(
                const char *_pad,
                int _level,
                const char *_prompt,
                const char *_str)
        

FIELD_TITLE::drawtxt()

        PUBLIC void FIELD_TITLE::drawtxt(
                WINDOW *win,
                int)
        

FIELD_TITLE::getmenustr()

        PUBLIC const char *FIELD_TITLE::getmenustr(
                void) const
        
        

FIELD_TITLE::getnotepadlevel()

Return the notepad level. 0 for no notepad

        PUBLIC int FIELD_TITLE::getnotepadlevel(
                void) const
        
        

FIELD_TITLE::gui_draw()

Draw the titie field with the prompt

        PUBLIC void FIELD_TITLE::gui_draw(
                int nof,
                SSTRINGS&tb)
        

FIELD_TITLE::html_draw()

Draw the field with the prompt

        PUBLIC void FIELD_TITLE::html_draw(
                int)
        

FIELD_TITLE::html_validate()

        PUBLIC int FIELD_TITLE::html_validate(
                int)
        

FIELD_TITLE::popup_draw()

        PUBLIC void FIELD_TITLE::popup_draw(
                int no,
                int &curlevel)
        

FIELD_TITLE:: FIELD_TITLE()

        PUBLIC FIELD_TITLE::~FIELD_TITLE(
                void)
        

FONT::FONT()

        PUBLIC FONT::FONT(
                int _pointsize,
                GFONT_ID _fontid,
                GFONT_STYLE _style,
                GFONT_WEIGHT _weight,
                bool _underlined)
        

FONTS::getitem()

        PUBLIC FONT *FONTS::getitem(
                int no) const
        
        

GUI_DC::GUI_DC()

        PUBLIC GUI_DC::GUI_DC(
                const char *_font,
                const char *_pen,
                const char *_brush)
        

GUI_DCS::getitem()

        PUBLIC GUI_DC *GUI_DCS::getitem(
                int no) const
        
        

GUI_RESOURCE::GUI_RESOURCE()

        PUBLIC GUI_RESOURCE::GUI_RESOURCE(
                char idletter,
                int &alloc)
        

HTML_VARVAL::HTML_VARVAL()

An HTML_VARVAL hold the content of a POST. It remember the path and the value of the different variables recover.

        PUBLIC HTML_VARVAL::HTML_VARVAL(
                const char *key)
        

HTML_VARVAL::add()

Add a value pair (varible/value) to the list

        PUBLIC void HTML_VARVAL::add(
                const char *var,
                const char *val)
        

HTML_VARVAL::exist()

Return != 0 if a given variable do exist in this list.

        PUBLIC int HTML_VARVAL::exist(
                const char *var)
        

HTML_VARVAL::getcontext()

Return the context of the object.

        PUBLIC const char *HTML_VARVAL::getcontext(
                void)
        

HTML_VARVAL::getid()

Return the context of the object.

        PUBLIC int HTML_VARVAL::getid(
                void)
        

HTML_VARVAL::getnb()

Return the number of variables in the table

        PUBLIC int HTML_VARVAL::getnb(
                void)
        

HTML_VARVAL::getval()

Return the value of a variable or "" if it is not there

        PUBLIC const char *HTML_VARVAL::getval(
                const char *var,
                int &exist)
        

HTML_VARVAL::getvar()

Return the name of a variable

        PUBLIC const char *HTML_VARVAL::getvar(
                int no)
        

LIST_STR::getitem()

        PUBLIC ELM_STR *LIST_STR::getitem(
                int no) const
        
        

LIST_STR::getshown()

Get the "significative" value associate of one item of the choice list

        PUBLIC const char *LIST_STR::getshown(
                int no) const
        
        

MASTER_REGISTRY::MASTER_REGISTRY()

        PUBLIC MASTER_REGISTRY::MASTER_REGISTRY(
                void)
        

MASTER_REGISTRY::add()

        PUBLIC int MASTER_REGISTRY::add(
                REGISTER_VARIABLES_OBJ *obj)
        

MASTER_REGISTRY::flushrecord()

        PRIVATE void MASTER_REGISTRY::flushrecord(
                void)
        

MASTER_REGISTRY::getitem()

        PUBLIC REGISTER_VARIABLES_OBJ *MASTER_REGISTRY::getitem(
                int no) const
        
        

MASTER_REGISTRY::lookup_from_prompt()

        const char *MASTER_REGISTRY::lookup_from_prompt(
                const char *_prompt,
                const char *_dialog_id)
        

MASTER_REGISTRY::lookup_index()

        int MASTER_REGISTRY::lookup_index(
                const char *_varname)
        

MASTER_REGISTRY::lookup_module()

        PUBLIC int MASTER_REGISTRY::lookup_module(
                const char *_id)
        

MASTER_REGISTRY::lookup_module_from_prompt()

        int MASTER_REGISTRY::lookup_module_from_prompt(
                const char *_prompt)
        

MASTER_REGISTRY::register_field()

        PUBLIC int MASTER_REGISTRY::register_field(
                FIELD *field,
                const char *dialog_id)
        

MASTER_REGISTRY::reregister_field()

        int MASTER_REGISTRY::reregister_field(
                FIELD *field)
        

MASTER_REGISTRY::retrieve()

        PUBLIC int MASTER_REGISTRY::retrieve(
                FIELD *field,
                const char *dialog_id)
        

MASTER_REGISTRY::retrieve_first()

        const char *MASTER_REGISTRY::retrieve_first(
                void)
        

MASTER_REGISTRY::retrieve_next()

        const char *MASTER_REGISTRY::retrieve_next(
                void)
        

MASTER_REGISTRY::retrieve_value()

        const char *MASTER_REGISTRY::retrieve_value(
                void)
        

MASTER_REGISTRY:: MASTER_REGISTRY()

        PUBLIC MASTER_REGISTRY::~MASTER_REGISTRY(
                void)
        

PEN::PEN()

        PUBLIC PEN::PEN(
                const char *_color,
                int _thick,
                GPEN_STYLE _style)
        

PENS::getitem()

        PUBLIC PEN *PENS::getitem(
                int no) const
        
        

REGISTER_VARIABLE::REGISTER_VARIABLE()

        PUBLIC REGISTER_VARIABLE::REGISTER_VARIABLE(
                const char *_varname,
                const char *_dialog_id,
                const char *_prompt,
                void(*_exec_dialog)(),
                void(*_exec_dialog_record)(const char *record, bool setting))
        

REGISTER_VARIABLE::flush()

Move the data recorded with REGISTER_VARIABLE::set() to the corresponding dialogs.

        int REGISTER_VARIABLE::flush(
                void)
        

REGISTER_VARIABLE::get()

Retrieve the value of a variable. This trigger a dialog and the field value is grabbed.

        const char *REGISTER_VARIABLE::get(
                void)
        

REGISTER_VARIABLE::get_prompt()

        PUBLIC const char *REGISTER_VARIABLE::get_prompt(
                void) const
        
        

REGISTER_VARIABLE::get_varname()

        PUBLIC const char *REGISTER_VARIABLE::get_varname(
                void) const
        
        

REGISTER_VARIABLE::getvalue()

        PUBLIC const char *REGISTER_VARIABLE::getvalue(
                void)
        

REGISTER_VARIABLE::has_been_set()

        bool REGISTER_VARIABLE::has_been_set(
                void)
        

REGISTER_VARIABLE::is_dirty()

        bool REGISTER_VARIABLE::is_dirty(
                void)
        

REGISTER_VARIABLE::is_record()

Does this registry variable control operate on records

        PUBLIC bool REGISTER_VARIABLE::is_record(
                void) const
        
        

REGISTER_VARIABLE::is_system()

        bool REGISTER_VARIABLE::is_system(
                void)
        

REGISTER_VARIABLE::mark_unset()

        void REGISTER_VARIABLE::mark_unset(
                void)
        

REGISTER_VARIABLE::mark_written()

        void REGISTER_VARIABLE::mark_written(
                void)
        

REGISTER_VARIABLE::set()

        int REGISTER_VARIABLE::set(
                const char *_value)
        

REGISTER_VARIABLE::set_not_system()

        void REGISTER_VARIABLE::set_not_system(
                void)
        

REGISTER_VARIABLE::setvalue()

        PRIVATE void REGISTER_VARIABLE::setvalue(
                const char *_value)
        

REGISTER_VARIABLE:: REGISTER_VARIABLE()

        PUBLIC REGISTER_VARIABLE::~REGISTER_VARIABLE(
                void)

REGISTER_VARIABLES::delete_varname()

        int REGISTER_VARIABLES::delete_varname(
                const char *varname)
        

REGISTER_VARIABLES::end_session()

        PUBLIC int REGISTER_VARIABLES::end_session(
                void)
        

REGISTER_VARIABLES::get()

        const char *REGISTER_VARIABLES::get(
                const char *_varname)
        

REGISTER_VARIABLES::getitem()

        PUBLIC REGISTER_VARIABLE *REGISTER_VARIABLES::getitem(
                int no) const
        
        

REGISTER_VARIABLES::loadmsg()

Map the P_MSG_U() macros to real message strings

        PRIVATE void REGISTER_VARIABLES::loadmsg(
                void)
        

REGISTER_VARIABLES::lookup_from_prompt()

Retrieve the value associated (stored) in a variable from the DIALOG field prompt

        const char *REGISTER_VARIABLES::lookup_from_prompt(
                const char *_prompt,
                const char *_dialog_id)
        

REGISTER_VARIABLES::lookup_index()

        int REGISTER_VARIABLES::lookup_index(
                const char *_prompt)
        

REGISTER_VARIABLES::lookup_var_index()

        int REGISTER_VARIABLES::lookup_var_index(
                const char *_varname)
        

REGISTER_VARIABLES::register_field()

        int REGISTER_VARIABLES::register_field(
                FIELD *field,
                const char *dialog_id)
        

REGISTER_VARIABLES::reregister_field()

        int REGISTER_VARIABLES::reregister_field(
                FIELD *field)
        

REGISTER_VARIABLES::retrieve()

        int REGISTER_VARIABLES::retrieve(
                FIELD *field)
        

REGISTER_VARIABLES::retrieve_first()

        const char *REGISTER_VARIABLES::retrieve_first(
                void)
        

REGISTER_VARIABLES::retrieve_next()

        const char *REGISTER_VARIABLES::retrieve_next(
                void)
        

REGISTER_VARIABLES::retrieve_value()

        const char *REGISTER_VARIABLES::retrieve_value(
                void)
        

REGISTER_VARIABLES::set()

Set a value for one record

        FUNC_RECORD REGISTER_VARIABLES::set(
                const char *_key,
                const char *record,
                const char *_value)
        

REGISTER_VARIABLES::start_session()

        PUBLIC int REGISTER_VARIABLES::start_session(
                void)
        

REGISTER_VARIABLES:: REGISTER_VARIABLES()

        PUBLIC REGISTER_VARIABLES::~REGISTER_VARIABLES(
                void)
        

REGISTER_VARIABLES_OBJ::REGISTER_VARIABLES_OBJ()

        PUBLIC REGISTER_VARIABLES_OBJ::REGISTER_VARIABLES_OBJ(
                const char *_module_id)
        

REGISTER_VARIABLES_OBJ::create_registry()

        PROTECTED VIRTUAL REGISTER_VARIABLE *REGISTER_VARIABLES_OBJ::create_registry(
                const char *_varname,
                const char *_dialog_id,
                const char *_prompt,
                void(*_exec_dialog)(),
                void(*_exec_dialog_record)(const char *record, bool setting))
        

REGISTER_VARIABLES_OBJ::delete_varname()

        PUBLIC VIRTUAL int REGISTER_VARIABLES_OBJ::delete_varname(
                char *varname)
        

REGISTER_VARIABLES_OBJ::end_session()

        PUBLIC VIRTUAL int REGISTER_VARIABLES_OBJ::end_session(
                void)
        

REGISTER_VARIABLES_OBJ::get()

        PUBLIC VIRTUAL const char *REGISTER_VARIABLES_OBJ::get(
                const char *_key)
        

REGISTER_VARIABLES_OBJ::get_module_id()

        PUBLIC const char *REGISTER_VARIABLES_OBJ::get_module_id(
                void)
        

REGISTER_VARIABLES_OBJ::getitem()

        PUBLIC REGISTER_VARIABLE *REGISTER_VARIABLES_OBJ::getitem(
                int no) const
        
        

REGISTER_VARIABLES_OBJ::loadmsg()

        PRIVATE VIRTUAL void REGISTER_VARIABLES_OBJ::loadmsg(
                void)
        

REGISTER_VARIABLES_OBJ::lookup_from_prompt()

        PUBLIC VIRTUAL const char *REGISTER_VARIABLES_OBJ::lookup_from_prompt(
                const char *,   // prompt
                const char *)   // dialog_id
        

REGISTER_VARIABLES_OBJ::lookup_index()

        PUBLIC VIRTUAL int REGISTER_VARIABLES_OBJ::lookup_index(
                const char *_prompt)
        

REGISTER_VARIABLES_OBJ::lookup_var_index()

        PUBLIC VIRTUAL int REGISTER_VARIABLES_OBJ::lookup_var_index(
                const char *_key)
        

REGISTER_VARIABLES_OBJ::register_field()

        PUBLIC VIRTUAL int REGISTER_VARIABLES_OBJ::register_field(
                FIELD *,
                const char *)   // dialog_id
        

REGISTER_VARIABLES_OBJ::reregister_field()

        PUBLIC VIRTUAL int REGISTER_VARIABLES_OBJ::reregister_field(
                FIELD *)
        

REGISTER_VARIABLES_OBJ::retrieve()

        PUBLIC VIRTUAL int REGISTER_VARIABLES_OBJ::retrieve(
                FIELD *field)
        

REGISTER_VARIABLES_OBJ::retrieve_first()

        PUBLIC VIRTUAL const char *REGISTER_VARIABLES_OBJ::retrieve_first(
                void)
        

REGISTER_VARIABLES_OBJ::retrieve_next()

        PUBLIC VIRTUAL const char *REGISTER_VARIABLES_OBJ::retrieve_next(
                void)
        

REGISTER_VARIABLES_OBJ::retrieve_value()

        PUBLIC VIRTUAL const char *REGISTER_VARIABLES_OBJ::retrieve_value(
                void)
        

REGISTER_VARIABLES_OBJ::set()

        PUBLIC VIRTUAL FUNC_RECORD REGISTER_VARIABLES_OBJ::set(
                const char *_key,
                const char *_record,
                const char *_value)
        

REGISTER_VARIABLES_OBJ::start_session()

        PUBLIC VIRTUAL int REGISTER_VARIABLES_OBJ::start_session(
                void)
        

REGISTER_VARIABLES_OBJ:: REGISTER_VARIABLES_OBJ()

        PUBLIC REGISTER_VARIABLES_OBJ::~REGISTER_VARIABLES_OBJ(
                void)
        

attr_clear()

* Set window to attribute 'attr'

        void attr_clear(
                WINDOW *win,
                int height,
                int width,
                chtype attr)
        

base64_decode()

Decode a base64 encode string. Return -1 if any errors.

        int base64_decode(
                char *dst,
                int sizedst,
                const char *bufcoded)

button_text2png()

        void button_text2png(
                const char *str,
                FILE *fout)

cmdsock_connect()

Etablie la connexion avec un serveur. Retourne -1 si erreur.

        EXPORT int cmdsock_connect(
                const char *servname,
                const char *portname,
                int nbretry)
        

cmdsock_wait()

Retourne le nombre de handle prêt pour une lecture (data disponible) Retourne 0 si le timeout est écoulé. Retourne -1 s'il y a un erreur.

        int cmdsock_wait(
                int nbfds,
                int fds[],
                int ready[],
                long timeout)
        

create_rc()

* Create the configuration file

        void create_rc(
                char *filename)
        

diaetc_drawinput()

Draw a string with padding on the right, without going too far

        void diaetc_drawinput(
                WINDOW *dialog,
                int x,
                int y,
                int width,
                const char *s)

diaetc_forcemono()

Record that the text mode is not allowed to use colors

        void diaetc_forcemono(
                void)
        

diagui_getlast_actionid()

Return the id of the last button pressed (or entry selection in a tree menu)

        EXPORT const char *diagui_getlast_actionid(
                void)
        

diagui_resetmsg()

Forget all recorded messages

        void diagui_resetmsg(
                void)
        

diagui_sendhtmlhelp()

Transmit an html help to the GUI frontend

        void diagui_sendhtmlhelp(
                const char *relpath)
        

diagui_sendminixpm()

        EXPORT int diagui_sendminixpm(
                const char *name,       // Name of the icon to send
                char *name_sent)        // Name selected if this one was missing
        

diagui_sethtmlhelp()

Record the fact that the GUI frontend support html helps

        void diagui_sethtmlhelp(
                void)
        

diagui_seticonpath()

Record one path to find xpm icons. The function may be called several time.

        EXPORT void diagui_seticonpath(
                const char *path)
        

diagui_showhelp()

Present a help screen. Function used internally and by some module handling the GUI themselves

        EXPORT void diagui_showhelp(
                HELP_FILE&helpfile)
        

dialog_checklist()

Display a dialog box with a list of options that can be turned on or off

        int dialog_checklist(
                const char *title,
                const char *prompt,
                HELP_FILE&helpfile,
                int,    //list_height,
                int item_no,
                char **items,
                char *status)   /* Array of flags indicating if items[x] is */
                /* selected */

dialog_checklist_p()

* Display a dialog box with a list of options that can be turned on or off

        int dialog_checklist_p(
                const char *title,
                const char *prompt,
                HELP_FILE&helpfile,
                int list_height,
                int item_no,
                char **items)

dialog_clear()

General initialisation of the user interface

        EXPORT void dialog_clear(
                void)
        

dialog_clearinit()

        void dialog_clearinit(
                void)
        

dialog_consout()

Print a message at the bottom of the screen

        EXPORT void dialog_consout(
                const char *ctl,
                ...)
        

dialog_consout_mode()

Control output on the console of various linuxconf operation

        EXPORT void dialog_consout_mode(
                bool silent_mode)
        

dialog_draw()

        void dialog_draw(
                WINDOW *dialog,
                const char *title,
                const char *internal_title,
                const char *intro,
                int height,
                int width)
        

dialog_end()

Clean up at the end of the program. Called automaticly by atexit().

        EXPORT void dialog_end(
                void)
        

dialog_endlevel()

Fall to the previous level of the DIALOG_TREE mode. Clear the position of the current level to 0.

        void dialog_endlevel(
                void)
        

dialog_get_consout_mode()

Return the operation mode for console output.

        EXPORT bool dialog_get_consout_mode(
                void)
        

dialog_getcurtimeout()

        int dialog_getcurtimeout(
                void)
        

dialog_inputbox()

Display a dialog box for inputing a string Returne MENU_ACCEPT or MENU_CANCEL or MENU_ESCAPE.

        EXPORT MENU_STATUS dialog_inputbox(
                const char *title,
                const char *intro,
                HELP_FILE&helpfile,
                char inpstr[MAX_LEN+1])
        

dialog_inputpass()

Display a dialog box for inputing a password (mangled echo) Returne MENU_ACCEPT or MENU_CANCEL or MENU_ESCAPE.

        EXPORT MENU_STATUS dialog_inputpass(
                const char *title,
                const char *prompt,
                HELP_FILE&helpfile,
                char inpstr[MAX_LEN+1])

dialog_isinit()

Return true if the dialog sub-system has been initialised

        bool dialog_isinit(
                void)
        

dialog_jump2help()

The next dialog visited won't be shown. Instead its help screen will be triggered.

        EXPORT void dialog_jump2help(
                bool mode)
        

dialog_jumpto()

Record the target of a tree jump (Jump in the menu tree). If menupath is NULL, this disable the jump

        EXPORT void dialog_jumpto(
                const char *menupath)
        

dialog_mayuselynx()

Override usage of lynx as the help previewer (disable it or not)

        void dialog_mayuselynx(
                bool mayuselynx)
        

dialog_menu()

* Display a menu for choosing among a number of options * Return MENU_OK, MENU_QUIT or MENU_ESCAPE * Depending on the options parameter, may return MENU_INS, MENU_SAVE * MENU_ADD or MENU_DEL.

        MENU_STATUS dialog_menu(
                const char *title,
                const char *prompt,
                HELP_FILE&helpfile,
                int options,    // MENUBUT_ADD | MENUBUT_INS | MENUBUT_DEL | MENUBUT_SAVE
                int item_no,
                char **items,
                int &sel)   // Will hold the selection or -1 if escape
                // It must already contains the initial selection
        

dialog_msgbox()

Display a message box.

        int dialog_msgbox(
                const char *title,
                const char *prompt,
                const char *icon)

dialog_noquitbutton()

Tell the dialog system that MENU_QUIT should always be mapped to Dismiss. This function is called by program having a pulldown menu and a quit entry.

        EXPORT void dialog_noquitbutton(
                void)
        

dialog_openwin()

Open a centered window

        WINDOW *dialog_openwin(
                int height,
                int width)
        

dialog_required()

        void dialog_required(
                void)
        

dialog_restart()

Re-initialise the text mode user interface after an external command (fiddling with the screen) has been executed. You call dialog_end, then the command, then dialog_restart.

        EXPORT void dialog_restart(
                void)
        

dialog_setmode()

Assume maximum 20 levels of menu Set the basic user interface mode. This function is generally called at startup time

        EXPORT DIALOG_MODE dialog_setmode(
                DIALOG_MODE mode)
        

dialog_setuselynx()

Record the value for using or not lynx to display help screens.

        void dialog_setuselynx(
                bool uselynx)
        

dialog_splash()

Present a splash screen using this optional xpm image. If xpm is NULL, the linuxconf splash screen is presented.

        EXPORT void dialog_splash(
                const char *xpm)

dialog_starttimeout()

Initialise the timeout before the first call to dialog_wgetch().

        void dialog_starttimeout(
                void)
        

dialog_textsize()

Evaluate the size of a text in a string. (number of line, maximum width) The string may contain tabs. Return the number of line

        int dialog_textsize(
                const char *txt,
                int *width)
        

dialog_uiok()

Return true if the UI toolkit is usable (there is a tty listening) This function is used by xconf_error to decide if the error message should be shown in a popup or simply thrown on stderr

        bool dialog_uiok(
                void)
        

dialog_usinglynx()

Return true if lynx is used to display help in text mode

        bool dialog_usinglynx(
                void)
        

dialog_wait()

Wait few seconds, but let the other thread operate

        EXPORT void dialog_wait(
                int nbseconds)
        

dialog_waitformessage()

Wait for a PRIVATE_MESSAGE. Return -1 if any error.

        EXPORT int dialog_waitformessage(
                PRIVATE_MESSAGE&msg)
        

dialog_wgetch()

Wait for a char and check the timeout. If the timeout is active, terminate every seconds to allow the dialog editor to take control once in a while

        int dialog_wgetch(
                WINDOW *w,
                MENU_STATUS&timeout_button)

draw_box()

End of print_button() End of print_button() * Draw a rectangular box with line drawing characters

        void draw_box(
                WINDOW *win,
                int y,
                int x,
                int height,
                int width,
                chtype box,
                chtype border_light,    // Receiving the light source
                chtype border_shadow)
        

draw_shadow()

        void draw_shadow(
                WINDOW *,
                int,
                int,
                int,
                int)
        

field_editline()

        bool field_editline(
                WINDOW *dialog,
                bool password_mode,
                FIELDEDIT_TYPE char_mode,
                int key,
                int box_width,
                int box_y,
                int box_x,
                int size,
                int &input_x,
                int &scroll,
                char *instr)
        

field_formatpath()

        const char *field_formatpath(
                char tmp[1000],
                const char *diapath,
                const char *fldpath)
        

fldmisc_required()

        void fldmisc_required(
                void)
        

ftitle_clist()

Format a Clist or Clist item GUI command

        void ftitle_clist(
                int nof,
                const char *tag,
                const char *buf,
                bool is_title,
                const char *dianame,    // FORM name for the setval
                bool setval)    // Updating the value of a line
        

ftitle_splitline()

        int ftitle_splitline(
                const char *buf,
                char line[1000],
                char word[1000])
        

guiid_required()

        void guiid_required(
                void)
        

guiid_setbrush()

Return the ID describing a specific brush

        EXPORT const char *guiid_setbrush(
                const char *color,
                GBRUSH_STYLE style)
        

guiid_setdc()

Allocate a new drawing context for the font,pen,brush combination. This function may be called repeatedly with the same argument and will return the same drawing context ID (It won't allocate a new one each time)

        EXPORT const char *guiid_setdc(
                const char *font,       // Font ID returned by guiid_setfont or NULL
                const char *pen,        // Pen ID returned by guiid_setpen or NULL
                const char *brush)      // Pen ID returned by guiid_setbrush or NULL

guiid_setfont()

Return the ID describing a specific font

        EXPORT const char *guiid_setfont(
                int pointsize,
                GFONT_ID fontid,
                GFONT_STYLE style,
                GFONT_WEIGHT weight,
                bool underlined)
        

guiid_setpen()

Return the ID describing a specific pen

        EXPORT const char *guiid_setpen(
                const char *color,
                int thick,
                GPEN_STYLE style)
        

html_adddialog()

        void html_adddialog(
                DIALOG *)
        

html_defselect()

Generate a <SELECT command to define a field

        void html_defselect(
                const char *name)
        

html_defvar()

        void html_defvar(
                const char *type,
                const char *name,
                int value,
                const char *opt)
        

html_defvarcur()

        void html_defvarcur(
                const char *name,
                int value)
        

html_flush()

        void html_flush(
                void)
        

html_forgetdialog()

        void html_forgetdialog(
                DIALOG *)
        

html_formatkey()

Format a message suitable as a path component of a URL. Space are transformed to ==.

        void html_formatkey(
                char *key,
                const char *ctl,
                ...)
        

html_get()

Get a command (A "get" indeed) from a client (Web browser). parse this command into a path that will silently show the way so linuxconf will silently travel to the proper menu, draw it and quit. Return -1 if there was some error or nothing has happen for a long time (no more job). Nothing to do for Linuxconf.

        int html_get(
                int _debug,
                HELP_FILE&intro,
                int timeout,    // in minutes
                char module_key[50],    // Special key allowing a URL to point straight
                // into a module menuing
                int &remhandle)     // Will contain the handle for the remote
                // GUI mode or -1
        

html_getcutinfo()

HTML aware parts of linuxconf are allowed to override the path by cutting it and placing a dummy menu selection. Return the "cut" information recorded in a previous "run". Record at the same time the cut level which will be used by setcutinfo.

        EXPORT const char *html_getcutinfo(
                void)
        

html_gethandle()

Get the current socket handle to talk to the client

        EXPORT int html_gethandle(
                void)
        

html_getoldval()

Get the original value of a field

        const char *html_getoldval(
                const char *key)
        

html_getourname()

Try to identify under which name we have been contacted. This is mainly used by the userconf/upass.c which provide POP users a way to change their password using an html form. upass.c support virtual email domain and determine the virtual domain using the output of the function. It return -1 if it can't identify our own name

        int html_getourname(
                char *name)

html_getpageparm()

Return the configurable parameters for the html BODY and HEAD directives

        void html_getpageparm(
                SSTRING&body,
                SSTRING&head)
        

html_getval()

Get the new value of a field

        EXPORT const char *html_getval(
                const char *key)
        

html_ivldurl()

Signal that an URL is invalid

        void html_ivldurl(
                void)
        

html_locatefile()

Find one file in the different hierarchy available to linuxconf and its modules

        int html_locatefile(
                const char *fname,
                const char *extension,
                char *path,
                int maxlen)
        

html_needpasswd()

Is called when a password is needed. The proper information is sent to the www browser requesting such a pawwword. The web browser will retransmit this password for the rest of the session.

        void html_needpasswd(
                void)
        

html_printf()

Add to the buffer which will be transmitted to the browser. html_flush() should be called once all the html_printf have been done. Return how many chars added to the buffer.

        EXPORT int html_printf(
                const char *ctl,
                ...)
        

html_registerpath()

Register a basepath for html file, PNGs and icons used by modules.

        void html_registerpath(
                const char *basepath)
        

html_resetpopup()

Forget about html_setpopup()

        void html_resetpopup(
                void)
        

html_sendintro()

Send the header of the html document.

        void html_sendintro(
                const char *content_type,
                int length,     // Length or -1
                int expires,    // How much seconds this document is expected to
                // be valid
                bool nocache)
        

html_setaref()

Target name + port use to reach us. Set a url pointing to a sub-menu entry

        void html_setaref(
                const char *key,        // Key for the url (path indeed)
                const char *text)       // Highlit text
        

html_setcutinfo()

Record the information which will be retrieve by the application in the next "run". html_getcutinfo() must have been called before this function, generally 1 or more dialogs before.

        EXPORT void html_setcutinfo(
                const char *s)
        

html_setdone()

Indicate that the html page has been sent and the connection can be closed.

        void html_setdone(
                void)
        

html_sethost()

Record the host name and port number to encode in URLs

        void html_sethost(
                const char *_hostname,
                int _port)
        

html_setpageparm()

Save the configurable parameter for the HTML BODY and HEAD directives. The application must call linuxconf_save() after that.

        void html_setpageparm(
                const char *body,
                const char *head)
        

html_setpopup()

#Specification: html mode / general strategy Here is a basic explanation of the way linuxconf manage html page while not being that much http/html aware. Some fact: # -Linuxconf is a classical modal program. Mostly, only one dialog has the focus at a time. Further, in linuxconf, there is generally only one dialog at once. This is acceptable for admin tasks anyway. -html mode work with the concept of hope. You send a page to a user and he may click on a button one day or never. You better not wait for it. So good for a modal program. # The strategy is simple. Linuxconf is always waiting at the top level of the menu hierachy for an html request. Each request contain a path (using /'s) allowing linuxconf to navigate in the menu hisrarchy up to a certain "level". At this point linuxconf simply draw the dialog or menu and ... get back to the top level. This behavior of always getting back is trigger by returning MENU_ESCAPE, so each part of linuxconf must be "ESCAPE" aware, which is good anyway. So when we get a path, we parse it and store it in a table and note the target_level. Important assumption here: All dialog with input are preceded in the hierarchy by menus. This make sens anyway. This disable support for popup dialog however. So we parse and store the path and lauch linuxconf from the top level menu. While navigating in its code, linuxconf draw menus (not really) and wait for input (not really also). If this menu is not of the proper level, the path information will be used as a key to identify which menu item was choosen. A MENU_OK is then returned and linuxconf continue to navigate further into sub-sub-menus (In fact the exact button returned is contain in the path). At some point, it crosses the target level. At the target level, there is two cases: Either this is GET or a POST. If this is a GET, we draw the dialog and escape away to the main loop. If this is a POST, then we load all the fields of the dialog with the values received from the POST. Based on some special values, we know which buttons was hit and return appropriatly MENU_ACCEPT, MENU_ADD and so on to the application. Three things may happen. Either there is some error message (The application identify those with html_setpopup()) or linuxconf is happy and exited to the previous level menu (Leaving this dialog screen) or linuxconf provide a sub-dialog asking for more info. Most of the logic here is controlled by the DIALOG::edithtml() function.

Record that the next DIALOG object is a popup dialog (error message)

        void html_setpopup(
                void)
        

html_stresc()

Transforme/Escape some characters so they do not confuse the browser

        void html_stresc(
                char *dst,
                const char *src,
                int size)
        

http_getbody()

Reminder of a request, kept for other protocol started from the http port such as remadmin Return the body of the last http request (The lines following the first empty one)

        const char *http_getbody(
                void)
        

init_dialog()

* Do some initialization for dialog

        void init_dialog(
                void)
        

logdebug()

        void logdebug(
                int level,
                const char *fmt,
                ...)
        

logevent()

        void logevent(
                const char *fmt,
                ...)
        

menubox_drawcols()

        void menubox_drawcols(
                const char *pt,
                int tbcol[],
                int max_width,
                WINDOW *win,
                const int hoffset,
                int pos)
        

menubox_getwidths()

Compute the width of each word in a string. Words are separated by \t. Return the number of words

        int menubox_getwidths(
                const char *pt,
                int tb[])
        

menubox_setcollect()

Register a collect function which will be called for each menu option when running in tree mode

        EXPORT void menubox_setcollect(
                void(*f)(const char *, const char *, const char *))
        

multi_alloc_gui_id()

        int multi_alloc_gui_id(
                void)
        

multi_setlistening()

Send various listen directive to the GUI to inform about the "listening" state of a dialog.

        void multi_setlistening(
                void)
        

multi_touchwins()

Invalidate all ncurses window so dialog_restart repaint the screen properly. Called by dialog_restart().

        void multi_touchwins(
                void)
        

parse_rc()

End of create_rc() End of create_rc() * Parse the configuration file and set up variables

        int parse_rc(
                void)

pass_required()

Function needed to force the linkage of pass.o

        void pass_required(
                void)
        

print_button()

* Print a button

        void print_button(
                WINDOW *win,
                const char *label,
                int y,
                int x,
                int selected)
        

sheet_required()

        void sheet_required(
                void)
        

textbox_expandtab()

Expand tab character (8) and translate some others

        void textbox_expandtab(
                const char *src,
                char *dst,
                int maxsiz)
        

uithread_init()

Initialise the user interface thread with the amount of thread which will be used. For now it can't grow. It is believed that an application with more than say 20 user interface thread (no necessarily windows) is over complicate for anyone to manage.

        EXPORT void uithread_init(
                int nbtr)
        

uithread_ok()

Register a new thread

        int uithread_ok(
                void(*fct)(void *),
                void *data)
        

uithread_setmodal()

Record the fact that the front-end do not support multi-thread dialogs

        void uithread_setmodal(
                void)
        

uithread_sync()

Wait for all User interface thread to meet here and then call the input function editfct(). The editfct must return the ID of the thread which must resume.

        void uithread_sync(
                int(*editfct)())
        

uithread_yield()

Let all the other threads run. This function will return as soon as all the other thread reach the focus point (the UI event loop generally)

        EXPORT void uithread_yield(
                void)

varval_get()

Get the HTML_VARVAL with a give ID Return NULL if not found.

        HTML_VARVAL *varval_get(
                int id)

Next Previous Contents