3
edits
Changes
corrected spam and special character replacement
Start by creating mock-up classes (class declaration and definition with empty methods that only compiles and don't do anything).
Each class MUST have its own header file to hold its declaration and ""cpp" " file to hold its implementation. To make sure you do not do circular includes follow these simple guidelines:
* Add recompilation safeguards to all your header files.
* Always use forward declaration if possible instead of including a class header-file.
* Use includes only in files in which the actual header file code is used.
* '''Avoid ""just in case" " includes.'''
=Due Dates=
===Sat March 19 R3.0===
= General Internal Header file (cgh.h R0.1)=
The general header file holds the common setting and definition between all the Core Classes.
#ifndef ___CGH_H__
#define C_NO_FRAME 0
#define C_BORDER_CHARS ""/-\\|/-\\|""
enum CDirection {bio_centre, bio_left, bio_right, bio_up, bio_down};
extern ""C""{#include ""bio.h""
};
# 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))
#endif
=File Names=
*:For example '''CFrame''' class should have '''cframe.h''' and '''cframe.cpp''' files for its implementation.
=Hierarchy=
CFrame
|
|
|-------- CMenu
=Basic (BIO) Encapsulating Classes=
<syntaxhighlight lang="cpp">;
#pragma once
#include &quot;"cgh.h&quot;"
class CFrame{
</syntaxhighlight>
===Properties===
int _row, holds the relative coordinate of top row of this border with respect to its container.&lt;<br /&gt;>int _col, same as _row, but for _col. &lt;<br /&gt;>int _height, height of the entity. &lt;<br /&gt;>int _width, width of the entity. &lt;<br /&gt;>char _border[9], characters used to draw the border: &lt;<br /&gt;>
: _border[0], left top
: _border[1], top side
: _border[6], bottom left
: _border[7], left side
bool _visible; Indicates if the border surrounding the entity is to be drawn or not. &lt;<br /&gt;>CFrame* _frame; holds the container (another CFrame) which has opened this one (owner or container of the current CFrame). '''_frame''' will be NULL if this CFrame does not have a container, in which case, it will be full screen and no matter what the values of row, col, width and height are, CFrame will be '''Full Screen''' (no border will be drawn)&lt;<br /&gt;>
char* _covered; is a pointer to a character array that hold what was under this frame before being drawn. When the CFrame wants to hides itself, it simple copies the content of this array back on the screen on its own coordinates.
===Methods and Constructors===
====Private Methods====
void capture();
:if _covered pointer is not pointing to any allocated memory, it will call the bio_capture function to capture the area that is going to be covered by this frame and keeps its address in _covered.
====Public Methods====
CFrame(int Row=-1, int Col=-1, int Width=-1,int Height=-1,
bool Visible = false,
const char* Border=C_BORDER_CHARS,
CFrame* Frame = (CFrame*)0);
:Sets the corresponding attributes to the incoming values in the argument list and set _covered to null
virtual void draw(int fn=C_FULL_FRAME);
* First it will '''capture()''' the coordinates it is supposed to cover
* If frame is '''fullscreen()''' then it just clears the screen and exits. &lt;<br /&gt;>
Otherwise:&lt;<br /&gt;>
*If the _visible flag is true, it will draw a box at _row and _col, with size of _width and _height using the _border characters and fills it with spaces. Otherwise it will just draw a box using spaces at the same location and same size.
virtual void move(CDirection dir);
virtual void hide();
using bio_restore()it restores the characters behind the Frame back on screen. It will also free the memory pointed by _covered;
virtual ~CFrame();
It will make sure allocated memories are freed.
bool fullscreen()const;
void visible(bool val);
void width(int val);
int width()const;
These functions set and get the attributes of the CFrame.
===CFrame.cpp &amp; Test1Frame.cpp Bug Fix for R0.3.5===
Please visit my blog for the description and solution of the bug during the CFrame
* [http://www.ashkansotoudeh.com/blog/?p=159 CFrame.cpp &amp; Test1Frame.cpp Bug Fix for R0.3.5] by [[User:asotoude|Ashkan]]
==CField==
CField is an abstract base class that encapsulates the commonalities of all Input Outputs Console Fields which are placeable on a CDialog. All Fields could be Framed, therefore a CField is int
class CDialog;
class CField : public CFrame{
CDialog* container();
};
===Attributes===
void* _data;
Will hold the address of any type of data a CField can hold.
===Constructors and Methods===
CField(int Row = 0, int Col = 0,
int Width = 0, int Height =0,
bool Bordered = false,
const char* Border=C_BORDER_CHARS);
Passes the corresponding attributes to it's parents constructor and then sets the _data attribute to the incoming Data argument.
~CField();
Empty Destructor
virtual int edit() = 0;
virtual bool editable() const = 0;
virtual void set(const void* data) = 0;
Enforce the children to implement;
* an edit() method
* an editable() method that returns true if the class is to edit data and false if the class is to only display data.
* a set() method to set the _data attribute to the data the class is to work with.
virtual void* data();
Returns _data.
void container(CDialog* theContainer);
CDialog* container();
Sets and Gets the _frame attribute of CFrame by calling CFrame::frame() method. Make sure to cast The CDialog to CFrame when setting and cast CFrame to CDialog when getting
==CLabel==
A readonly Field that encapsulates bio_display() function. (i.e it is responsible to display a short character string on the display) CLable although, by inheritance is Frame, but it is never '''bordered'''.
class CLabel : public CField{
int _length;
int Len = 0);
CLabel(int Row, int Col, int Len);
CLabel(const CLabel&amp; L);
~CLabel();
void draw(int fn=C_NO_FRAME) ;
void set(const void* str);
};
===Attributes===
int _length;
Holds the Length of the label, this will be stored to be passed to bio_display function.
===Constructors / Destructor ===
CLabel(const char *Str, int Row, int Col,
int Len = 0);
passes the Row and Col to the CField constructor and then;
if len is zero, it will allocate enough memory to store the string pointed by Str and then copies the Str into it.
if len &gt; > 0, then it will allocate enough memory to store '''len''' chars in a string.
In any way, the allocated memory is pointed by '''_data'''
CLabel(int Row, int Col, int Len);
Works exactly like the previous constructor, but len in this case can not be zero. (no validation required) and the string pointed by _data will be set to an empty string.
Copy Constructor
~CLabel();
makes sure that memory pointed by _data is deallocated before the object is destroyed.
===Methods===
void draw(int fn=C_NO_FRAME) ;
makes a direct call to bio_display, passing '''_data''' for the string to be printed and absRow() and absCol() for row and col and _length for len.
this function ignores the argument fn.
int edit();
calls draw, returning 0.
bool editable()const;
always return false.
void set(const void* str);
if _length is greater than zero, it will copy the string pointed by str into the string pointed by _data upto _length characters.
if _length is zero, it will delete the memory pointed by _data and reallocates enough memory for str and copies the string pointed by str into the newly allocated memory pointed by _data.
Organizes CField objects on the screen, displays them and then lets the user edit them one by one.
class CField;
int add(CField* field, bool dynamic = true);
int add(CField&amp; field, bool dynamic = false); CDialog&amp; operator&lt;&lt;<<(CField* field); CDialog&amp; operator&lt;&lt;<<(CField&amp; field);
bool editable();
int curIndex()const;
CField&amp; operator[](unsigned int index); CField&amp; curField();
};
===Attributes===
====Mandatory====
int _fnum;
Holds the number of Fields added to the Dialog
bool _editable;
will be set to true if any of the Fields added are editable.
====Optional====
This is optional because it depends on how you are going to implement the collection of CFields:
int _curidx;
Holds the index of the Field that is currently being edited.
CField* _fld[C_MAX_NO_FIELDS];
Array of CField pointers to hold the address of the CField objects added to the screen.
bool _dyn[C_MAX_NO_FIELDS];
Holds series of boolean to the exact number of fields, and each boolean here will hold false if the corresponding field pointed by _fld is allocated dynamically or not.
This array will later on be used by destructor to decide which object is dynamic and to be deleted.
===Constructors/Destructors===
CDialog(CFrame *Container = (CFrame*)0,
int Row = -1, int Col = -1,
bool Borderd = false,
const char* Border=C_BORDER_CHARS);
Then it will set called a attributes to their default values and then sets all the field pointers (_fld) to NULL.
It also sets all the dynamic (_dyn) flags to false.
virtual ~CDialog();
The destructor, will loop through all the field pointers and if the corresponding dynamic flag is true then it will delete the field pointed to by the field pointer.
===Methods===
void draw(int fn = C_FULL_FRAME);
If '''fn''' is a non-zero positive value, then it will only draw '''Field''' number '''fn''' in the dialog. (First added '''Field''' is field number one.)
int edit(int fn = C_FULL_FRAME);
If fn is '''0''' or less, then before editing, the draw method is called with '''fn''' as its argument and then editing begins from the first editable Field.
Start editing from field number '''fn''';
Call the edit of each field and depending on the value returned, do the following:&lt;<br /&gt;>
# For '''ENTER_KEY''', '''TAB_KEY''' and '''DOWN_KEY''', go to next editable Field , if this is the last editable Field then restart from Field number one.
# For '''UP_KEY''' go to the previous editable Field, if there is no previous editable Field, go to the last editable Field in the Dialog.
# For any other key, terminate the edit function returning the character which caused the termination.
int add(CField* field, bool dynamic = true);
Make sure that add() sets the container of the added CField to this CDialog object, using the container() method of CField'''
Makes a direct call to the first add method.
Makes a direct call to the first add method, ignoring the second argument and then returns the owner (current CDialog).
Makes a direct call to the second add method, ignoring the second argument and then returns the owner (current CDialog).
bool editable();
Returns '''_editable''';
int fieldNum()const;
returns '''_fnum'''.
int curIndex()const;
returns '''_curidx''';
Returns the reference of the Field with incoming index. (Note that here, the first field index is '''0''')
Returns the reference of the Field that was just being edited.
==CLineEdit==
'''ClineEdit''' encapsulates the bio_edit function of bio library.
#pragma once
#include &quot;"cfield.h&quot;"
class CLineEdit: public CField{
void set(const void* Str);
};
CLineEdit(char* Str, int Row, int Col, int Width,
int Maxdatalen, int* Insertmode,
bool Bordered = false,
const char* Border=C_BORDER_CHARS);
LineEdit, sets the Field's _data to the value of str. If LineEdit is instantiated with this constructor then it will edit an external string provided by the caller function of LineEdit. LineEdit in this case is not creating any dynamic memory, therefore _dyn is set to false (therefore the destructor will not attempt to deallocate the memory pointed by _data).&lt;<br /&gt;>The location (row and col) and Bordered are directly passed to the parent (FWField) and str is passed as data to the parent constructor. Unlike Label, LineEdit could have border or not so depending on this (Bordered being true or false) the Height is set to 3 or 1 respectfully. &lt;<br /&gt;>
(hint: use '''? :''' operator to pass the proper Height value to FWField's constructor)
CLineEdit(int Row, int Col, int Width,
int Maxdatalen, int* Insertmode,
bool Bordered = false,
const char* Border=C_BORDER_CHARS);
Works exactly like the previous constructor with one difference; since no external data is passed to be edited here, this constructor must allocate enough dynamic memory to accommodate editing of '''Maxdatalen''' characters. Then make it an empty string and set Fields's _data to point to it. Make sure _dyn is set to true in this case, so the destructor knows that it has to deallocate the memory at the end.
~CLineEdit();
If '''_dyn''' is true, it will deallocate the character array pointed by Fields's '''_data'''
void draw(int Refresh = C_FULL_FRAME);
The values used for the arguments of bio_display are:
*str: address of string pointed by _data + the value of _offset
*col: absCol() (''add one if border is visible'')
*len: width() (''reduce by two is border is visible''')
int edit();
Makes a direct call to, and returns '''bio_edit()'''.
For the coordinates and width arguments follow the same rules as the draw function.
For the rest of the arguments of bio_edit, use the attributes of '''CLineEdit'''.
bool editable()const;
Always return true;
void set(const void* Str);
Copies the characters pointed by '''Str''' into the memory pointed by Field's '''_data''' up to '''_maxdatalen''' characters.
It displays a small piece of text (usually one word or two) and accepts one key hit entry.
When in edit mode, to indicate the editing mode, it will surround the text with squared brackets.
#pragma once
#include &quot;"cfield.h&quot;"
class CButton: public CField{
public:
};
===Attributes===
This class does not have any attributes of its own!
===Constructor / Destructor===
CButton(const char *Str, int Row, int Col,
bool Bordered = true,
const char* Border=C_BORDER_CHARS);
For width: Set width to the length of '''Str''' + 2 (adding 2 for surrounding brackets) or if the Button is bordered set width to the length of '''Str''' + 4 (adding 2 for surrounding brackets and 2 for the borders).
For height: Set the height to 1 or if the Button is bordered, set the height to 3.
virtual ~CButton();
Deallocates the allocated memory pointed by Field's '''_data'''.
===Methods===
void draw(int fn=C_FULL_FRAME);
:*First calls Frame's draw(fn) (passing the fn argument to the parents draw)
:*:display the text at absRow()+1 and absCol()+2
int edit();
bool editable()const;
Always returns true;
void set(const void* str);
:''Then allocate new memory to the size of content of '''str''' and copy the content into it and make Field's '''_data''' point to it.''
==CCheck==
class CCheck : public CField{
int _flag;
public:
CCheck(bool Checked,const char* Format, const char* Text, int Row, int Col, int Width, bool IsRadio = false);
CCheck(const CCheck&amp; C);
void draw(int fn = C_NO_FRAME) ;
int edit();
void checked(bool val);
};
===Attributes===
int _flag;
int _radio;
char _format[4];
CLabel _Label;
*'''_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. &quot;"[X]&quot;", &quot;"(O)&quot;", &quot;&lt;"<*&gt;&quot;>", etc...).
*'''_Label''' holds the Label attached to the this Checkbox
===Constructor / Destructor===
CCheck(bool Checked,const char* Format, const char* Text, int Row, int Col, int Width, bool IsRadio = false);
*: *see page 64 of Practical Programming Techniques Using C++
*Sets the frame of _Label to itself
*Sets _data to the address of _flag
*Sets _data to the address of _flag
===Methods===
void draw(int fn = C_NO_FRAME) ;
*Uses bio_displayflag() to display _flag using _format at absRow() and absCol()
*Then draw()s the _Label
int edit();
*returns bio_flag()'s returned value.
*:bio_flag is to edit the value of _flag using the same arguments used in draw() as radiobutton or checkbox depending to the value of _radio
bool editable()const;
*Always return true;
void set(const void* flag);
*Casts the incoming flag pointer to an (int*) and sets the content of '''_flag''' to where '''flag''' is pointing to.
bool checked()const;
void checked(bool val);
*These methods set and get _flag.
==CMenuItem==
class CMenuItem:public CField{
int _selected;
public:
CMenuItem(bool Selected,const char* Format, const char* Text, int Row, int Col, int Width);
CMenuItem(const CMenuItem &amp;CM);
virtual ~CMenuItem(void);
void draw(int fn = C_NO_FRAME) ;
const char* Text();
};
===Attributes===
int _selected;
char _format[3];
char* _text;
*_selected holds the status of the menuitem (0: not selected, 1: selected) and is pointed by _data.
*_format hods the surrounding &quot;"selection indicator&quot; " characters used by bio_displaymenuitem.
*_text points to the allocated memory holding the text of the menuitem
===Constructors / Destructor===
CMenuItem(bool Selected,const char* Format, const char* Text, int Row, int Col, int Width);
*Sets _selected to Selected (0 for false and 1 for true)
*Copies Format into _format
*Sets _data to the address of _selected
*It passes the Row, the Col and the Width to the CField constructor
*Allocated enough memory to hold CM._text and sets _text to address of newly allocated memory
*Copies the string pointed by CM._text into _text
*Sets _selected to CM._selected
*Sets _data to the address of _selected
~CMenuItem(void);
*Deallocated the memory pointed by _text
===Methods===
void draw(int fn = C_NO_FRAME) ;
*Draws the object using bio_displayMenuItem function.
*:Make sure absRow() and absCol() are used for Row and Col args of bio_displayMenuItem
int edit();
*Returns the returned value of bio_menuItem() using the same arguemtns used in draw()
bool editable()const;
*Always returns true
void set(const void* Selected);
*Sets _selected to content pointed by Selected
bool selected()const;
void selected(bool val);
*These methods set and get _selected.
const char* Text()const;
*Returns _text
=Complex Core User Interface classes=
==CValEdit==
class CValEdit: public CLineEdit{
void (*_help)(MessageStatus, CDialog&amp;); bool (*_validate)(const char*, CDialog&amp;);
public:
CValEdit(char* Str, int Row, int Col, int Width,
int Maxdatalen, int* Insertmode,
bool (*Validate)(const char* , CDialog&amp;) = NO_VALDFUNC, void (*Help)(MessageStatus, CDialog&amp;) = NO_HELPFUNC,
bool Bordered = false,
const char* Border=C_BORDER_CHARS);
CValEdit(int Row, int Col, int Width,
int Maxdatalen, int* Insertmode,
bool (*Validate)(const char* , CDialog&amp;) = NO_VALDFUNC, void (*Help)(MessageStatus, CDialog&amp;) = NO_HELPFUNC,
bool Bordered = false,
const char* Border=C_BORDER_CHARS);
int edit();
};
===Attributes===
*_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, int* Insertmode,
bool (*Validate)(const char* , CDialog&amp;) = NO_VALDFUNC, void (*Help)(MessageStatus, CDialog&amp;) = NO_HELPFUNC,
bool Bordered = false,
const char* Border=C_BORDER_CHARS);
CValEdit(int Row, int Col, int Width,
int Maxdatalen, int* Insertmode,
bool (*Validate)(const char* , CDialog&amp;) = NO_VALDFUNC, void (*Help)(MessageStatus, CDialog&amp;) = NO_HELPFUNC,
bool Bordered = false,
const char* Border=C_BORDER_CHARS);
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();
If the container() is not NULL:
#If _help function exist it calls the function passing MessageStatus::SetMessage and container()'s reference as arguments.
#It will return the terminating key
''Navigation keys are Up key, Down key, Tab key or Enter key.''&lt;<br /&gt;>
''MessageStatus is enumerated in '''cgh.h'''''
==CText==
~CText();
};
==CCheckList==
class CCheckList;
public:
CCheckList(const char* Format, int Row, int Col, int Width,bool radio, bool Bordered = true,const char* Border=C_BORDER_CHARS);
CCheckList&amp; add(const char* Text, bool selected = false);
void draw(int fn = C_FULL_FRAME);
int edit();
void* data();
void set(const void* data);
bool&amp; operator[](unsigned int index);
bool editable()const;
bool radio();
};
==CMenu==
class Cmenu;
public:
CMenu(const char* Format, int Row, int Col, int Width, bool Bordered = true,const char* Border=C_BORDER_CHARS);
CMenu&amp; add(const char* Text, bool selected = false);
void draw(int fn = C_FULL_FRAME);
int edit();
~CMenu(void);
};
=Make Files and Testers=
Copy these makefiles under &quot;"makefile&quot; " name in root of your project in Linux or Mac.&lt;<br /&gt;>Replace the &quot;&lt;"<tab&gt;&quot; >" with tab character&lt;<br /&gt;>then issue the make command: &lt;<br /&gt;>$make &lt;<enter&gt;&lt;><br /&gt;>this will compile your code and create an executable called prjexe, if there is no error&lt;<br /&gt;>Also, copies of all these make files and tester programs are commited to: '''svn://zenit.senecac.on.ca/oop344/trunk/Testers&lt;<br /&gt;>The executable of testers are compiled and copied in my account on matrix:&lt;<br /&gt;>login to matix and run:&lt;<br /&gt;>$~fardad.soleimanloo/t[X]&lt;<br /&gt;>
where [X] is number of the test. (i.e. run $fardad.soleimanloo/t3 for test3
== Test2 Make file ==
t2: bio.o cframe.o cfield.o cdialog.o clabel.o Test2DialogAndLabel.o
<tab>c++ bio.o cframe.o cfield.o cdialog.o clabel.o \
<tab>c++ -c Test2DialogAndLabel.cpp
</pre></big>
==Test 3 make file==
prj: bio.o cframe.o cfield.o cdialog.o clabel.o clineedit.o Test3DialogAndLineEdit.o
-lncurses -oprjexe
bio.o: bio.c bio.h
cframe.o: cframe.cpp cframe.h cgh.h
cfield.o: cfield.cpp cfield.h cgh.h cframe.h
cdialog.o: cdialog.cpp cdialog.h cfield.h cgh.h cframe.h
clabel.o: clabel.cpp clabel.h cfield.h cframe.h cgh.h
clineedit.o: clineedit.cpp clineedit.h cfield.h cframe.h cgh.h
Test3DialogAndLineEdit.o: Test3DialogAndLineEdit.cpp clineedit.h clabel.h cdialog.h cfield.h cframe.h cgh.h
==Full Project Makefile==
Not Tested!
prj: bio.o cframe.o cfield.o cdialog.o clabel.o clineedit.o cmenuitem.o cbutton.o ccheck.o cchecklist.o cmenu.o cveditline.o ctext.o strarr.o prj.o
c++ bio.o cframe.o cfield.o cdialog.o clabel.o clineedit.o cmenuitem.o cbutton.o ccheck.o cchecklist.o cmenu.o cveditline.o ctext.o strarr.o prj.o \
c++ -c prj.cpp
</pre></big>