Make your own free website on Tripod.com

CPP2HTM Builder Aux File

/*****************************************************************
     
     PURPOSE: Contains methods which accompany the HtmBuilder 
             class defined in builderspec.h and other 
             non-member class functions. 

*****************************************************************/

#include "builderspec.h"


// default construtor
Config :: Config()
{     
     // ********* allocate data member memory *********** //

     browserTitle = new char[TITLELEN];
     bgColor = new char[HEXLENGTH];
     textColor = new char[HEXLENGTH];
     pageTitle = new char[TITLELEN];
     fontType = new char[FONTLENGTH];

     // ********* default values *********** //

     configFlag = OFF;          // configuration tool flag
     pageTitleFlag = OFF;     // title option flag
     lineNumberFlag = OFF;     // line number display flag
     titleAlignment = LEFT;

     strncpy(textColor, hexBlack, HEXLENGTH);
     strncpy(bgColor, hexWhite, HEXLENGTH);
     strncpy(fontType, "fixedsys", FONTLENGTH);

     tabSize = DEFTABSIZE;
     fontSize = DEFFONTSIZE;
     lineNumber = 1;

}// end Config :: Config()


// destructor
Config :: ~Config()
{
     delete browserTitle;
     delete bgColor;
     delete textColor;
     delete pageTitle;
     delete fontType;

}// end Config :: ~Config()


// default constructor
HtmBuilder :: HtmBuilder()
{
     status = INCOMPLETE;

}// end HtmBuilder :: HtmBuilder()


// displays main menu and performs major operations
void HtmBuilder :: run()
{
     tFileError openResult;
     int selection;

     while ( getProgramStatus() == INCOMPLETE ) // program not done
     {
          displayHeader("CPP2HTM Builder");

          displayRunMenu();
          selection = getRunMenuSelection(); // prompt user for selection

          if ( selection != USERDONE ) // user not done
          {
               // prompt for option of web page configuration
               getConfigRequest();

               // prompt for input (source) and output (destination) file paths
               openResult = getDataFiles();

               if (openResult == FILE_OK)
               {
                    if ( getConfigFlag() == ON ) // user wishes to configure settings
                         runConfigTool();

                    interpretSource(); // translate source and send data to destination file

                    cout << endl;
                    displayMessage(" File build operation completed successfully.");

                    clearData(); // set values back to defaults for next build
               }
               else // invalid file paths
               {
                    cout << endl;
                    displayMessage(" File build operation completed unsuccessfully.");
               }

               pause(" Press any key to return to main builder menu...");
               cout << endl;

          }
          else // user done
          {
               cout << endl;
               displayMessage(" CPP2HTM builder tool is terminated.");
               setProgramStatus(COMPLETE);
          }
     }
          
     cout << endl << endl;
}// end HtmBuilder :: runMenu()


// prompts user for option of running web page configuration tool
void HtmBuilder :: getConfigRequest()
{
     char request;
     
     cout << endl 
          << "  Do you wish to configure visual details of web page (Y/N)? ";
     cin >> request;
     cin.ignore(IGNORELEN, '\n');

     if (toupper(request) == 'Y') // user wishes to configure
     {
          displayMessage("   [ CONFIGURATION TOOL ACTIVATED ] => Execution momentarily.");
          setConfigFlag(ON);
     }
     else
          displayMessage("   [ CONFIGURATION TOOL NOT ACTIVATED ] => Defaults will be used.");

}// end HtmBuilder :: getDataFiles()


// prompt for input (C or C++ source) and output (HTML destination) file paths
tFileError HtmBuilder :: getDataFiles()
{
     char proceedOption;
     tFileError result;

     cout << endl << "  Enter full path of C/C++ source file: "; // C or C++ source path
     cin.get(cppFile, FILENAMELEN);
     cin.ignore(IGNORELEN, '\n');

     cout << endl << "  Enter full path of HTML destination file: "; // HTML destination path
     cin.get(htmlFile, FILENAMELEN);
     cin.ignore(IGNORELEN, '\n');

     cout << endl 
          << "  *** WARNING ***" << endl << "    POSSIBLE OVERWRITE: [ " << htmlFile << " ]" << endl;
     cout << endl << "  PROCEED (Y/N)? ";
     cin.get(proceedOption);
     cin.ignore(IGNORELEN, '\n');

     if (toupper(proceedOption) != 'N')
     {
          inCppFile.open(cppFile); // attempt to open source file

          if ( !inCppFile ) // error check
          {
               cerr << endl << endl 
                    <<  "  Error opening specified C/C++ source file: " << inCppFile << endl;
               exit(EXIT_FAILURE);
          }

          outHtmFile.open(htmlFile); // attempt to open destination file

          if ( !outHtmFile ) // error check
          {
               cerr << endl << endl 
                    << "  Error opening specified HTML destination file: " << outHtmFile << endl;
               exit(EXIT_FAILURE);
          }

          setBrowserTitle(htmlFile); // default web page title value
          result = FILE_OK;
     }
     else result = FILE_ERROR;

     return result;

}// end HtmBuilder :: getDataFiles()


// presents main menu for configuration tool used to change build settings
void HtmBuilder :: runConfigTool()
{
     int selection = 0;
     bool toolFinished = false;

     while ( toolFinished == false) // user not done configuring
     {
          cout << endl << endl;
          displayHeader("Web Page Configuration Tool");

          displayConfigMenu(); // main tool option menu

          selection = getConfigMenuOption(); // prompt user for detail to configure

          toolFinished = executeSelection( selection, toolFinished ); // perform operation
     }

}// end HtmBuilder :: runConfigTool()


// translate source C or C++ file and send data to destination HTML file
void HtmBuilder :: interpretSource()
{
     char currentChar;
     bool charOk;
     int spcSize;

     sendHtmHeader(); // send HTML heading markup to file

     if ( getlineNumberFlag() == ON ) // display first line number ( 1: )
     {
          outHtmFile << getlineNumber() << ":";
          for (spcSize = 1; spcSize <= LINENUMSPC; spcSize++) // separate number for code
               outHtmFile << " ";
          incrementlineNumber();
     }

      while ( inCppFile.get(currentChar) ) // file contains data
     {
          charOk = true;
          charOk = checkCharMeaning(currentChar); // check for HTML markup conflict

          if ( charOk ) // no conflict with HTML markup
               outHtmFile.put(currentChar);
     }

     sendHtmFooter(); // send HTML closing markup to file

      inCppFile.close();
     outHtmFile.close();

}// end HtmBuilder :: interpretSource()


// checks character from source to determine if it has special meaning to HTML markup
// if conflicting, an HTML specifier symbol must be used
bool HtmBuilder :: checkCharMeaning(char token)
{
     bool htmlOk = true;
     int spcSize;

     if ( token == '\n' ) // new line 
     {
          outHtmFile << _lt << "br" << _gt << endl; // HTML line break

          if ( inCppFile.peek() != EOF )          // if content exists on next line
               if ( getlineNumberFlag() == ON )
               {
                    outHtmFile << getlineNumber() << ":";
                    for (spcSize = 1; spcSize <= LINENUMSPC; spcSize++) 
                         outHtmFile << " ";
               }

          incrementlineNumber();
          htmlOk = false;
     }
     else if ( token == 32 ) // white (character) space
     {
          outHtmFile << " ";
          htmlOk = false;
     }
     else if ( token == 9 ) // tab
     {
          for (spcSize = 1; spcSize <= 5; spcSize++)
               outHtmFile << " "; 
          htmlOk = false;
     }
     else if ( token == 60 ) // less than '<' character
     {
          outHtmFile << "<";
          htmlOk = false;
     }
     else if ( token == 62 ) // greater than '>' character
     {
          outHtmFile << ">";
          htmlOk = false;
     }

     return htmlOk; // character status

}// end HtmBuilder :: checkCharMeaning()


// configures text displayed in title bar of web browser
void HtmBuilder :: configBrowserTitle()
{
     char* title = new char[TITLELEN];

     cout << endl;
     displayHeader("Configure Web Browser Title Bar Text");

     displayPrompt(" Enter web page title: ");
     cin.get(title, TITLELEN);
     cin.ignore(80, '\n');

     setBrowserTitle(title);

     displayMessage(" Browser title bar text successfully manipulated.");
     pause(" Press any key to return to main config menu...");

}// end HtmBuilder :: configBrowserTitle()


// configures color of web page background
void HtmBuilder :: configBgColor()
{
     cout << endl;
     displayHeader("Configure Background Color");

     setBgColor( getDesiredColor() );

     displayMessage(" Web page background color successfully manipulated.");
     pause(" Press any key to return to main config menu...");

}// end HtmBuilder :: configBgColor()


// configures color of web page text
void HtmBuilder :: configTextColor()
{
     cout << endl;
     displayHeader("Configure Text Color");

     setTextColor( getDesiredColor() ); // prompt user for color selection 

     displayMessage(" Web page text color successfully manipulated.");
     pause(" Press any key to return to main config menu...");

}// end HtmBuilder :: configTextColor()


// configures title text to be displayed at top of web page before code
void HtmBuilder :: configPageTitle()
{
     char* title = new char[TITLELEN];

     cout << endl;
     displayHeader("Configure Web Page Heading Text");

     displayPrompt(" Enter web page heading text: ");
     cin.get(title, TITLELEN);
     cin.ignore(IGNORELEN, '\n');

     setPageTitle(title);
     setTitleAlignment( getDesiredAlignment() );

     displayMessage(" Web page title text successfully manipulated.");
     pause(" Press any key to return to main config menu...");

}// end HtmBuilder :: configPageTitle()


// configures text font type
void HtmBuilder :: configFontType()
{
     char* fontType = new char[FONTLENGTH];

     cout << endl;
     displayHeader("Configure Text Font Type");

     setFontType( getDesiredFontType() );
     setFontSize ( getDesiredFontSize() );

     displayMessage(" Text font type and size successfully manipulated.");
     pause(" Press any key to return to main config menu...");

}// end HtmBuilder :: configFontType()


// configures tab size used in build where a tab occurs in source code
void HtmBuilder :: configTabSize()
{
     tUserInput userInput = INVALID;
     int size;

     while ( userInput == INVALID ) // user specified invalid data
     {
          userInput = VALID;

          displayPrompt(" Enter tab size used for build spacing: ");
          cin >> size;
          cin.ignore(IGNORELEN, '\n');

          if ( size < 0 )
          {
               cout << "  Tab size cannot be negative in value." << endl;
               cout << "  Re-enter data.";
               userInput = INVALID;
          }
     }

     setTabSize(size);

     displayMessage(" Tab size successfully manipulated.");
     pause(" Press any key to return to main config menu...");

}// end HtmBuilder :: configTabSize()


// configures line number option
void HtmBuilder :: configLineNumbers()
{
     char lineOption;

     displayPrompt(" Show line numbers in build (Y/N)? ");
     cin >> lineOption;
     cin.ignore(IGNORELEN, '\n');

     if ( toupper(lineOption) == 'Y' )
          setlineNumberFlag(ON);
     else
          setlineNumberFlag(OFF);

     displayMessage(" Line number option successfully manipulated.");
     pause(" Press any key to return to main config menu...");

}// end HtmBuilder :: configLineNumbers()


// displays configuration settings for current build
void HtmBuilder :: showCurSettings()
{
     cout << endl << endl 
          << setw(MENUTITLESPC) << " " << "CURRENT SETTINGS -->" << endl << endl
          << setw(MENUOPSPC) << " " << "BROWSER TITLE TEXT...: " << getBrowserTitle() << endl
          << setw(MENUOPSPC) << " " << "BACKGROUND COLOR.....: " << getBgColor() << endl
          << setw(MENUOPSPC) << " " << "TEXT COLOR...........: " << getTextColor() << endl 
          << setw(MENUOPSPC) << " " << "WEB PAGE TITLE.......: ";

     showPageTitleSettings();

     cout << setw(MENUOPSPC) << " " << "TEXT FONT TYPE.......: " << getFontType() 
          << " (" << getFontSize() << "px)" << endl
          << setw(MENUOPSPC) << " " << "TAB SIZE.............: " << getTabSize() << endl
          << setw(MENUOPSPC) << " " << "LINE NUMBERS.........: ";

     showLineNumSettings();
     pause(" Press any key to return to main config menu...");

}// end HtmBuilder :: showCurSettings()


// displays default configuration settings for current build
void HtmBuilder :: showDefSettings()
{
     cout << endl << endl 
     << setw(MENUTITLESPC) << " " << "DEFAULT SETTINGS -->" << endl << endl
          << setw(MENUOPSPC) << " " << "BROWSER TITLE TEXT...: " << htmlFile << endl
          << setw(MENUOPSPC) << " " << "BACKGROUND COLOR.....: " << hexWhite << endl
          << setw(MENUOPSPC) << " " << "TEXT COLOR...........: " << hexBlack << endl 
          << setw(MENUOPSPC) << " " << "WEB PAGE TITLE.......: " << "[none]" << endl
          << setw(MENUOPSPC) << " " << "TEXT FONT TYPE.......: " << "fixedsys (" 
               << DEFFONTSIZE << "px)" << endl
          << setw(MENUOPSPC) << " " << "TAB SIZE.............: " << DEFTABSIZE << endl
          << setw(MENUOPSPC) << " " << "LINE NUMBERS.........: " << "OFF" << endl << endl;
     
     pause(" Press any key to return to main config menu...");

}// end HtmBuilder :: showDefSettings()


// restores current configuration settings to default values
void HtmBuilder :: restoreDefSettings()
{
     setBrowserTitle(htmlFile);
     setBgColor( getHexColor(WHITE_HEX_INDEX) );
     setTextColor( getHexColor(BLACK_HEX_INDEX) );
     setFontType("fixedsys");
     setFontSize(12);
     setPageTitleFlag(OFF);
     setTabSize(DEFTABSIZE);
     setlineNumberFlag(OFF);
     
     displayMessage("  Default settings successfully restored.");
     pause(" Press any key to return to main config menu...");

}// end HtmBuilder :: restoreDefSettings()


// prompts user for main configuration menu selection
int HtmBuilder :: getConfigMenuOption()
{
     int option;

     cout << "  Enter menu selection: ";
     cin >> option;
     cin.ignore(IGNORELEN, '\n');

     while ( option < 1 || option > 11 )
     {
          cout << "  [ SPECIFIED SELECTION INVALID ]" << endl;
          cout << "  Menu option must be in 1 to 11 range." << endl << endl;

          cout << "  Enter menu selection: ";
          cin >> option;
          
     }

     return option;

}// end HtmBuilder :: getConfigMenuOption()


// performs configuration operation specified by user
bool HtmBuilder :: executeSelection(int selection, bool status)
{
          switch ( selection )
          {
               case BROWSER_TITLE:
                    configBrowserTitle();
                    break;

               case BG_COLOR:
                    configBgColor();
                    break;

               case TEXT_COLOR:
                    configTextColor();
                    break;

               case PAGE_TITLE:
                    configPageTitle();
                    break;

               case FONT_TYPE:
                    configFontType();
                    break;

               case TAB_SIZE:
                    configTabSize();
                    break;

               case LINE_NUMBERS:
                    configLineNumbers();
                    break;

               case CUR_SETTINGS:
                    showCurSettings();
                    break;

               case DEF_SETTINGS:
                    showDefSettings();
                    break;

               case RES_DEF_SETTINGS:
                    restoreDefSettings();
                    break;

               case EXIT: 
                    status = true;
                    break;

               default:
                    cout << "  [ INVALID OPTION SPECIFIED ]" << endl;
                    cout << "  Menu option must be in 1 to 11 range." << endl << endl;
          }

          return status; // current status of configuration tool

}// end HtmBuilder :: executeSelection()


// prompts user for color selection based on hexadecimal schemes
char* HtmBuilder :: getDesiredColor()
{
     int option = 0;
     char* hexColor = new char[HEXLENGTH];

     displayColorOptions();

     displayPrompt(" Enter color option: ");
     cin >> option;
     cin.ignore(IGNORELEN, '\n');

     while ( option < 1 || option > 22 )
     {
          cout << "  [ SPECIFIED SELECTION INVALID ]" << endl;
          cout << "  Menu option must be in 1 to 22 range." << endl << endl;

          cout << "  Enter color option: ";
          cin >> option;
          
     }

     hexColor = getHexColor(option);
     return hexColor;

}// end HtmBuilder :: getDesiredColor()


// prompts user for specified alignment of text
tAlignment HtmBuilder :: getDesiredAlignment()
{
     int selection;
     tAlignment alignChoice = LEFT; // default value

     displayAlignOptions();

     displayPrompt(" Enter alignment justification: ");
     cin >> selection;

     while ( selection < 1 || selection > 3 )
     {
          cout << "  [ SPECIFIED SELECTION INVALID ]" << endl;
          cout << "  Menu option must be in 1 to 3 range." << endl << endl;

          cout << "  Enter alignment justification: ";
          cin >> selection;
          
     }

     alignChoice = getAlignmentChoice(selection);
     return alignChoice;

}// end HtmBuilder :: getDesiredAlignment()


// prompts user for font type of text based on available types
char* HtmBuilder :: getDesiredFontType()
{
     int selection;

     displayFontTypes();

     displayPrompt(" Select font type: ");
     cin >> selection;

     while ( selection < 1 || selection > 9 )
     {
          cout << "  [ SPECIFIED SELECTION INVALID ]" << endl;
          cout << "  Menu option must be in 1 to 9 range." << endl;;

          displayPrompt("  Select font type: ");
          cin >> selection;
     }

     return ( getFontTypeChoice(selection) );

}// end HtmBuilder :: getDesiredFontType()


// prompts user for font size of text
int HtmBuilder :: getDesiredFontSize()
{
     int size;

     displayPrompt(" Enter font size in pixels: ");
     cin >> size;

     return ( size );

}// end HtmBuilder :: getDesiredFontSize()


// determines if user has configured web page title
void HtmBuilder :: showPageTitleSettings()
{
     if ( getPageTitleFlag() == ON ) // title configured
     {
          cout << getPageTitle(); 
          showAlignment();
     }
     else
          cout << "Not specified." << endl;

}// end HtmBuilder :: showPageTitleSettings()


// determines if user has configured line number option
void HtmBuilder :: showLineNumSettings()
{
     if ( getlineNumberFlag() == ON ) // line numbers configured
          cout << "ON" << endl << endl;
     else
          cout << "OFF" << endl << endl;

}// end HtmBuilder :: showLineNumSettings()


// displays alignment based upon configuration settings
void Config :: showAlignment()
{
     switch ( getTitleAlignment() ) // web page title 
     {
          case LEFT :
               cout << " (left)" << endl;
               break;
          case CENTER :
               cout << " (center)" << endl;
               break;
          case RIGHT :
               cout << " (right)" << endl;
     }
}// end Config :: showAlignment()


// sends web page title settings HTML destination file
void HtmBuilder :: sendPageTitle()
{
     if ( getTitleAlignment() == CENTER )
          outHtmFile << _lt << "div align=\"center\"";
     else if ( getTitleAlignment() == RIGHT )
          outHtmFile << _lt << "div align=\"right\"";
     else 
          outHtmFile << _lt << "div align=\"left\""; // default justification


          outHtmFile << _gt << _lt << "h2" << _gt << getPageTitle() << _lt << _sl 
                    << "h2" << _gt << _lt << _sl << "div" << _gt;          

}// end Config :: showPageTitle()


// clears current build data (actually restores defaults) to prepare for next build
void HtmBuilder :: clearData()
{
     setBrowserTitle(htmlFile);
     setBgColor( getHexColor(WHITE_HEX_INDEX) );
     setTextColor( getHexColor(BLACK_HEX_INDEX) );
     setFontType("fixedsys");
     setFontSize(12);
     setPageTitleFlag(OFF);
     setTabSize(DEFTABSIZE);
     setlineNumberFlag(OFF);
     clearLineCount();

}// end HtmBuilder :: clearData()


// send HTML heading markup to destination file 
void HtmBuilder :: sendHtmHeader()
{
     /* CODE PRODUCES SIMILAR BUT NOT PRECISELY:

          <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
          <html>
          <head><title>[BROWSER TITLE]</title>
          <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
          <style type="text/css">
          <!--
          body { font-family: [FONTTYPE]; font-size: [FONTSIZE]pt}
          -->
          </style>
          </head>
          <body bgcolor="[HEXVALUE]" text="[HEXVALUE]">
          <p><div align="ALIGNMENT"><h2> [WEB PAGE TITLE GOES HERE] </h2></div>
     */

     outHtmFile << _lt << "!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\"" << _gt << endl
               << _lt << "html" << _gt << endl << _lt << "head" << _gt << _lt << "title" << _gt 
               << getBrowserTitle() << _lt << _sl << "title" << _gt << endl << endl 
               << _lt << "meta http-equiv=\"Content-Type\" content=\"text/html; charset=iso-8859-1\"" << _gt 
               << endl << endl << _lt << "style type=\"text/css\"" << _gt << endl << _lt << "!--" << endl 
               << endl << "body { font-family: " << getFontType() << "; font-size: " << getFontSize() 
               << "px}" << endl << endl 
               << "--" << _gt << endl << _lt << "/style" << _gt << endl << endl << _lt << _sl << "head" << _gt 
               << endl << endl << _lt << "body bgcolor=" << getBgColor() <<  " text=" << getTextColor() << _gt
               << endl << endl << _lt << "p" << _gt;

     if ( getPageTitleFlag() == ON )
          sendPageTitle();

}// end HtmBuilder :: sendHtmHeader()


// sends HTML closing markup to destination file
void HtmBuilder :: sendHtmFooter()
{
     /* CODE PRODUCES SIMILAR BUT NOT PRECISELY:

     <br><br>Rendered using: CPP2HTM Builder -- http://warebiz.tripod.com/<br><br>
     </body>
     </html>

     */

     outHtmFile << endl << endl << _lt << "br" << _gt << _lt << "br" << _gt 
               << "Rendered using: CPP2HTM Builder -- http://warebiz.tripod.com/" 
               << _lt << "br" << _gt << _lt << "br" << _gt << endl << endl 
               << _lt << _sl << "body" << _gt << endl << _lt << _sl << "html" << _gt << endl << endl;     

}// end HtmBuilder :: sendHtmFooter()


// retrieves data member denoting program status COMPLETE/INCOMPLETE
tProgStatus HtmBuilder :: getProgramStatus()
{
     return status;

}// end getProgramStatus()


// accesses data member denoting program status COMPLETE/INCOMPLETE
void HtmBuilder :: setProgramStatus(tProgStatus inStatus)
{
     status = inStatus;

}// end setProgramStatus()


// accesses data member denoting user choice of running configuration tool
void Config :: setConfigFlag(tConfigFlag inFlag)
{
     configFlag = inFlag;

}// end setConfigFlag()


// accesses data member denoting user choice of a web page title
void Config :: setPageTitleFlag(tConfigFlag inFlag)
{
     pageTitleFlag = inFlag;

}// end Config :: setPageTitleFlag()


// accesses data member denoting user choice of line numbers in build
void Config :: setlineNumberFlag(tConfigFlag inFlag)
{
     lineNumberFlag = inFlag;

}// end Config :: setlineNumberFlag()


// increments data member denoting line number count
void Config :: incrementlineNumber()
{
     lineNumber++;

}// end Config :: incrementlineNumber()


// accesses data member denoting web page title alignment
void Config :: setTitleAlignment(tAlignment inAlign)
{
     titleAlignment = inAlign;

}// end Config :: setTitleAlignment()


// retrieves data member denoting configuration flag
tConfigFlag Config :: getConfigFlag()
{
     return configFlag;

}// end getConfigFlag()


// retrieves data member denoting web page title flag
tConfigFlag Config :: getPageTitleFlag()
{
     return pageTitleFlag;

}// end Config :: getPageTitleFlag()


// retrieves data member denoting web page title alignment
tAlignment Config :: getTitleAlignment()
{
     return titleAlignment;

}// end Config :: getTitleAlignment()


// retrieves data member denoting line number option flag
tConfigFlag Config :: getlineNumberFlag()
{
     return lineNumberFlag;

}// end Config :: getlineNumberFlag()


// retrieves data member denoting browser title text
char* Config :: getBrowserTitle()
{
     return browserTitle;

}// end Config :: getBrowserTitle()


// retrieves data member denoting background color of web page
char* Config :: getBgColor()
{
     return bgColor;

}// end Config :: getBgColor()


// retrieves data member denoting color of web page text
char* Config :: getTextColor()
{
     return textColor;

}// end Config :: getTextColor()


// retrieves data member denoting web page title text
char* Config :: getPageTitle()
{
     return pageTitle;

}// end Config :: getPageTitle()


// retrieves data member denoting font type of web page text
char* Config :: getFontType()
{
     return fontType;

}// end Config :: getFontType()


// retrieves data member denoting font size of web page text
int Config :: getFontSize()
{
     return fontSize;

}// end Cofig :: getFontSize()


// retrieves data member denoting tab size of build code
int Config :: getTabSize()
{
     return tabSize;

}// end Config :: getTabSize()


// retrieves data member denoting current line number
int Config :: getlineNumber()
{
     return lineNumber;

}// end Config :: getlineNumber()


// retrieves data member denoting current line number for assignment of zero
void Config :: clearLineCount()
{
     lineNumber = 1;

}// end Config :: zeroLineNumber()


// accesses data member denoting browser title bar text
void Config :: setBrowserTitle(char* title)
{
     strncpy(browserTitle, title, TITLELEN);

}// end Config :: setBrowserTitle()


// accesses data member denoting background color 
void Config :: setBgColor(char* color)
{
     strncpy(bgColor, color, HEXLENGTH);

}// end Config :: setBgColor()


// accesses data member denoting color of web page text
void Config :: setTextColor(char* color)
{
     strncpy(textColor, color, HEXLENGTH);     

}// end Config :: setTextColor()


// accesses data member denoting web page title text
void Config :: setPageTitle(char* title)
{
     strncpy(pageTitle, title, TITLELEN);
     pageTitleFlag = ON;

}// end Config :: setPageTitle()


// accesses data member denoting font type of web page text
void Config :: setFontType(char* type)
{
     strncpy(fontType, type, FONTLENGTH);

}// end Config :: setFontType()


// accesses data member denoting font size of web page text
void Config :: setFontSize(int size)
{
     fontSize = size;

}// end Config :: setFontSize()


// accesses data member denoting tab size of build code
void Config :: setTabSize(int size)
{
     tabSize = size;

}// end Config :: setTabSize()


/*********************** NON-MEMBER DEFINITIONS ************************/


// displays main builder operational menu
void displayRunMenu()
{
     cout << endl << setw(MENUTITLESPC) << " " << "PROGRAM MENU --->" << endl << endl
          << setw(MENUOPSPC) << " " << "   1 : BUILD FILE" << endl
          << setw(MENUOPSPC) << " " << "   2 : EXIT" << endl << endl;

}// end displayAlignOptions()


// displays main configuration tool menu
void displayConfigMenu()
{
     cout << endl 
          << setw(MENUOPSPC) << " " << "   1 : Browser Title Text" << endl
          << setw(MENUOPSPC) << " " << "   2 : Background Color" << endl
          << setw(MENUOPSPC) << " " << "   3 : Text Color" << endl 
          << setw(MENUOPSPC) << " " << "   4 : Page Title Text" << endl
          << setw(MENUOPSPC) << " " << "   5 : Text Font Type" << endl
          << setw(MENUOPSPC) << " " << "   6 : Tab Size" << endl
          << setw(MENUOPSPC) << " " << "   7 : Line Numbers" << endl
          << setw(MENUOPSPC) << " " << "   8 : Show Current Settings" << endl
          << setw(MENUOPSPC) << " " << "   9 : Show Default Settings" << endl
          << setw(MENUOPSPC) << " " << "  10 : Restore Default Settings" << endl
          << setw(MENUOPSPC) << " " << "  11 : Exit" << endl << endl;

}// end displayConfigMenu()


// displays set of hexadecimal color options
void displayColorOptions()
{
     cout << endl << setw(MENUTITLESPC) << " " << "COLOR OPTIONS ----->" << endl << endl
          << setw(MENUOPSPC) << " " << "   1 : WHITE" << endl
          << setw(MENUOPSPC) << " " << "   2 : PALE RED" << endl
          << setw(MENUOPSPC) << " " << "   3 : RED" << endl
          << setw(MENUOPSPC) << " " << "   4 : DARK RED" << endl 
          << setw(MENUOPSPC) << " " << "   5 : LIGHT ORANGE" << endl
          << setw(MENUOPSPC) << " " << "   6 : ORANGE" << endl 
          << setw(MENUOPSPC) << " " << "   7 : DARK ORANGE" << endl
          << setw(MENUOPSPC) << " " << "   8 : LIGHT YELLOW" << endl
          << setw(MENUOPSPC) << " " << "   9 : YELLOW" << endl
          << setw(MENUOPSPC) << " " << "  10 : GOLD" << endl 
          << setw(MENUOPSPC) << " " << "  11 : LIGHT GREEN" << endl
          << setw(MENUOPSPC) << " " << "  12 : GREEN" << endl 
          << setw(MENUOPSPC) << " " << "  13 : DARK GREEN" << endl
          << setw(MENUOPSPC) << " " << "  14 : LIGHT BLUE" << endl
          << setw(MENUOPSPC) << " " << "  15 : BLUE" << endl
          << setw(MENUOPSPC) << " " << "  16 : DARK BLUE" << endl
          << setw(MENUOPSPC) << " " << "  17 : LIGHT MAGENTA" << endl 
          << setw(MENUOPSPC) << " " << "  18 : MAGENTA" << endl
          << setw(MENUOPSPC) << " " << "  19 : DARK MAGENTA" << endl 
          << setw(MENUOPSPC) << " " << "  20 : LIGHT GRAY" << endl
          << setw(MENUOPSPC) << " " << "  21 : DARK GRAY" << endl
          << setw(MENUOPSPC) << " " << "  22 : BLACK" << endl;
     
}// end displayColorOptions()


// displays text alignment options
void displayAlignOptions()
{
     cout << endl << setw(MENUTITLESPC) << " " << "ALIGNMENT --->" << endl << endl
          << setw(MENUOPSPC) << " " << "   1 : LEFT" << endl
          << setw(MENUOPSPC) << " " << "   2 : CENTER" << endl
          << setw(MENUOPSPC) << " " << "   3 : RIGHT" << endl;

}// end displayAlignOptions()


// displays set of font types
void displayFontTypes()
{
     cout << endl << setw(MENUTITLESPC) << " " << "FONT TYPES --->" << endl << endl
          << setw(MENUOPSPC) << " " << "   1 : ARIAL" << endl
          << setw(MENUOPSPC) << " " << "   2 : COURIER" << endl
          << setw(MENUOPSPC) << " " << "   3 : COURIER NEW" << endl
          << setw(MENUOPSPC) << " " << "   4 : FIXEDSYS [default]" << endl
          << setw(MENUOPSPC) << " " << "   5 : SYSTEM" << endl
          << setw(MENUOPSPC) << " " << "   6 : TAHOMA" << endl
          << setw(MENUOPSPC) << " " << "   7 : TIMES NEW ROMAN" << endl
          << setw(MENUOPSPC) << " " << "   8 : TERMINAL" << endl
          << setw(MENUOPSPC) << " " << "   9 : VERDANA" << endl;

}// end displayFontTypes()


// prompts user for menu selection
int getRunMenuSelection()
{
     int selection;

     displayPrompt(" Enter menu selection: ");
     cin >> selection;
     cin.ignore(IGNORELEN, '\n');

     return selection;

}// end getRunMenuSelection()


// determines color from user specified selection
char* getHexColor(int selection)
{
     char* hexResult = new char[HEXLENGTH];
 
     switch ( selection )
     {
          case WHITE:
               strncpy(hexResult, hexWhite, HEXLENGTH);
               break;
          case PALE_RED:
               strncpy(hexResult, hexPaleRed, HEXLENGTH);
               break;
          case RED:
               strncpy(hexResult, hexRed, HEXLENGTH);
               break;
          case DARK_RED:
               strncpy(hexResult, hexDarkRed, HEXLENGTH);
               break;
          case LIGHT_ORANGE:
               strncpy(hexResult, hexLightOrange, HEXLENGTH);
               break;               
          case ORANGE:
               strncpy(hexResult, hexOrange, HEXLENGTH);
               break;               
          case DARK_ORANGE:
               strncpy(hexResult, hexDarkOrange, HEXLENGTH);
               break;
          case LIGHT_YELLOW:
               strncpy(hexResult, hexLightYellow, HEXLENGTH);
               break;
          case YELLOW:
               strncpy(hexResult, hexYellow, HEXLENGTH);
               break;
          case GOLD:
               strncpy(hexResult, hexGold, HEXLENGTH);
               break;
          case LIGHT_GREEN:
               strncpy(hexResult, hexLightGreen, HEXLENGTH);
               break;
          case GREEN:
               strncpy(hexResult, hexGreen, HEXLENGTH);
               break;
          case DARK_GREEN:
               strncpy(hexResult, hexDarkGreen, HEXLENGTH);
               break;
          case LIGHT_BLUE:
               strncpy(hexResult, hexLightBlue, HEXLENGTH);
               break;
          case BLUE:
               strncpy(hexResult, hexBlue, HEXLENGTH);
               break;
          case DARK_BLUE:
               strncpy(hexResult, hexDarkBlue, HEXLENGTH);
               break;
          case LIGHT_MAGENTA:
               strncpy(hexResult, hexLightMagenta, HEXLENGTH);
               break;
          case MAGENTA:
               strncpy(hexResult, hexMagenta, HEXLENGTH);
               break;
          case DARK_MAGENTA:
               strncpy(hexResult, hexDarkMagenta, HEXLENGTH);
               break;
          case LIGHT_GRAY:
               strncpy(hexResult, hexLightGray, HEXLENGTH);
               break;
          case DARK_GRAY:
               strncpy(hexResult, hexDarkGray, HEXLENGTH);
               break;
          case BLACK:
               strncpy(hexResult, hexBlack, HEXLENGTH);
     }

     return hexResult;

}// end getHexColor()


// determines alignment from user specified selection
tAlignment getAlignmentChoice(int selection)
{
     tAlignment result;

     switch ( selection )
     {
          case LEFT:
               result = LEFT;
               break;
          case CENTER:
               result = CENTER;
               break;
          case RIGHT:
               result = RIGHT;
     }

     return result;

}// end getAlignmentChoice()


// determines font type from user specified selection
char* getFontTypeChoice(int selection)
{
     char* typeResult = new char[FONTLENGTH];
 
     switch ( selection )
     {
          case T_ARIAL:
               strncpy(typeResult, "arial", FONTLENGTH);
               break;
          case T_COURIER:
               strncpy(typeResult, "courier", FONTLENGTH);
               break;
          case T_COURIERNEW:
               strncpy(typeResult, "courier new", FONTLENGTH);
               break;
          case T_FIXEDSYS:
               strncpy(typeResult, "fixedsys", FONTLENGTH);
               break;
          case T_SYSTEM:
               strncpy(typeResult, "system", FONTLENGTH);
               break;               
          case T_TAHOMA:
               strncpy(typeResult, "tahoma", FONTLENGTH);
               break;               
          case T_TIMES:
               strncpy(typeResult, "times new roman", FONTLENGTH);
               break;
          case T_TERMINAL:
               strncpy(typeResult, "terminal", FONTLENGTH);
               break;
          case T_VERDANA:
               strncpy(typeResult, "verdana", FONTLENGTH);
     }

     return typeResult;

}// end getFontType()


// displays dashed line
void divider()
{
     cout << setw(IGNORELEN) << setfill('-') << "-" << setfill(' ');
}// end divider()


// displays header block for current operation
void displayHeader(char str[])
{
     divider();
     cout << " " << str << endl;
     divider();

}// end displayHeader()


// displays character string as message to user
void displayMessage(char str[])
{
     cout << " " << str << endl;

}// end displayMessage()


// displays character string as prompt to user
void displayPrompt(char str[])
{
     cout << endl <<  " " << str;

}// end displayPrompt()


// pauses execution for user readability
void pause(char str[])
{
     cout << endl;
     displayMessage(str);
     getch();

}// end pause()

Rendered using: CPP2HTM Builder -- http://warebiz.tripod.com/