---

ndk++.h

Go to the documentation of this file.

// * This makes emacs happy -*-Mode: C++;-*-
/****************************************************************************
 * Copyright (c) 2002 Fabrica de Software XXI SRL - info@lafabrica.com.ar   *
 * Copyright (c) 2002 RaqLink SA - info@raqlink.com                         *
 *                                                                          *
 * Permission is hereby granted, free of charge, to any person obtaining a  *
 * copy of this software and associated documentation files (the            *
 * "Software"), to deal in the Software without restriction, including      *
 * without limitation the rights to use, copy, modify, merge, publish,      *
 * distribute, distribute with modifications, sublicense, and/or sell       *
 * copies of the Software, and to permit persons to whom the Software is    *
 * furnished to do so, subject to the following conditions:                 *
 *                                                                          *
 * The above copyright notice and this permission notice shall be included  *
 * in all copies or substantial portions of the Software.                   *
 *                                                                          *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
 * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
 *                                                                          *
 * Except as contained in this notice, the name(s) of the above copyright   *
 * holders shall not be used in advertising or otherwise to promote the     *
 * sale, use or other dealings in this Software without prior written       *
 * authorization.                                                           *
 ****************************************************************************/

/****************************************************************************
 *  Author Miguel Pinkas <miguel@lafabrica.com.ar>                          *
 ****************************************************************************/
#if !defined(__NDK_NCURSES__)
#define __NDK_NCURSES__
#include <cursesapp.h>
#include <cursesm.h>
#include <vector>
#include <string>
#include <fstream>
#include <typeinfo>
using namespace std;

#if HAVE_LIBC_H
#  include <libc.h>
#endif

#include "dlgdefines.h"

namespace NDK_XX {

ofstream &get_logfile();

struct BINDING;
struct BINDING_MAP;

/*******************************************************************
*   \class Control                                                  *
*   A Panel which behaves as a basic dialog control.               *
*   Is the base class for all the dialog controls and dialog boxes *
********************************************************************/
class Control : public NCursesPanel
{
    friend class DialogBox;
public:
    ///The styles a control can have
    enum styles{
        framed  =   0x0001, ///Do we have a frame?
        moveable=   0x0002, ///We can be moved around?
        editable=   0x0004, ///Is our text editable?
        tabstop =   0x0008, ///Can be looped thru?
        notify  =   0x0010, ///Do we notify our parent of events?
        hscroll =   0x0020, ///Can we scroll horizontally?
        multisel=   0x0040, ///Can select multiple items?
        hscrollbar= 0x0100, ///Draw horizontal scrollbar?
        vscrollbar= 0x0200, ///Draw vertical scrollbar?
        title   =   0x0400, ///Show title of this control?
        hidden  =   0x0800  ///Should we be seen in a window?
    };
    
    ///The states a control can take
    enum states{
        unknown =   0x0000,
        active  =   0x0001, ///aka Focused
        ovrwrt  =   0x0002, ///if editable==true, insert or overwrite?
        checked=    0x0004, ///If a selectable control, are we checked?
        visible =   0x0008  ///dito
    };

    /**
        Control Constructor
        @param parent:
            the parent window containing this control
        @param id
            a user defined const int identifying this control
        @param lines:
            height of the control
        @param cols
            width of the control
        @param y
            line where we are placed, relative to parent's top left
        @param x
            column where we are placed, relative to parent's top left
        @param style
            style indications for enabling/disabling control's capabilities
    */
    Control(Control *parent, int id
        ,int lines,int cols,int y, int x,int style=0)
        : NCursesPanel(lines,cols,parent->begy()+y,parent->begx()+x)
            ,pParent(parent),ctrl_id(id)
            ,field_style(style),field_state(unknown)
            ,arrow_as_tab(true)
    {
        if(has_frame()){
            box();
        }
        set_visible();
    }
    
    /**
        Control Constructor
        @param id
            a user defined const int identifying this control
        @param lines:
            height of the control
        @param cols
            width of the control
        @param y
            line where we are placed, absolute coord.
        @param x
            column where we are placed, absolute coord.
        @param style
            style indications for enabling/disabling control's capabilities
    */
    Control(int id
        ,int lines,int cols,int y, int x,int style=0)
        : NCursesPanel(lines,cols,y,x)
            ,pParent(0),ctrl_id(id)
            ,field_style(style),field_state(unknown)
            ,arrow_as_tab(true)
    {
        if(has_frame()){
            box();
        }
        set_visible();
    }
    ///tell me what styles this window has...
    styles get_style() const { return styles(field_style); }
    
    /// set all styles at once...
    styles set_styles(styles s);
    
    /// set/unset a style bit
    styles set_style(styles s,bool on=true);
    

    ///tell me what status this window is on...
    states get_state() const { return states(field_state); }
    
    /// set all states at once...
    states set_states(states s);
    
    /// set/unset a state bit
    states set_state(states s,bool on=true);
    
    /// if this style has been set...
    bool has_frame()const{return ( (field_style & framed)== framed);}
    

    /// the user can move this control?...
    bool is_moveable() const{ return ( (field_style & moveable)==moveable);}
    
    /// the user can edit this control's text?
    bool is_editable() const{ return ( (field_style & editable)==editable);}
    
    /// are we visible on the list viewport?
    bool is_visible() const{ return ( (field_state & visible)==visible);}
    
    /// a control always moves inside its parent boundaries,
    /// so make this function use only relative values...
    int mvwin(int y, int x);
    
    
    /// Usualy, a control in a dialog has some kind of text on it...
    virtual void set_text(const string &txt)=0;
    virtual string get_text()const=0 ;
    
    /// The control identifier
    int get_ctrl_id() const {return ctrl_id;};
    void set_ctrl_id(int id){ctrl_id=id;};

    ///Draw as active (i.e.,with bold frame)
    virtual void activate();
    
    ///Draw as inactive (i.e.,with normal frame)
    virtual void deactivate();
    
    ///show or hide
    void set_visible(bool new_state=true){set_state(visible,new_state);}
    
    ///Ignore /Stop ignoring us when user press tab
    void enable(bool t_or_f=true){ set_style(tabstop,t_or_f);}

    /// can make this control the active control?
    bool is_enabled()const{ return ( (field_style & tabstop)==tabstop);}
    
    ///Ignore /Stop ignoring us when user press tab
    void set_hscroll(bool t_or_f=true){ set_style(hscroll,t_or_f);}

    /// can make this control the active control?
    bool is_hscroll_set()const{ return ( (field_style & hscroll)==hscroll);}

    ///Allow multiple selections
    void set_multisel(bool t_or_f=true){ set_style(multisel,t_or_f);}

    /// can make this control the active control?
    bool is_multisel()const{ return ( (field_style & multisel)==multisel);}

    ///notify parent of changes
    void enable_notify(bool t_or_f=true){ set_style(notify,t_or_f);}

    /// should we notify our parent upon firing of action()?
    bool notify_enabled() const{ return ( (field_style & notify)==notify);}
    
    ///Set edit mode to overwrite or insert
    void set_overwrite(bool t_or_f=true){ set_state(ovrwrt,t_or_f);}
    
    /// the user current pos is overwritten or char is inserted?
    bool overwrite()const
        { return (is_editable() &&( (field_state & ovrwrt)==ovrwrt));}
        

    /// if this style has been set...
    bool has_hscrollbar()const{return ( (field_style & hscrollbar)== hscrollbar);}
    void set_hscrollbar(bool t_or_f=true){ set_style(hscrollbar,t_or_f);}
    
    bool has_vscrollbar()const{return ( (field_style & vscrollbar)== vscrollbar);}
    void set_vscrollbar(bool t_or_f=true){ set_style(vscrollbar,t_or_f);}
    
    /// Should we write the title of this control?
    bool has_show_title()const{return ( (field_style & title)== title);}
    void set_show_title(bool t_or_f=true){ set_style(title,t_or_f);}
    
    /// if set, when user presses key left or right, move to next/previous control
    void use_arrow_as_tab(bool t_or_f=true){arrow_as_tab=t_or_f;}
    bool arrow_is_tab(){return arrow_as_tab;}
    
    /// Should this control be shown at all?
    /// NOT same as visible/invisible, which is used to post/unpost a control
    /// under user actions.
    /// i.e.: we have two controls going to the same place, but we will show one
    /// and hide the other under some circumstances.
    bool is_hidden()const{return ( (field_style & hidden)== hidden);}
    void set_hidden(bool t_or_f=true){
        if(t_or_f==true){
            hide();
        }
        set_style(hidden,t_or_f);
    }
    
    
    ///call panel's show and set our state accordingly
    virtual void show(){
        if(is_hidden()) return;
        if(is_visible()) return;
        NCursesPanel::show();
        set_visible();
        enable();
    }
    
    ///call panel's hide and set our state accordingly
    virtual void hide(){
        if(!is_visible()) return;
        NCursesPanel::hide();
        set_visible(false);
        enable(false);
    }

            
    /// Delegation function to get the params from almost anywhere in NDK++
    string get_param(const string &section_name
                            ,const string &key_name
                            ,const string &val);

    /// Delegation function to get the params from almost anywhere in NDK++
    long get_param(const string &section_name
                            ,const string &key_name
                            ,long val);

    /// Delegation function to save the params from almost anywhere in NDK++
    string save_param(const string &section_name
                            ,const string &key_name
                            ,const string &val);

    /// Delegation function to save the params from almost anywhere in NDK++
    long save_param(const string &section_name
                            ,const string &key_name
                            ,long val);
    static ofstream &send_to_log(const string &what);
  /** No descriptions */
    virtual bool clicked_inside(int y, int x) const{
        return ( begy() <= y &&
                 begx() <= x &&
                 (begx() + maxx()) >= x &&
                 (begy() + maxy()) >= y
                );
    }

protected:
    Control *pParent;
    int ctrl_id;
    int field_style;
    int field_state;
    
    /// User can choose if using the arrows
    /// at left or right edges yields the
    /// same effect as pressing TAB/SHIFT-TAB
    /// default: TRUE;
    bool arrow_as_tab;
    
    /// get a chance at processing the key,
    /// before parent does
    virtual int driver(int key);
    
    ///
    /// move_left and move_right:
    ///
    /// if arrow_is_tab == true, they return
    /// false, so the owner can process KEY_LEFT
    /// and KEY_RIGHT, and properly move to
    /// previous or next control.
    virtual int move_left();
    virtual int move_right();

private:
    static const BINDING _bindingEntries[];
protected:
    static const BINDING_MAP bindingMap;
    virtual const BINDING_MAP* get_binding_map() const;
    
    /// this method starts with pTarget and clibs it way thru the inheritance
    /// tree searching for a handler for what corresponding to ctrl_id
    static bool process_message(Control *pTarget
                                    , int what, int ctrl_id, void* pExtra);
                                    
    ///Helper to find a binding for what corresponding to ctrl_id
    static const BINDING* get_binding(const BINDING* pEntry
                                            ,int what, int ctrl_id);
};

#include "ndk_bindings.h"

/************************************************************************
*   \class Label                                                            *
*   A static label.                                                     *
************************************************************************/
class Label : public Control
{
public:

    /**
        Label Constructor
        See parameters for class Control
    */

    Label( Control *parent,int id,const string &title
                    ,int lines,int cols,int y, int x
                    ,int style=tabstop|notify);

    /**
        Label Constructor
        See parameters for class Control
    */
    Label( int id,const string &title
                    ,int lines,int cols,int y, int x
                    ,int style=tabstop|notify);
    ~Label() {}


    void set_text(const string &txt);
    string get_text() const {return text;}
    
    void activate();
    void deactivate();

    ///Useful for scrolling labels in lists
    chtype operator[](int pos)const
    {
        chtype result;
        
        if(pos < 0 || pos >= text.size())
            result = getbkgd();
        else
            result = text[pos];
        
        return result;
    }

    
    ///Maximum size of contained text. (default=viewport's size)
    int max_len() const {return max_length;}
    
    int set_max_len(int len) {max_length = len;}
    
protected:
    
    string text;
    
    ///Hack to manage framed/unframed windows
    int pos_x, pos_y;
    
    ///The maximum allowed text to enter
    int max_length;

        
    ///Edition viewport.
    ///When not framed, viewport = window;
    NCursesWindow *viewport;
    
    ///cursor situation
    int cur_x, cur_y;
    
    /// first visible char
    int x_start;

    ///Update the text we present on the viewport
    virtual void refresh_text(){
        viewport->deleteln();
        viewport->addstr(cur_y,0, text.c_str(), max_len());
    }
    
    ///Calls to the panel underneath
    virtual void refresh_viewport(){
        viewport->move(cur_y,cur_x);
        viewport->cursyncup();
        viewport->refresh();
    }
};


/************************************************************************
*   \class Edit                                                         *
*   A single line, editable control.                                    *
************************************************************************/
class Edit : public Label
{
public:

    /**
        Edit Constructor
        See parameters for class Control
    */
    Edit( Control *parent,int id,const string &text
                    ,int lines,int cols,int y, int x
                    ,int style=framed|editable|tabstop|notify);

    ~Edit();
    
protected:
    
    ///This is the specialized driver for edition
    virtual int edit(int key);
    
    
    virtual int add_or_insert_char(int key);
    
    ///In overwrite mode
    virtual void add_char(int key);
    
    ///In insert mode
    virtual void insert_char(int key);
    
    virtual void refresh_text(){
        viewport->deleteln();
        viewport->addstr(   cur_y,0
                            ,text.substr(x_start,viewport->width()).c_str()
                            ,viewport->width());
    
    }
    
    int move_right();
    int move_left();
    
    int driver(int key);
};


/************************************************************************
*   \class EditNumber                                                   *
*   An Edit control, constrained to digits.                     *
************************************************************************/
class EditNumber : public Edit
{
public:

    /**
        EditNumber Constructor
        See parameters for class Control
    */
    EditNumber( Control *parent,int id,const string &text
                    ,int lines,int cols,int y, int x
                    ,int style=framed|editable|tabstop|notify)
        :Edit(parent,id,text,lines,cols,y,x,style)
        {}

    int edit(int key);
    
};


/************************************************************************
*   \class EditDate                                                     *
*   Actually, a primitive masked editor.                                *
*   it expects a string of the form dd/mm/yyyy or mm/dd/yyyy            *
*   No validation yet, but it will skip the slashes or dashes           *
*   (Validation implies creating dependencies with some datetime class) *
************************************************************************/
class EditDate:public EditNumber
{
public:
    
    /**
        EditDate Constructor
        See parameters for class Control
    */
    EditDate( Control *parent
                    ,int id, const string &msk
                    ,int y, int x
                    ,int style=editable|tabstop|notify|framed);
            
    EditDate( Control *parent,int id,const string &msk
                    ,int lines,int cols,int y, int x
                    ,int style=editable|tabstop|notify|framed);

protected:
    string mask;
    int edit(int key);
    
};


/************************************************************************
*   \class EditDouble                                                   *
*   Actually, a primitive masked editor.                                *
*   it expects a string of the form -99999,000 or +09999,99,etc         *
*   No validation yet, but it will skip the commas and signs.           *
*   (Validation implies creating dependencies with some datetime class) *
************************************************************************/
class EditDouble:public EditNumber
{
public:
    
    /**
        EditDouble Constructor
        See parameters for class Control
    */
    EditDouble( Control *parent,int id,const string &text
                    ,int lines,int cols,int y, int x
                    ,int style=framed|editable|tabstop|notify)
        :EditNumber(parent,id,text,lines,cols,y,x,style)
        {}

    int edit(int key);
    
};


/************************************************************************
*   \class Button                                                       *
*   The base class for radio buttons, push buttons and check boxes      *
************************************************************************/
class Button : public Label
{
public:
    /**
        Button Constructor
        See parameters for class Control
    */
    Button( Control *parent,int id, const string &title
                    ,int lines,int cols,int y, int x
                    ,int style=tabstop|notify);

    void activate();
    void deactivate();

    ///action fired when user presses Enter
    virtual int action()=0;
    
    ///Set this button as the default choice
    void set_default(bool t_or_f=true) {default_choice=t_or_f;}
    bool is_default()const {return default_choice;}
    
protected:
    int driver(int key);
    bool default_choice;
};


/************************************************************************
*   \class PushButton                                                   *
************************************************************************/
class PushButton : public Button
{
public:
    /**
        PushButton Constructor
        See parameters for class Control
    */
    PushButton( Control *parent,int id, const string &title
                    ,int lines,int cols,int y, int x
                    ,int style=tabstop|notify|framed);

    /**
        PushButton Constructor
        See parameters for class Control
    */
    PushButton( Control *parent,int id, const string &title
                    ,int y, int x);
                    
    void set_text(const string &txt);

    int action(){
        process_message(pParent,0,get_ctrl_id(),0);
        return TRUE;
    }
};


/************************************************************************
*   \class PropDlgPushButton                                                *
*   A specialized push button, able to take us back to the current      *
*   page on a tabbed dialog box                                         *
************************************************************************/
class PropDlgPushButton : public PushButton
{
public:
    /**
        PropDlgPushButton Constructor
        See parameters for class Control
    */
    PropDlgPushButton( Control *parent,int id, const string &title
                    ,int lines,int cols,int y, int x
                    ,int style=tabstop|notify|framed)
                    :PushButton( parent,id,title,lines,cols,y,x,style)
        {}

    /**
        PropDlgPushButton Constructor
        See parameters for class Control
    */
    PropDlgPushButton( Control *parent,int id, const string &title
                    ,int y, int x)
                    :PushButton( parent,id,title,y,x)
        {}
        
protected:
    int driver(int key){
        int result= FALSE;
        switch(key) {
            case KEY_UP:
                process_message(pParent,0,(int)RETURN_TO_PAGE,0);
                return TRUE;
            default:    result = Button::driver(key); break;
        }
        return result;
    }
};


/************************************************************************
*   \class ListItemData                                                 *
*   A helper object holding state and member info for a ListItem        *
************************************************************************/
class ListItem; //forward reference
class ListItemData
{
public:

    /**
        ListItemData Constructor
        @param txt
            the label of this list item
        @param id
            a user defined int identifying this item
        @param style
            style indications for enabling/disabling control's capabilities
        @param state
            what is the state of this item
        @param data
            user defined data. we save this and give it back to
            the user untouched and unevaluated
    */
    ListItemData(   const string &txt,int id=-1
                        ,int style=Control::tabstop|Control::notify
                        ,int state=0,void *data=0)
        :text(txt),ctrl_id(id),field_style(style)
            ,field_state(state),user_data(data)
        {
        }


    ListItemData &operator=(const ListItem &lha);
    ListItemData &operator=(const ListItemData &lha);
    
    void set_text(const string &txt){text = txt;}
    string get_text()const  {return text;}


    void set_ctrl_id(int id)        {ctrl_id = id;}
    int get_ctrl_id()   const   {return ctrl_id;}

    void set_styles(int style)  {field_style = style;}
    int get_style() const       {return field_style;}

    void set_states(int state)  {field_state = state;}
    int get_state() const       {return field_state;}

    /// set/unset a state bit
    int set_state(int s,bool on=true);

    void set_user_data(void *data)  {user_data = data;}
    void *get_user_data() const     {return user_data;}

    ///set/unset check mark
    void set_check(bool new_state=true){
        bool prev_state=is_checked();
        set_state((int)Control::checked,new_state);
    };
    
    /// is this item selected?
    bool is_checked() const
    { return ( (field_state & Control::checked)
                    == Control::checked);}

    void set_default(bool t_or_f=true) {default_choice=t_or_f;}
    bool is_default()const {return default_choice;}
    virtual int action(){return false;} 
    virtual int driver(int key){return false;}
protected:
    friend class ListBox;
    string text;
    int ctrl_id;
    int field_style;
    int field_state;
    bool default_choice;
    void *user_data;
};


/************************************************************************
*   \class ListItem                                                     *
*   The base class for items contained                                  *
*   on ListBox and derivatives                                          *
************************************************************************/
class ListItem : public Button
{
    friend class ListBox;
public:

    /**
        ListItem Constructor
        See parameters for class Control
    */
    ListItem( Control *parent,int id,const string &title
                    ,int lines,int cols,int y, int x,int style=tabstop|notify);

    void set_text(const string &txt);

    ///set/unset check mark
    void set_check(bool new_state=true){
        bool prev_state=is_checked();
        set_state(checked,new_state);
        show_state(true);
        if(prev_state!=new_state && notify_enabled())
            process_message(pParent,LI_SEL_CHANGE,get_ctrl_id(),0);
    };
    
    /// is this item selected?
    bool is_checked() const { return ( (field_state & checked)==checked);}
    
    void set_user_data(void *data){user_data = data;}
    void *get_user_data() const {return user_data;}
    
    ListItem &operator=(const ListItemData &lha);
    
protected:
    void *user_data;

    int driver(int key);

    ///specialized on children
    virtual void show_state(bool ref=false)
    {
        if(!text.empty()){
            if(is_checked()) addch(0,0, '*');
            else addch(0,0, ' ');
        }
        if(ref)refresh();
    }
    
    void refresh_text(){
        viewport->deleteln();
        show_state();
        addstr(pos_y,state_size(),text.c_str(),width()-state_size());
    }
    
    ///specialized on children
    virtual int state_size() const {return 1;};

    ///Hidden from public use
    int action() {return FALSE;}

};




/************************************************************************
*   \class RadioButton                                                  *
************************************************************************/
class RadioButton : public ListItem
{
public:

    /**
        RadioButton Constructor
        See parameters for class Control
    */
    RadioButton( Control *parent,int id, const string &title
                    ,int lines,int cols,int y, int x
                    ,int style=tabstop|notify);

    /**
        RadioButton Constructor
        See parameters for class Control
    */
    RadioButton( Control *parent,int id, const string &title
                    ,int y, int x);

protected:

    void show_state(bool ref=false){
        if(!text.empty()){
            if(is_checked()) addstr(0,0, "(0)");
            else addstr(0,0, "( )");
        }
        if(ref)refresh();
    }
    
    int state_size() const {return 3;};
};


/************************************************************************
*   \class CheckButton                                                  *
************************************************************************/
class CheckButton : public ListItem
{
public:
    /**
        CheckButton Constructor
        See parameters for class Control
    */
    CheckButton( Control *parent,int id, const string &title
                    ,int lines,int cols,int y, int x
                    ,int style=tabstop|notify);

    /**
        CheckButton Constructor
        See parameters for class Control
    */
    CheckButton( Control *parent,int id, const string &title
                    ,int y, int x);

protected:

    void show_state(bool ref=false){
        if(!text.empty()){
            if(is_checked()) addstr(0,0, "[x]");
            else addstr(0,0, "[ ]");
        }
        if(ref)refresh();
    }
    
    int state_size() const {return 3;};
};


/************************************************************************
*   \class MenuItemData                                                                                          *
************************************************************************/
class MenuBar;
class MenuItemData : public ListItemData
{
public:
    /**
        MenuItemData Constructor
        See parameters for class ListItemData
    */
    MenuItemData(const string &txt,int id=-1
                        ,int style=Control::tabstop|Control::notify
                        ,int state=0,void *data=0)
        :ListItemData(txt,id,style,state,data),pMenuItem(0)
        {
        }

protected:
    friend class MenuItem;
    friend class MenuBar;
    int action(){return false;}
    MenuItem *pMenuItem;
};


/************************************************************************
*   \class MenuItem                                                 *
************************************************************************/
class MenuItem : public ListItem
{
public:
    /**
        MenuItem Constructor
        See parameters for class Control
    */
    MenuItem( Control *parent,int id, const string &title
                    ,int lines,int cols,int y, int x
                    ,int style=tabstop|notify);

    /**
        MenuItem Constructor
        See parameters for class Control
    */
    MenuItem( Control *parent,int id, const string &title
                    ,int y, int x);

    int driver(int key);
    MenuItemData *pData;
};


/************************************************************************
*   \class ClosingMarkItem                                              *
*   The end marker for an items list.                                   *
************************************************************************/
//class ClosingMarkItem : public MenuItem
//{
//protected:
//public:
//  ClosingMarkItem() : MenuItem() { }
//  ~ClosingMarkItem(){
//  }
//};


/************************************************************************
*   \class NonImplementedItem                                           *
*   A non-functional item (you can draft your menu with these).         *
************************************************************************/
class NonImplementedItem : public MenuItemData {
public:
    NonImplementedItem(const string &text) : MenuItemData(text) {
        field_style &=!Control::tabstop;
    }
    ~NonImplementedItem(){}

};


/************************************************************************
*   \class ExitCmd                                                      *
*   This is the one to take us off the menu.                            *
************************************************************************/
class ExitCmd : public MenuItemData
{
public:
  ExitCmd(const string &text="Exit") : MenuItemData(text) { }
  ~ExitCmd(){}
  int action() { return EXIT_APP; }
};


/************************************************************************
*   \class ListBox                                                      *
*   Base class for managing lists of things                             *
************************************************************************/
typedef vector<ListItem *> VisibleItems;
typedef vector<ListItemData *> ListItems;
typedef vector<int> IndexList;

class ListBox : public Control
{
    friend class ListItem;
public:
    /**
        ListBox Constructor
        See parameters for class Control
    */
    ListBox( Control *parent,int id,const string &title
                    ,int lines,int cols,int y, int x
                    ,int style=tabstop|framed|notify);
    
    ListBox(int id,const string &title
        ,int lines,int cols,int y, int x
                    ,int style=tabstop|framed|notify);

    ~ListBox();
    
    ///You can add an item just sending in a string
    int add_item(const string &new_item, int pos=-1,bool is_default= false,bool make_visible=true);
    
    /// Here you are sending a full item data ptr.
    /// The list will own it and dispose it at destruction time
    int add_item(ListItemData *new_item,int pos=-1,bool make_visible=true);
    
    /// Drop an item from the list
    int remove_item(int pos=-1);
        
    ///Here we will manage the virtualized list
    int refresh();


        ///call panel's show and set our state accordingly
    void show(){
//      if(is_visible()) return;
        for( int idx=0; idx <items.size(); idx++){
                items[idx]->show();
        }
        Control::show();
    }
    
    ///call panel's hide and set our state accordingly
    void hide(){
//      if(!is_visible()) return;
        for( int idx=0; idx <items.size(); idx++){
                items[idx]->hide();
        }
        Control::hide();
    }

    void activate();
    void deactivate();
    
    string get_text() const {return _title;}
    void set_text(const string &v){
        _title = v;
        show_text(v,'l');
    }
    
    ///Where are we standing on the list?
    virtual int get_cur_pos();
    virtual void set_cur_pos(int pos=-1);

    ///The current checked item
    virtual int get_cur_sel();
    void set_cur_sel(int pos);
    
    ///On a multisel list, the list of checked items
    virtual void get_sel_items(IndexList &list);
    virtual void set_sel_items(const IndexList &list, bool t_or_f=true);
    
    ///Get tht text for the pos'th item
    virtual string get_item_text(int pos=-1);
    virtual void set_item_text(int pos,const string &txt);
    
    ///Select an item based on the given pattern, starting at pos
    virtual int sel_string(int pos,const string &pattern);
        
    ///Get the user data hooked on the pos'th item
    virtual void *get_item_data(int pos=-1);
    virtual void set_item_data(int pos,void *data);

    ///Get full info for the pos'th item
    virtual ListItemData *get_item(int pos=-1);
    virtual void set_item(int pos,ListItemData *item);

    ///How long is the list?
    virtual int get_count(){return data.size();};

    ///Remove all the elements
    void clear();
    int largest_name_len()const;

protected:
    string _title;
    int pos_x, pos_y;

    VisibleItems items;
    ListItems data;
    
    int curr_item;
    int first_visible;
    int last_visible;
    int cur_sel;
    int driver(int key);

    /// Put the label text at the left (0)
    /// in the specified row.
    virtual void lefttext(int row,const char* label);

    /// Put the label text to the right (ending at maxx())
    /// in the specified row.
    virtual void righttext(int row,const char* label);

    void show_text(const string &t,char where);

    virtual void adjust_visible_items();

    virtual int move_up();  
    virtual int move_down();
    
    virtual void activate_item(int item_idx);
    virtual void deactivate_item(int item_idx);

    ///Copy to the buffer the full info of item_idx'th item
    void update_data(int item_idx);
    
    ///Copy to the visible item the full info of item_idx'th item
    void update_item(int item_idx);
    
    ///Refresh the visible elements
    void refresh_items();
    
    ///Clear (erase) the visible items
    void clear_items();
    
    ///Clear (erase) the full list of items
    void delete_data();
    
    /// If there are no elements to show, put the 'Empty' tag
    void show_empty();
    
    ///Draw a vertical scroll bar (just visual sugar, we don't have mouse yet)
    void draw_scrollbar();
    
    ///Virtualize the requested item index
    ListItem *&visible_item(int requested)
                                    {return items[requested-first_visible];}

    ///Do we allow multiple selection?
    void check_multisel(int pos, bool t_or_f);
    
    void on_sel_change(int);
    
    ///A macro for enabling message processing (see ndk_bindings.h)
    DECLARE_BINDINGS();
};


/************************************************************************
*   \class SelectionBox                                                 *
*   A derivation of ListBox, is a plain list selection box without      *
*   radio or check buttons                                              *                                                                   *
************************************************************************/
class SelectionBox : public ListBox
{
public:
    /**
        SelectionBox Constructor
        See parameters for class Control
    */
    SelectionBox( Control *parent,int id,const string &title
                    ,int lines,int cols,int y, int x
                    ,int style=tabstop|framed|notify)
        :ListBox( parent,id,title
                    ,lines,cols,y, x
                    ,style)
        {
            initialize_items();
        }

    /**
        SelectionBox Constructor
        See parameters for class Control
    */
    SelectionBox( int id,const string &title
                    ,int lines,int cols,int y, int x
                    ,int style=tabstop|framed|notify)
        :ListBox( id,title
                    ,lines,cols,y, x
                    ,style)
        {
            initialize_items();
        }
protected:
    ///Load the visible components of the list
    void initialize_items();
};


/************************************************************************
*   \class CheckListBox                                                 *
*   A ListBox with check buttons on it (usually multiselect-enabled     *
************************************************************************/
class CheckListBox : public ListBox
{
public:
    /**
        CheckListBox Constructor
        See parameters for class Control
    */
    CheckListBox( Control *parent,int id,const string &title
                    ,int lines,int cols,int y, int x
                    ,int style=tabstop|framed|notify)
        :ListBox( parent,id,title
                    ,lines,cols,y, x
                    ,style)
        {
            initialize_items();
        }
                    
protected:
    ///Load the visible components of the list
    void initialize_items();
};


/************************************************************************
*   \class ChoiceBox                                                        *
*   A ListBox with radio buttons (usually single selectable)        *
************************************************************************/
class ChoiceBox : public ListBox
{
public:
    /**
        CheckListBox Constructor
        See parameters for class Control
    */
    ChoiceBox( Control *parent,int id,const string &title
                    ,int lines,int cols,int y, int x
                    ,int style=tabstop|framed|notify)
        :ListBox( parent,id,title
                    ,lines,cols,y, x
                    ,style)
        {
            initialize_items();
        }
                    
protected:
    ///Load the visible components of the list
    void initialize_items();
};


/************************************************************************
*   \class MenuBar                                                  *
*   A menu bar is a menu containing popup and regular items             *
*   by default, it has centered top and bottom labels and               *
*   wide orientation                                                    *
************************************************************************/
class MenuBar : public ListBox
{
public:
    /**
        MenuBar Constructor
        @param orient (default: h)
            this menu bar will deploy
            h (horizontally) or v (vertically)

        other params: See parameters for class Control
    */
    MenuBar( int id,const string &title
                    ,int lines,int cols,int y, int x
                    ,char orient='h'
                    ,int style=hidden|tabstop|notify)
        :ListBox(id,title
                    ,lines,cols,y, x
                    ,style),orientation(orient),b_own_items(true),is_main_menu(false)
        {
        }

    ~MenuBar(){
        if(!b_own_items){
            data.clear();
        }
    }   

    ///we are wide-oriented or tall-oriented?
    char get_orientation()const{return orientation;}
    int execute();
    
    /// specialized add_item: a MenuBar, as oposed to a ListBox
    /// adds the visible item at the same time as the data item
    /// (implicit to this is that you should not add more data items
    /// than the visible ones.
    /// This limitation is which allows us to deploy the items each one
    /// at its own position. (By now, anyway.  Later we may add the ability
    /// to scroll items, but it's unlikely we will ever want to...)
    int add_item(MenuItemData *new_item){
        string txt(new_item->get_text());
        new_item->pMenuItem = new MenuItem(this,-1,txt,1,txt.size()+1,get_next_item_y(),get_next_item_x());
        items.push_back(new_item->pMenuItem);
        curr_item++;
        new_item->pMenuItem->pData =new_item;
        new_item->set_ctrl_id(data.size());
        return ListBox::add_item(new_item,-1,false);
    };

    /// If we get only a text, then the assumed intention
    /// is to place a placeholder (i.e. a non implemented yet label
    int add_item(const string & text){
        return add_item(new NonImplementedItem(text));};
    void items_owner(bool t_or_f=true){b_own_items=t_or_f;};

    /// This one si for processing of the ESC key.
    /// On the main menu, you MUST treat ESC as EXIT_APP, don't you...?
    /// This flag lets the driver know what behavior is intended
    bool is_main_menu;
protected:
    bool b_own_items; ///Should we delete the added items?
    char orientation;

    string titlePos;

    int move_up(){
        if(orientation=='h')
            return move_left();
        ListBox::move_up();
        return false;
    };  
    int move_down(){
        if(orientation=='h')
            return execute_current_item(KEY_ENTER);
        ListBox::move_down();
        return false;
    };  
    int move_left(){
        if(orientation=='v')
            return move_up();
        ListBox::move_up();
        return false;
    };  
    int move_right(){
        if(orientation=='v')
            return move_down();
        ListBox::move_down();
        return false;
    };  

    int driver(int key);
    int execute_current_item(int key);

    /// mouse support
    void find_clicked();

    /// Calculate the position of the next item to be inserted
    int get_next_item_y();
    int get_next_item_x();
};


/************************************************************************
*   \class FramedMenuBar                                                *
*   Ok,don't need to explain what is this, right...?                    *
************************************************************************/
class FramedMenuBar : public MenuBar
{
public:

    /**
        FramedMenuBar Constructor
    */
    FramedMenuBar(int id,const string &title
                    ,int lines,int cols,int y, int x
                    ,char orient='h'
                    ,int style=tabstop|framed|notify)
        :  MenuBar (id,title,lines+2,cols,y,x,orient,style)
    {
    }
};


/************************************************************************
*   \class SubMenu                                                  *
*   A Menu that delpoys itself relative to a popup menu item.           *
************************************************************************/
class SubMenu : public MenuBar
{
public:
    /**
        SubMenu Constructor
    */
    SubMenu(int id,const string &title
                    ,int lines,int cols,int y, int x
                    ,char orient='h'
                    ,int style=tabstop|framed|notify)
        :  MenuBar (id,title,lines+2,cols+2+1,y,x,orient,style)
    {
    }
    ~SubMenu() {
    }

    int move_up(){
        if(orientation=='h')
            return true;
        return MenuBar::move_up();
    };  
    int move_down(){
        if(orientation=='h')
            return true;
        return MenuBar::move_down();
    };  
    int move_left(){
        if(orientation=='v')
            return true;
        return MenuBar::move_left();
    };  
    int move_right(){
        if(orientation=='v')
            return true;
        return MenuBar::move_right();
    };  
};


/************************************************************************
*   \class PopUpMenu                                                    *
*   A popup menu item which displays a submenu.                         *
*   the popup menu manages the liftime of the items.                    *
************************************************************************/
class PopUpMenu : public MenuItemData
{
public:
    PopUpMenu(const string &text) : MenuItemData(text),S(0),cur_sel(-1){    }
    ~PopUpMenu();
    
    int action();
    
    int largest_name_len()const;

protected:
    /// So we can know the right width for the submenu
    string sub_menu_label;
    ListItems items;
    SubMenu *S;
    int cur_sel;
};


/************************************************************************
*   \class DialogBox                                                        *
*   (aka form window)
************************************************************************/
typedef vector <Control *> ListOfChildren;

class DialogBox: public Control
{
public:
    enum dlg_styles{
        info        = 0x0100,
        warning     = 0x0200,
        error       = 0x0400,
        okCancel    = 0x0001,
        yesNo       = 0x0002,
        yesNoCancel = 0x0004
    };

    enum Dlg_Request{
        DLG_LOW = PAD_HIGH + 1,
        REQ_DLG_REFRESH = DLG_LOW,
        REQ_DLG_PROCESSED,
        REQ_DLG_NEXT,
        REQ_DLG_PREV,
        REQ_DLG_UP,
        REQ_DLG_DOWN,
        REQ_DLG_LEFT,
        REQ_DLG_RIGHT,
        REQ_DLG_EXIT,
        DLG_HIGH = REQ_DLG_EXIT
    };

    /**
        DialogBox Constructor
        @param parent:
            the parent of this window
        @param id
            a user defined const int identifying this window
        @param title
            The title for this window
        @param lines:
            height of the window
        @param cols
            width of the window
        @param y
            line where we are placed, absolute coord.
        @param x
            column where we are placed, absolute coord.
        @param d_style
            type of window (okCancel,yesNoCancel, etc.)
        @param c_style
            style indications for enabling/disabling control's capabilities
    */
    DialogBox(Control *parent,int id, const string &title
                        ,int lines, int cols,int y=0, int x=0
                        ,int d_style=0,int c_style=0);

    /**
        DialogBox Constructor
        @param id
            a user defined const int identifying this window
        @param title
            The title for this window
        @param lines:
            height of the window
        @param cols
            width of the window
        @param y
            line where we are placed, absolute coord.
        @param x
            column where we are placed, absolute coord.
        @param d_style
            type of window (okCancel,yesNoCancel, etc.)
        @param c_style
            style indications for enabling/disabling control's capabilities
    */
    DialogBox(int id, const string &title
                        ,int lines, int cols,int y=0, int x=0
                        ,int d_style=0,int c_style=0);
    ~DialogBox();
    
    ///Add a control at the end of the list of this window
    void add_child(Control *new_child){ children.push_back(new_child);  }   
    
    ///Add a control at the given pos on the list of this window
    void add_child(int pos,Control *new_child);
    
    ///Add a control after the given control on the list of this window
    void add_child(Control *after,Control *new_child);
    
    string get_text() const {return _title;}
    void set_text(const string &v){
        _title = v;
        show_text(v,'c');
    }

    ///The modal loop of the dialog box
    virtual int do_modal();
    
    ///Hide this window and the contained controls
    void hide();
    
    ///Show this window and the contained controls
    void show();
    
    ///The standard screen  
    static NCursesPanel dlg_stdscr;
    
protected:
    ///Allow children to touch our stuff
    friend Control;
    /// The controls we have
    ListOfChildren children;
    
    /// where is te focus now
    int curr_child;
    
    string _title;
    
    int dlg_style;
    
    ///Modal loop condition
    bool bContinueModal;
    
    ///So we can ask the user if she want to save
    bool changed;
    
    PushButton *pBtnYes;
    PushButton *pBtnNo;
    PushButton *pBtnCancel;
    PushButton *pBtnOk;

    ///this is the result of the interaction
    int user_request;
    
    /// A simple helper
    void show_text(const string &t,char where);

    /// When user press TAB, give me the next child
    void next_control();

    void prev_control();
    
    void find_clicked();

protected:
    DECLARE_BINDINGS();

    ///called at the beggining of the modal loop
    virtual void on_dlg_init(){ 
        if(has_frame()){    
            frame();
        }
        if(has_show_title()){
            show_text(_title,'c');
        }
    }
        
    ///called at the end of the modal loop
    virtual void on_dlg_term(){ }
    
    ///called if user presses one of the 'exits' 
    virtual bool can_close();
    
    ///called when the user enters a control
    virtual void on_ctrl_init(Control &ctrl){
        ctrl.activate();
    }
    
    ///called when the user leaves the control
    virtual bool on_ctrl_term(Control &ctrl){
        ctrl.deactivate();
        return true;
    }
    
    /// Kind of catch-all for derived windows
    virtual void on_cmd(int dlg_req) {
    }
    
    ///called on construction of dialog
    virtual void create_buttons();
    
    ///The next four are used by create_buttons
    void add_ok();
    void add_ok_cancel();
    void add_yes_no(); 
    void add_yes_no_cancel(); 

    ///activate child at position child_idx
    virtual void set_focus_to(int child_idx);

    ///activate p_child
    virtual void set_focus_to(Control *p_child);

    int driver (int key);
    
    ///Vanilla implementation of exits
    virtual void on_dlg_ok()    {end_dialog(IDOK);} 
    virtual void on_dlg_yes()   {end_dialog(IDYES);}
    virtual void on_dlg_no()    {end_dialog(IDNO);}
    virtual void on_dlg_cancel(){
        if(can_close())
            end_dialog(IDCANCEL);
    }

    ///Break the modal loop
    ///and give the user a chance to cleanup/serialize/whatever
    int end_dialog(int request){
        user_request = request;
        bContinueModal=false;
        on_dlg_term();
    }

    /// Put the label text at the left (0) 
    /// in the specified row.
    virtual void lefttext(int row,const char* label);

    /// Put the label text to the right (ending at maxx())
    /// in the specified row.
    virtual void righttext(int row,const char* label);
    
    ///Helpers for auto-ordering the default buttons
    static int my_w;        ///useable width
    static int btn_w;       ///each button width
    static int btns;            ///number of buttons
    static int used_width;  ///total buttons width          
    static int spc;         ///space between buttons
    static int X_POS(int pos);

    static string lblOk;
    static string lblCancel;
    static string lblYes;   
    static string lblNo;
    static string lblApply;
    static string titDataChgd;
    static string msgAskToSave;
};


/************************************************************************
*   \class MessageBox                                                   *
*   You already know what is this... ;-)                                *
************************************************************************/
class MessageBox: public DialogBox 
{
public:
    MessageBox(const string &title,const string &message,int style=info);
protected:

    ///Prompt the user
    string msg;

    ///We redefine here so we get called on construction
    void on_dlg_init(); 
    void show_message();
};


/************************************************************************
*   \class OkCancelBox                                                  *
*   You already know what is this... ;-)                                *
************************************************************************/
class OkCancelBox: public MessageBox 
{
public:
    OkCancelBox(const string &title,const string &message,int style=info)
        :MessageBox(title,message,style|okCancel)
        {};
};


/************************************************************************
*   \class YesNoBox                                                 *
*   You already know what is this... ;-)                                *
************************************************************************/
class YesNoBox: public MessageBox 
{
public:
    YesNoBox(const string &title,const string &message,int style=info)
        :MessageBox(title,message,style|yesNo)
        {};
};


/************************************************************************
*   \class YesNoBox                                                 *
*   You already know what is this... ;-)                                *
************************************************************************/
class YesNoCancelBox: public MessageBox 
{
public:
    YesNoCancelBox(const string &title,const string &message,int style=info)
        :MessageBox(title,message,style|yesNoCancel)
        {};
};


/************************************************************************
*   \class PropertyPage                                                 *
*   A dialog box with it's title in a tab and stacked with others...    *
************************************************************************/
class PropertyDialog;
class PropertyPage: public DialogBox 
{
public:
    /**
        DialogBox Constructor
        @param parent
            the property dialog that owns us
        @param id
            a user defined const int identifying this window
        @param title
            The title for this window
        @param lines:
            height of the window
        @param cols
            width of the window
        @param y
            line where we are placed, absolute coord.
        @param x
            column where we are placed, absolute coord.
    */
    PropertyPage(PropertyDialog *parent,int id, const string &title
                        ,int lines, int cols,int y=0, int x=0)
                        :DialogBox((Control *)parent,id,title,lines,cols,y,x,0,framed|notify)
                        ,pDialog(parent)
                        {
                            do_initial_update();
                        };
    ~PropertyPage(){};
    
    ///Since we have the dialogs stacked and they are not modal,
    ///we need to do this manually
    int refresh()
    {
        for( int idx=0;idx < children.size(); idx++){
            if(idx!=curr_child)
                children[idx]->deactivate();
        }
        if(curr_child>-1 && curr_child < children.size())
            children[curr_child]->activate();
    }


    
protected:
    friend class Tab;
    friend class PropertyDialog;
    
    ///Non-modal equivalent of do_modal()
    int process_key(int key);
    
    int driver(int key){ return DialogBox::driver(key);}
    
    ///Non-modal wrapper for calling on_dlg_init from the constructor
    void do_initial_update(){
        enable_notify(false);
        on_dlg_init();
        enable_notify();
    }
    
    ///We redefine here so we get called on construction
    void on_dlg_init(){
    }; 
    
    void on_cmd(int dlg_req);

    ///Called when some control change
    virtual void on_page_change(){
        if(notify_enabled())
            process_message(pParent,PAGE_MODIFIED,get_ctrl_id(),this);
    }
    
    ///called by parent when user pushes the "Apply" button
    virtual void on_apply(){
        if(notify_enabled())
            process_message(pParent,0,(int)CANCEL_TO_CLOSE,0);
    };
    
    void create_buttons(){
        /**Do nothing, otherwise OK shows up...*/   
    }
    
    PropertyDialog *pDialog;
};


/************************************************************************
*   \class Tab                                                          *
*   A specialized button used to show the                               *
*   title of the PropertyPage                                           *
************************************************************************/
class Tab:public Button
{
public:

    /**
        Tab Constructor
        See parameters for class Control
    */
    Tab( Control *parent,int id, const string &title
                    ,int lines,int cols,int y, int x
                    ,int style=tabstop|notify|framed);

    /**
        Tab Constructor
        See parameters for class Control
    */
    Tab( Control *parent,int id, const string &title
                    ,int y, int x);

    ~Tab();
    
    int driver(int key);
                    
    int action(){ return TRUE;}
    
    void activate();
    void deactivate();
    
    ///call panel's show and set our state accordingly
    void show(){
//      send_to_log("show en Tab")<< pPage->get_text()<< endl;
        if(!is_visible()) 
            Control::show();
        pPage->show();
    }
    
    ///call panel's hide and set our state accordingly
    void hide(){
//      send_to_log("hide en Tab")<< pPage->get_text()<< endl;
        if(is_visible())
            Control::hide();
        pPage->hide();
    }
    
    ///Get the page associated with this tab
    PropertyPage *get_page() { return pPage;}
    ///Set the page associated with this tab
    void set_page(PropertyPage *page){pPage = page;}

    void set_text(const string &txt);
    
protected:
    ///The stacked dialog we manage
    PropertyPage *pPage;
};


/************************************************************************
*   \class PropertyDialog                                               *
*   A container for stacked dialogs                                     *
*   No frames, no title, with three default buttons (Ok,Apply,Cancel)   *
************************************************************************/
typedef vector <Tab *> ListOfPages;

class PropertyDialog: public DialogBox 
{
public:
    /**
        PropertyDialog Constructor
        @param id
            a user defined const int identifying this window
        @param lines:
            height of the window
        @param cols
            width of the window
        @param y
            line where we are placed, absolute coord.
        @param x
            column where we are placed, absolute coord.
    */
    PropertyDialog(int id, const string &title,int lines, int cols,int y=0, int x=0);
    ~PropertyDialog();
    
    ///Insert a new page on this stack
    void add_page(PropertyPage *new_page);
    
    ///Show the selected page
    void set_selected_page(int page);
    int get_selected_page(){ return curr_page;}
    
    ///Check if page number is valid
    bool valid_page_number(int page){return (page < pages.size() && page > -1);}
    
    PropertyPage * get_page(int page);
    
protected:
    PushButton *&pBtnApply;
    int curr_page;
    ListOfPages pages;
    void on_dlg_init();
    void reorder_pages();
    void create_buttons();
    int get_next_tab_pos();
    
    virtual void on_page_modified(int page){ 
        changed = true;
        pBtnOk->enable();
        pBtnNo->enable();
    }
    
    virtual void on_page_selected(int page){
        if(valid_page_number(page))
            curr_page = page;
    }
            
    virtual void on_apply(){
        if(valid_page_number(curr_page))
            pages[curr_page]->get_page()->on_apply();
    }
    
    void on_focus_to_buttons(){ 
        if(pBtnOk->is_enabled())set_focus_to(pBtnOk);
        else set_focus_to(pBtnCancel);
    }
    
    void on_return_to_page(){   
        if(valid_page_number(curr_page))
            set_focus_to(pages[curr_page]);
    }
    
    ///Once the user Apply, we can't cancel...
    virtual void cancel_to_close();
    
    DECLARE_BINDINGS();

};


/************************************************************************
*   \class StatusBar                                                    *
*   A status bar at the bottom of the application console               *
************************************************************************/
class StatusBar : public Label
{
public:

    StatusBar(int lines,int cols,int y, int x,const string &text="Status bar")
        : Label(1000,text,lines, cols, y, x, visible)
    {
    }
};


/************************************************************************
*   \class Application                                                  *
*   Derivation of the NCursesApplication class                          *
*   where we added a status bar                                         *
************************************************************************/
class Application: public NCursesApplication
{
protected:

    Application(bool wantColors = FALSE)
        :   NCursesApplication(wantColors),pStatusBar(0)
    {
    }
    
    virtual void activateMenuBar()=0;
    virtual void activateStatusBar();
    string app_title;
  
public:

    static Application *get_application(){
        Application *pApp = dynamic_cast<Application *>
                                        (NCursesApplication::getApplication());
        return pApp;
    }
    
    virtual ~Application(){
        delete pStatusBar;
    };

    StatusBar *getStatusBar() {return pStatusBar;}
    string get_title()const {return app_title;}
    ///Tell us what is the name of the parameters file  
    void set_param_file_name(const string &file_name){param_file_name = file_name;}
    
    /// Retrive the parameters file name
    string get_param_file_name()const {return param_file_name;}
    
    /// Find a string parameter (a la MS's .ini files)
    string get_param(const string &section_name
                        ,const string &key_name
                        ,const string &val);

    /// Find a numeric parameter (a la MS's .ini files)
    long get_param(const string &section_name
                        ,const string &key_name
                        ,long val);

    /// Save a string parameter (a la MS's .ini files)
    string save_param(const string &section_name
                        ,const string &key_name
                        ,const string &val){};

    /// Save a numeric parameter (a la MS's .ini files)
    long save_param(const string &section_name
                        ,const string &key_name
                        ,long val){};

protected:

    StatusBar *pStatusBar;
    string param_file_name;
    
    ///Helper to check if a section given in ge/save_param functs. exists
    bool section_exists(ifstream &param_file,const string &section_name);
    
    ///Helper to check if a key given in ge/save_param functs. exists
    long find_key(ifstream &param_file,const string &section_name
                            ,const string &key_name,string &value);

};


/// Delegation function to get the params from almost anywhere in NDK++
inline long Control::get_param(const string &section_name
                                    ,const string &key_name
                                    ,long val)
{
    return  Application::get_application()->get_param(section_name,key_name,val);
}


/// Delegation function to get the params from almost anywhere in NDK++
inline string Control::get_param(const string &section_name
                                    ,const string &key_name
                                    ,const string &val)
{
    return  Application::get_application()->get_param(section_name,key_name,val);
}


/// Delegation function to set the params from almost anywhere in NDK++
inline long Control::save_param(const string &section_name
                                    ,const string &key_name
                                    ,long val)
{
    return  Application::get_application()->save_param(section_name,key_name,val);
}


/// Delegation function to set the params from almost anywhere in NDK++
inline string Control::save_param(const string &section_name
                                    ,const string &key_name
                                    ,const string &val)
{
    return  Application::get_application()->save_param(section_name,key_name,val);
}

/************************************************************************
*   template \class Exception                                       *
*   We use it from anywhere in NDK++ to throw using the                 *
*   current context (usually the window containing the offending code)  *
************************************************************************/
template<class T> class Exception : public NCursesException
{
public:
  const T* pElem;

  Exception (const char *msg, int err) : 
    NCursesException (msg, err),
    pElem (0)
    {};

  Exception (const T* elem,
             const string &msg,
             int err=-1) : 
    NCursesException (msg.c_str(), err),
    pElem (elem)
    {};

  Exception (int err) : 
    NCursesException ("NDK++ library exception", err),
    pElem (0)
    {};

  Exception (const T* elem,
             int err) : 
    NCursesException ("NDK++ library exception", err),
    pElem (elem)
    {};

  virtual const char *classname() const {
    return typeid(pElem).name();
  }

};



} //namespace NDK_XX




#endif //!defined(__NDK_NCURSES__)

---