Changes

The CIO Framework - OOP344 20131

32,340 bytes added, 23:04, 17 March 2013

no edit summary

#define C_BORDER_CHARS "/-\\|/-\\|"

enum CDirection {centre, left, right, up, down};

// added after 0.3:

enum MessageStatus{ClearMessage,SetMessage};

#ifdef NO_HELPFUNC

# undef NO_HELPFUNC

#endif

#define NO_HELPFUNC ((void(*)(MessageStatus, CDialog&))(0))

#ifdef NO_VALDFUNC

# undef NO_VALDFUNC

#endif

#define NO_VALDFUNC ((bool(*)(const char*, CDialog&))(0))

#define C_MAX_LINE_CHARS (1024u)

#define C_INITIAL_NUM_OF_LINES (100u)

}

#endif

====CButton Blog Posts====

==CValEdit==

This class works exactly like CLineEdit and improves it by adding two features; Validation and Help. CValEdit is capable of validating the user input on exit and also provide help when CValEdit::edit() is active by invoking a '''"help"''' method before and after editing. If these two functions, (Validation and Help) are not provided, then CValEdit literally works like CLineEdit.

#include "clineedit.h"

namespace cio{

class CValEdit: public CLineEdit{

void (*_help)(MessageStatus, CDialog&);

bool (*_validate)(const char*, CDialog&);

public:

CValEdit(char* Str, int Row, int Col, int Width,

int Maxdatalen, bool* Insertmode,

bool (*Validate)(const char* , CDialog&) = NO_VALDFUNC,

void (*Help)(MessageStatus, CDialog&) = NO_HELPFUNC,

bool Bordered = false,

const char* Border=C_BORDER_CHARS);

CValEdit(int Row, int Col, int Width,

int Maxdatalen, bool* Insertmode,

bool (*Validate)(const char* , CDialog&) = NO_VALDFUNC,

void (*Help)(MessageStatus, CDialog&) = NO_HELPFUNC,

bool Bordered = false,

const char* Border=C_BORDER_CHARS);

int edit();

};

}

</syntaxhighlight></big>

===Attributes===

void (*_help)(MessageStatus, CDialog&);

bool (*_validate)(const char*, CDialog&);

</syntaxhighlight></big>

*_help, holds the address of the help logic (function) or NULL if there is no help function is assigned

*_validate, holds the address of the validation logic (function) or NULL if there is no validation function is assgned

===Constructors===

CValEdit(char* Str, int Row, int Col, int Width,

int Maxdatalen, bool* Insertmode,

bool (*Validate)(const char* , CDialog&) = NO_VALDFUNC,

void (*Help)(MessageStatus, CDialog&) = NO_HELPFUNC,

bool Bordered = false,

const char* Border=C_BORDER_CHARS);

CValEdit(int Row, int Col, int Width,

int Maxdatalen, bool* Insertmode,

bool (*Validate)(const char* , CDialog&) = NO_VALDFUNC,

void (*Help)(MessageStatus, CDialog&) = NO_HELPFUNC,

bool Bordered = false,

const char* Border=C_BORDER_CHARS);

</syntaxhighlight></big>

These constructors pass all their arguments to corresponding arguments of CLineEdit constructor and then set '''_help''' and '''_validate''' attributes to the corresponding incoming arguments

===Method===

int edit();

</syntaxhighlight></big>

If the container() is NULL then this function works exactly like LineEdit::edit().

If the container() is not NULL:

#If _help function exist, it calls the function passing MessageStatus::SetMessage and container()'s reference as arguments.

#Calls CLineEdit's edit()

#If validation function exists, and the terminating key of CLineEdit's edit() is a navigation key(see below)

#:It will call the validation function on the Field's _data, if the data is valid, it goes to next step, otherwise it will repeat calling CLineEdit's edit().

#After validation is done, if _help function exists, it will recall the help function using MessageStatus::ClearMessage and contianer()'s reference as arguments.

#It will return the terminating key

''Navigation keys are Up key, Down key, Tab key or Enter key.''

''MessageStatus is enumerated in '''cuigh.h'''''

===CValedit Student Resources===

====CValEdit Help/Questions Blogs====

====CValedit Blog Posts====

==CCheckMark==

Creates a single CheckMark on the screen and allows the user to:

# Toggle it, if it is set to be a CheckMark for a Check List.

# Only check it when its unchecked, if it is set to be a CheckMark for a Radio Button List.

#include "cfield.h"

#include "clabel.h"

namespace cio{

class CCheckMark : public CField{

bool _flag;

bool _radio;

char _format[4];

CLabel _Label;

public:

CCheckMark(bool Checked,const char* Format, const char* Text, int Row, int Col, int Width, bool IsRadio = false);

CCheckMark(const CCheckMark& C);

void draw(int fn = C_NO_FRAME) ;

int edit();

bool editable()const;

void set(const void* flag);

bool checked()const;

void checked(bool val);

bool radio();

void radio(bool isRadio);

operator bool();

operator char*();

bool operator=(bool flag);

};

}

</syntaxhighlight></big>

===Attributes===

int _flag;

bool _radio;

char _format[4];

CLabel _Label;

</syntaxhighlight></big>

*'''_flag''' holds the status of the Checkbox (0: unchecked or 1: checked ) and is pointed by _data pointer .

*'''_radio''' dictates the behavior of the Checkbox as a radio-button, or a check-mark.

*'''_format''' holds the characters, the Checkbox is drawn with (i.e. "[X]", "(O)", "<*>", etc...).

*'''_Label''' holds the Label attached to the this Checkbox

===Constructor / Destructor===

CCheckMark(bool Checked,const char* Format, const char* Text, int Row, int Col, int Width, bool IsRadio = false);

</syntaxhighlight></big>

*Passes the ''Row, Col, Width and "1"'' to ''row, col, width and height'' arguments of CField and directly initializes _Label with ''Text, 0, 4, and (Width-4)'' for ''Str, Row, Col and Len'', arguments of CLabel's Constructor.

*Sets the frame of _Label to its owner (Checkmark i.e. 'this');

*Sets _flag to Checked

*Sets _radio to IsRadio

*Copies Format to _format

*Sets _data to the address of _flag

CCheckMark(const CCheckMark& C);

</syntaxhighlight></big>

*Passes incoming CCheckMark reference ("C") to CField's copy constructor, and directly initializes the _Label with the _Label of C

*Sets all the attributes of this object to the attributes of incoming CCheckMark reference ("C")

*Sets _data to the address of _flag

===Methods===

void draw(int fn = C_NO_FRAME) ;

</syntaxhighlight></big>

Using Console methods:

#displays the _format string at absRow() and absCol()

#if _flag is false, it will overwrite the second character printed above, with a space (removes the check mark on console)

#draw()s the _Label

#sets the position of the cursor at the checkmark (second character of printed _format)

int edit();

</syntaxhighlight></big>

#draw()s the checkmark

#gets a key

#: the key must be either SPACE or any non-printable character (all printable character are ignored)

#if the entered key is space

##if _radio is true, it will set the _flag to true

##if _radio is false, it will flip the value of _flag.

##draw()s the checkmark again

bool editable()const;

</syntaxhighlight></big>

*Always return true;

void set(const void* flag);

</syntaxhighlight></big>

*Casts the incoming flag pointer to an (bool*) and sets the content of '''_flag''' to where '''flag''' is pointing to.

bool checked()const;

void checked(bool val);

</syntaxhighlight></big>

*These methods set and get _flag.

bool radio(); // addition for R0.6

void radio(bool isRadio); // addition for R0.6

</syntaxhighlight></big>

* These to methods, get and set the '''_radio''' attribute.

operator bool(); // addtion for R0.6

</syntaxhighlight></big>

* Overload the '''bool''' cast to return the value of '''_flag'''

operator char*(); // addtion for R0.6

</syntaxhighlight></big>

* Overload the '''char*''' cast to return the value of '''_Label.data()'''

bool operator=(bool flag);; // addtion for R0.6

</syntaxhighlight></big>

* Overload the operator= and set the _flag to flag

===CCheckMark Student Resources===

====CCheckMark Help/Questions Blogs====

====CCheckMark Blog Posts====

==CMenuItem==

CMenuItem provides a Label that can be marked as selected by pressing the space bar.

#include "clabel.h"

#include "cfield.h"

namespace cio{

class CMenuItem:public CField{

bool _selected;

char _format[3];

CLabel Label;

public:

CMenuItem(bool Selected,const char* Format, const char* Text, int Row, int Col, int Width);

CMenuItem(const CMenuItem &CM);

void draw(int fn = C_NO_FRAME) ;

int edit();

bool editable()const;

void set(const void* Selected);

bool selected()const;

void selected(bool val);

const char* Text();

};

}

</syntaxhighlight></big>

===Attributes===

bool _selected;

</syntaxhighlight></big>

Holds the status of the MenuItem, being selected or not;

char _format[3];

</syntaxhighlight></big>

Holds the surrounding characters with which a selected MenuItem is shown:

If _format holds "[]", then a selected MenuItem will be like [MenuText]

CLabel Label;

</syntaxhighlight></big>

Hold the Text of the MenuItem.

===Constructors / Destructor===

CMenuItem(bool Selected,const char* Format, const char* Text, int Row, int Col, int Width);

</syntaxhighlight></big>

#Initializes the CField with Row, Col, Width and 1 for Height

#Initializes the Label with (Text, 0, 1 and Width-2) for (Str, Row, Col, and Len)

#Sets the attributes to corresponding arguments

#Sets CFields::_data to the address of _format

#Sets the Label's frame to this object.

CMenuItem(const CMenuItem &CM);

</syntaxhighlight></big>

#Passes CM to CField and Initializes the Label with CM

#Sets the _selected to _selected of CM

#Sets CFields::_data to the address of _format

#Sets the Label's frame to this object.

===Methods===

void draw(int fn = C_NO_FRAME) ;

</syntaxhighlight></big>

#Draws the Label with fn

#If _selected is true, it surrounds the Label Text the _format[0] and _format[1]

#If _selected if false, it surrounds the Label with SPACEs (overwrites _format[0] and _format[1])

#Positions the cursor at the first character of the Label

int edit();

</syntaxhighlight></big>

#draw()s the MenuItem

#gets a key

#: the key must be either SPACE or any non-printable character (all printable character are ignored)

#if the entered key is space

##it will set the _selected to true

##draw()s the MenuItem again

#returns the key

bool editable()const;

</syntaxhighlight></big>

Returns true.

void set(const void* Selected);

</syntaxhighlight></big>

Sets _selected to where Selected is pointing to

bool selected()const;

</syntaxhighlight></big>

Returns Selected

void selected(bool val);

</syntaxhighlight></big>

Sets _selected to val

const char* Text();

</syntaxhighlight></big>

Returns the text of Label

===CMenuItem Student Resources===

====CMenuItem Help/Questions Blogs====

====CMenuItem Blog Posts====

==CText==

CText is a CField to edit a multiline text.

To do this, it will use the [[#The_Text_Helper_Class|Text class]] to convert a character string containing a text into a (simulated) two dimensional array.

#pragma once

#include "cfield.h"

#include "text.h"

using namespace cio;

class CText:public CField{

Text _T;

bool _displayOnly;

int _curpos;

bool* _insertmode;

int _offset;

int _lcurpos;

int _loffset;

public:

CText(int Row, int Col, int Width, int Height, bool* Insertmode,

bool displayOnly = false, const char* Border=C_BORDER_CHARS);

CText(const char* Str, int Row, int Col, int Width, int Height,

bool* Insertmode, bool displayOnly = false,

const char* Border=C_BORDER_CHARS);

void draw(int fn = C_FULL_FRAME);

void set(const void *Str);

void *data()const;

int edit();

bool editable()const;

bool displayOnly();

void displayOnly(bool val);

};

</syntaxhighlight></big>

===Attributes===

Text _T;

</syntaxhighlight></big>

An instance of the [[#The_Text_Helper_Class|Text class]]

bool _displayOnly;

</syntaxhighlight></big>

If it is set to true, then the Text can only be viewed but not edited; All scrolling, page UP, DOWN, etc... is enabled but any attempt to change the text, is ignored quietly. This attribute is passed to ReadOnly argument of Console::edit(......).

int _curpos;

bool* _insertmode;

int _offset;

</syntaxhighlight></big>

Values used by Console::edit(......)

int _lcurpos;

int _loffset;

</syntaxhighlight></big>

Vertical cursor position in text.

Vertical offset of the text relative to the frame of CText. This value indicates, how many line are hidden above the frame when text is scrolled down.

===Constructors/Destructor===

CText(int Row, int Col, int Width, int Height, bool* Insertmode,

bool displayOnly = false, const char* Border=C_BORDER_CHARS);

</syntaxhighlight></big>

Initialized the CField with the corresponding incoming arguments and then sets all the attributes to their corresponding arguments.

CText(const char* Str, int Row, int Col, int Width, int Height,

bool* Insertmode, bool displayOnly = false,

const char* Border=C_BORDER_CHARS);

</syntaxhighlight></big>

Works exactly like the previous constructor but it also '''set()'''s the class to '''Str'''.

===Methods===

'''Under Construction'''

void draw(int fn = C_FULL_FRAME);

</syntaxhighlight></big>

First it will draw the CField using the fn arguement.

Then it will use console.display to display all the Lines of _T that are positioned inside the frame of the CText. (i.e. from _loffset to _loffset + Height() - 2).

Two Important things to note:

# you should note that '''Lines''' are '''console.display()'''ed from _offset character. (i.e. &_T[theLineNumber][_offset]).

# Also you should '''console.display()''' the Lines only if the length of the line is more than the _offset(i.e. _T[theLineNumver].strlen() > _offset)

void set(const void *Str);

</syntaxhighlight></big>

Sets the '''_T''' attribute to the incoming string.

void *data()const;

</syntaxhighlight></big>

Exports the string out of _T and returns its address after casting it to '''void*'''.

int edit();

</syntaxhighlight></big>

# Create local variables to hold the following attributes in case ESCAPE is hit to undo:

## _T

## _curpos

## _offset

## _lcurpos

## _loffset

# Create the usual '''while(!done)''' structure for interfacing with user

# '''draw()''' the text

# '''console.edit()''' the Line at where vertical cursor is after _loffset.

## use absRow() and _lcurpos to calculate the row on which the editing should happen

## use absCol() to calculate the column on which editing to happen.

## use width() to calculate the fieldLen for '''console.edit()'''

## use the '''size()''' of the current '''Line''' in '''_T''' to determine the maximum data length of the string to '''console.edit()'''

## the isTextEditor is always true

## the ReadOnly depends on the value of '''_displayOnly'''

bool editable()const;

</syntaxhighlight></big>

Always return true;

bool displayOnly();

void displayOnly(bool val);

</syntaxhighlight></big>

These methods Get and Set the '''_displayOnly''' attribute.

===The Text Helper Class===

[https://github.com/Seneca-OOP344/OOP344-20123/tree/master/TextClass Text class]

===CText Student Resources===

====CText Help/Questions Blogs====

====CText Blog Posts====

==CCheckList==

#pragma once

#include "cfield.h"

#include "ccheckmark.h"

namespace cio{

class CCheckList : public CField{

CCheckMark* _checkmarks[32];

bool _radio;

char _format[4];

unsigned int _cnt;

unsigned int _flags;

unsigned int _cur;

public:

CCheckList(const char* Format, int Row, int Col, int Width,bool radio, bool Bordered = true,const char* Border=C_BORDER_CHARS);

~CCheckList(void);

CCheckList& add(const char* Text, bool selected = false);

CCheckList& operator<<(const char* Text);

void draw(int fn = C_FULL_FRAME);

int edit();

void* data();

void set(const void* data);

CCheckMark& operator[](unsigned int index);

bool editable()const;

bool radio()const;

void radio(bool val);

unsigned int flags()const;

void flags(unsigned int theFlags);

int selectedIndex()const;

void selectedIndex(int index);

unsigned int length();

};

}

</syntaxhighlight></big>

===Attributes===

CCheckMark* _checkmarks[32];

</syntaxhighlight></big>

An array of 32 CCheckmark pointers that will point to _cnt dynamically allocated CCheckMarks.

bool _radio;

</syntaxhighlight></big>

Holds the behaviour of the CCheckList to be like a Radio Button List or Check Mark List

char _format[4];

</syntaxhighlight></big>

Holds the format with which a check mark is displayed (i.e. "[X]" or "(o)" etc...)

unsigned int _cnt;

</syntaxhighlight></big>

Holds the number of CCheckMarks currently in CCheckList

unsigned int _flags;

</syntaxhighlight></big>

Always holds the bit pattern corresponding to the status of the CCheckMarks in the List. Note that bit 0 (right most) will correspond to the first CCheckMark.

unsigned int _cur;

</syntaxhighlight></big>

Holds the index of the CCheckMark in the "_checkmarks" array which is currently being edited. (focused)

===Constructors/Destructor===

CCheckList(const char* Format, int Row, int Col, int Width,bool radio, bool Bordered = true,const char* Border=C_BORDER_CHARS);

</syntaxhighlight></big>

Passes corresponding values to the Base class (CField) then

#sets the _data attribute to the address of _flags

#copies '''Format''' and '''radio''' into '''_format''' and '''_radio''' respectively

#sets '''_cnt, _cur''' and '''_flags''' to zero

~CCheckList(void);

</syntaxhighlight></big>

Goes through '''_checkmarks''' up to '''_cnt''' and if deletes them one by one.

===Methods===

CCheckList& add(const char* Text, bool selected = false);

</syntaxhighlight></big>

* Only adds a new CCheckMark if '''_cnt''' does not exceed the maximum amount of '''_checkmarks''' (32)

* Creates a new CCheckMark with the row being '''_cnt'''+1, the height being 1 and the length being the length of '''Text'''+4

* Sets the newly created CCheckMarks' frame to '''this'''

* Automatically expands the width of the CCheckList if the width of the newly created CCheckMark is bigger than the current width of the CCheckList

* Sets the height of the CCheckList to '''_cnt'''+3

* Updates the bit pattern of '''_flags'''

* Increments '''_cnt'''

CCheckList& operator<<(const char* Text);

</syntaxhighlight></big>

returns add(Text).

void draw(int fn = C_FULL_FRAME);

</syntaxhighlight></big>

Draws the frame and then draws all the '''_checkmarks''', making sure the cursor is standing under the first checked checkmark.

int edit();

</syntaxhighlight></big>

*Draws the '''CCheckList''' then starts editing the '''_checkmarks''' form '''_cur''' and according to the return key of CCheckMark::edit():

**If Down or Right key is hit it goes to the next '''_checkmark''', if '''_cur''' is the last one, then it exits the edit, returning the last key entered.

**UP and Left key works in opposite direction of Down and Right, if '''_cur''' is already zero, then it exits the edit, returning the last key entered.

**If Space is hit, then if '''_radio''' is true, it will uncheck all the '''_checkmarks''' other than the '''_cur'''rent one.

void* data();

</syntaxhighlight></big>

returns the bit pattern held in _flags.

''make sure _flags are updated to the status of the '''_checkmarks'''''

void set(const void* data);

</syntaxhighlight></big>

sets the '''_flags''' and updates the '''_checkmarks''' to the bitpattern of '''_flags'''

CCheckMark& operator[](unsigned int index);

</syntaxhighlight></big>

returns the CCheckMark corresponding the '''index''' value.

bool editable()const;

</syntaxhighlight></big>

always returns true;

bool radio()const;

</syntaxhighlight></big>

returns '''_radio'''

void radio(bool val);

</syntaxhighlight></big>

sets the _radio and updates all _checkMarks radio value.

unsigned int flags()const;

</syntaxhighlight></big>

returns the '''_flags''' attribute

void flags(unsigned int theFlags);

</syntaxhighlight></big>

sets the '''_flags''' attribute

int selectedIndex()const;

</syntaxhighlight></big>

returns the index of the first CCheckMark that is selected, and -1 if nothing is selected.

void selectedIndex(int index);

</syntaxhighlight></big>

sets the selectedindex. (only un-selects the rest if object is in radio mode)

if index is less than zero, then it will un-selects all

unsigned int length();

</syntaxhighlight></big>

returns '''_cnt'''

===CCheckList Student Resources===

====CCheckList Help/Questions Blogs====

====CCheckList Blog Posts====

==CMenu and MNode (optional)==

CMenu is a linked list of MNodes. Providing menu selection for the user in two formats; Drop Down List, or a simple menu.

#ifndef __CIO__CMENU_H__

#define __CIO__CMENU_H__

#include "cuigh.h"

#include "cfield.h"

#include "cmenuitem.h"

#include "cbutton.h"

namespace cio{

class Cmenu;

class MNode{

CMenuItem* _item;

MNode* _next;

MNode* _prev;

unsigned int _index;

MNode(CMenuItem* item,unsigned int index, MNode* prev, MNode* next = ((MNode*)0));

~MNode(void);

friend class CMenu;

};

class CMenu : public CField{

MNode* _first;

MNode* _head;

MNode* _tail;

MNode* _cur;

char _format[3];

unsigned int _cnt;

int _selectedIndex;

bool _dropdown;

bool _dropped;

bool goNext();

bool goPrev();

CButton _Title;

public:

static const bool Select;

CMenu(const char* Title, const char* Format, int Row, int Col,

int Width, int Height,bool dropdown,

const char* Border=C_BORDER_CHARS);

CMenu& add(const char* Text, bool selected = false);

CMenu& operator<<(const char* Text);

CMenu& operator<<(bool select);

void draw(int fn = C_FULL_FRAME);

int edit();

void set(const void* data);

int selectedIndex() const;

int selectedIndex(int index);

const char* selectedText();

bool editable()const;

~CMenu(void);

};

extern const bool Select;

}

#endif

</syntaxhighlight></big>

===MNode===

MNode holds to main about an Item in the menut:

# The CMenuItem object

# The index of this Item

MNode is a fully private class and is only accessible by CMenu.

====Attributes====

CMenuItem* _item;

</syntaxhighlight></big>

Holds the address of a dynamically allocated CMenuItem

unsigned int _index;

</syntaxhighlight></big>

Holds the index (sequence -1) number of the '''CMenuItem''' in the '''CMenu'''.

MNode* _next;

MNode* _prev;

</syntaxhighlight></big>

Standard next and previous pointer for a linked list node.

====Constructor/Destructor====

MNode(CMenuItem* item,unsigned int index, MNode* prev, MNode* next = ((MNode*)0));

</syntaxhighlight></big>

Sets the corresponding attributes to the values of the arguments.

~MNode(void);

</syntaxhighlight></big>

deletes the '''_item'''

===CMenu===

CMenu is a linked list of MNodes and also contains a CButton for a Title (only used on if in '''_dropdown''' mode).

Assuming that a CMenu is created with a title as "FILE" and menu-items as "Save, Load, Print, Quit":

*When in '''_dropdown''' mode:

When drawing, Only the _Title(CButton) is drawn (and not the menu itself)

FILE

</pre></big>

When edited (in '''_dropdown''' mode) the CButton gets activated and if it is hit, then the Menu will be dropped down (drawn) under the CButton and user can browse through the options and select one of them. selecting the option in this case will close the menu and CButton gets activated again:

when active, CMenu looks like this:

[FILE]

</pre></big>

User hits enter: (since nothing is selected all menu items are unselected)

FILE

/-------\

| Save |

| Load |

| Print |

| Quit |

\-------/

</pre></big>

Now the cursor is standing under '''S'''ave.

User hits down arrow twice to select '''P'''rint and then hits Space:

[FILE]

</pre></big>

The Print is selected and The menu is closed and FILE is active again.

If the user hits Enter again:

FILE

/-------\

| Save |

| Load |

|[Print]|

| Quit |

\-------/

</pre></big>

We will see the Print is selected and the cursor in under P.

If user hits Enter instead of space, the selection wont change and whatever was selected before will remain the same:

[FILE]

</pre></big>

User hits navigation keys and moves out of the CMenu Field.

''Note that if '''left''' or '''right''' navigation keys are hit when the title is active, then they are translated to '''up''' or '''down''' respectively.

*When NOT in '''_dropdown''' mode:

*:The CButton will not be displayed at all, and when user starts to edit, he enters the menu browsing the items and if he gets to the end of the menu, the control goes to the next field in the dialog. If user goes up and passes the first them, then the control will go to the previous field in the dalog.

/-------\

| Save |

| Load |

|[Print]|

| Quit |

\-------/

</pre></big>

''Note that if the number of menu items are more than the space provided by the CField's frame, then the menu items should scroll up and down to accommodate the selection''

====Attributes====

MNode* _first;

</syntaxhighlight></big>

points to the first CMenuItem visible on the menu.

MNode* _head;

MNode* _tail;

MNode* _cur;

</syntaxhighlight></big>

standard Link list pointers

char _format[3];

</syntaxhighlight></big>

The two characters used to surround the selected menu item

unsigned int _cnt;

</syntaxhighlight></big>

The number of CMenuItems in CMenu

int _selectedIndex;

</syntaxhighlight></big>

The index of the selected CMenuItem (saved in MNode::index), if there is no selected menu, then this value is -1.

bool _dropdown;

</syntaxhighlight></big>

True if the Menu is a Drop Down Menu.

bool _dropped;

</syntaxhighlight></big>

Flag used to hold the status of a Drop Down Menu, (_dropped or not)

bool goNext();

bool goPrev();

</syntaxhighlight></big>

standard gonext() and goprev() in linked lists

CButton _Title;

</syntaxhighlight></big>

CButton holding the Title of this menu

====Constructor/Destructor====

CMenu(const char* Title, const char* Format, int Row, int Col,

int Width, int Height,bool dropdown,

const char* Border=C_BORDER_CHARS);

</syntaxhighlight></big>

#Initializes CField as follows:

#* Row: Passes Row, if this menu is not a dropdown, otherwise it will pass Row+1.

#* Col, Width, Height are passed directly

#* Data: a void null pointer is passed for data

#* Bordered: since CMenu is always bordered, true is passed here

#* Border is directly passed.

#Initializes _Title (the CButton) as follows:

#* Str, Title is passed here

#* Row, -1

#* Col, 1

#* Bordered, since the title of the dorpdown is alway NOT bordered, then false is passed here.

#Constructor Settings:

#* Link list attributes are set as standard linked list contructor

#* Format is copied into _format

#* _cnt is set to zero

#* _selectedIndex is set to -1

#* _data is set to address of _selectedIndex

#* _dropdown is set to dropdown

#* _dropped is set to false

#* _Title's frame is set to the CMenu object (this)

~CMenu();

</syntaxhighlight></big>

Standard Linked list destructor

====Methods====

CMenu& add(const char* Text, bool selected = false);

</syntaxhighlight></big>

Standard append for a linked list:

#creates an MNode with

#* a new CMenutItem with

#*:selected, _format, Text for first three arguments

#*:1, 1, and (width of the menu) -2, for Row col and width

#* the rest are what is needed for a standard append procedure for a linked list

#appends the new MNode to the end of the list

#if the new added CMenuItem is selected, it will update the selected index

'''''Note that if the added CMenuItem is the first CMenuItem in the list, then the _first pointer should be pointing to it'''''

CMenu& operator<<(const char* Text);

</syntaxhighlight></big>

returns add(Text)

CMenu& operator<<(bool select);

</syntaxhighlight></big>

if select is true, it will select the last CMenuItem added to the CMenu

void draw(int fn = C_FULL_FRAME);

</syntaxhighlight></big>

#if this is a '''_dropdown''', then it will draw the _Title

#: and then if '''_dropped''' is true, it will draw the CField and then draw the CMenuItems starting form what _first is pointing to, up to (CField's hieght -2) times.

#if this not a '''_dropdown''' then the _Title will never be drawn and the CMenuItems should be drawn as above.

int edit();

</syntaxhighlight></big>

Edits the menu the way it is explains in [[#CMenu|CMenu]] description.

If it is too confusing, this [[CMenu pseudo code - OOP344 20113|pseudo code]] may help.

void set(const void* data);

</syntaxhighlight></big>

Sets the selected index to the integer pointed by data;

int selectedIndex() const;

</syntaxhighlight></big>

returns the selected index or -1 if nothing is selected

int selectedIndex(int index);

</syntaxhighlight></big>

sets the selected index.

const char* selectedText();

</syntaxhighlight></big>

returns the text of the selected menu, if nothing is selected, and empty string is returned.

bool editable()const;

</syntaxhighlight></big>

returns true if '''_cnt''' is greater than zero

===CMenu Student Resources===

====CMenu Help/Questions Blogs====

====CMenu Blog Posts====

Fardad

Administrators

21

edits

Changes

The CIO Framework - OOP344 20131

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Navigation

get involved with CDOT

courses

course projects

links

Tools