开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
FreeBurn.cpp
资源名称：freeburn-oldsource-unofficial.zip　[点击查看]
上传用户：cnxinhai
上传日期：2013-08-06
资源大小：265k
文件大小：93k
源码类别：

DVD

开发平台：

Visual C++

FreeBurn.cpp：源码内容
  1. /* This is the main class definition for the FreeBurn application,
  2.  * including methods and program layout.
  3.  *
  4.  * Copyright (C) 2001, 2002  Adam Schlag
  5.  */
  6. /*
  7.  * FreeBurn Software License
  8.  * (based on the Apache Software License)
  9.  * 
  10.  * Version 1.1
  11.  * 
  12.  * Copyright (c) 2001, 2002 The FreeBurn Project. All rights reserved.
  13.  * 
  14.  * Redistribution and use in source and binary forms, with or without 
  15.  * modification, are permitted provided that the following conditions are met:
  16.  * 
  17.  * 1. Redistributions of source code must retain the above copyright 
  18.  * notice, this list of conditions and the following disclaimer.
  19.  * 
  20.  * 2. Redistributions in binary form must reproduce the above copyright 
  21.  * notice, this list of conditions and the following disclaimer in the 
  22.  * documentation and/or other materials provided with the distribution.
  23.  * 
  24.  * 3. The end-user documentation included with the redistribution, if any, must 
  25.  * include the following acknowledgment:
  26.  * 
  27.  *  "This product includes software developed by the FreeBurn 
  28.  *     Project (http://freeburn.sourceforge.net/)."
  29.  * 
  30.  * Alternately, this acknowledgment may appear in the software itself, 
  31.  * if and wherever such third-party acknowledgments normally appear.
  32.  * 
  33.  * 4. The names "FreeBurn" and "FreeBurn Project" must not be 
  34.  * used to endorse or promote products derived from this software 
  35.  * without prior written permission. For written permission, please 
  36.  * contact aschlag@users.sourceforge.net.
  37.  * 
  38.  * 5. Products derived from this software may not be called "FreeBurn", 
  39.  * nor may "FreeBurn" appear in their name, without prior written 
  40.  * permission of the FreeBurn Project.
  41.  * 
  42.  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED 
  43.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 
  44.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  45.  * DISCLAIMED. IN NO EVENT SHALL THE FREEBURN PROJECT OR ITS 
  46.  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  47.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
  48.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF 
  49.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 
  50.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
  51.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 
  52.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
  53.  * SUCH DAMAGE.
  54.  * 
  55.  * This software consists of voluntary contributions made by many 
  56.  * individuals on behalf of the FreeBurn Project. For more 
  57.  * information on the FreeBurn Project and FreeBurn, please see 
  58.  * <http://freeburn.sourceforge.net/>.
  59.  * 
  60.  * This software is distributed with software that is released under the GNU 
  61.  * General Public License (GPL).  You can find the terms of this license in the
  62.  * file GPL.txt distributed in this package.  You can find information on the
  63.  * software distributed with this package in the file PROGRAMS.txt.
  64.  */
  65. // The main FOX include file, and the PNG Icon include file (it's not in fx.h)
  66. #include <fx.h>
  67. #include <FXPNGIcon.h>
  68. #include "fbspinner.h"
  69. #ifdef WIN32
  70. #include <windows.h>
  71. #endif
  73. // Application include files go here
  75. // the main freeburn definition class and additional
  76. // helper and gui classes go here
  77. #include "FreeburnDefs.h"
  78. #include "FreeburnText.h"
  79. #include "FreeburnHelpText.h"
  80. #ifndef FREEBURN_ICONS_H
  81. #include "FreeburnIcons.h"
  82. #define FREEBURN_ICONS_H
  83. #endif
  84. #include "FreeburnHelper.h"
  86. // these contain the classes for the disc and track layouts,
  87. // and their helper and utility methods
  88. #include "FreeburnTrack.h"
  89. #include "FreeburnDisc.h"
  91. // these contain the includes for the various dialog classes
  92. #include "FreeburnNewDiscDialog.h"
  93. #include "FreeburnBurnDiscDialog.h"
  94. #include "FreeburnDiscImageDialog.h"
  95. #include "FreeburnCommandDialog.h"
  96. #include "FreeburnPreferences.h"
  97. #include "FreeburnGlobalTextDialog.h"
  98. #include "FreeburnTrackDialog.h"
  99. #include "HelpWindow.h"
  100. #include "FreeburnAbout.h"
  102. // these contain the system-level process and threading classes
  103. #include "FreeburnSystem.h"
  105. // finally, the main freeburn include header
  106. #include "FreeBurn.h"
  108. // Message Map for FreeBurn class
  109. FXDEFMAP(CFreeBurn) CFreeBurnMap[]={
  111.     //________Message_Type_______________ID_______________________Message_Handler___________
  112.     
  113.     // These are for the thread events to process the output of external commands
  114.     FXMAPFUNC(SEL_IO_EXCEPT, CFreeBurn::ID_GET_THREAD_BUFFER, CFreeBurn::getThreadBuffer),
  115.     FXMAPFUNC(SEL_IO_EXCEPT, CFreeBurn::ID_THREAD_COMPLETE,   CFreeBurn::threadComplete),    
  116.     
  117.     // These are for handling messages to change the application colors
  118.     FXMAPFUNCS(SEL_COMMAND,  CFreeBurn::ID_BASECOLOR,
  119.                              CFreeBurn::ID_BORDCOLOR,         CFreeBurn::onCmdColor),
  120.     FXMAPFUNCS(SEL_CHANGED,  CFreeBurn::ID_BASECOLOR,
  121.                              CFreeBurn::ID_BORDCOLOR,         CFreeBurn::onCmdColor),
  122.     FXMAPFUNCS(SEL_UPDATE,   CFreeBurn::ID_BASECOLOR,
  123.                              CFreeBurn::ID_BORDCOLOR,         CFreeBurn::onUpdColor),
  124.     FXMAPFUNCS(SEL_COMMAND,  CFreeBurn::ID_BASECOLOR_DEFAULT,
  125.                              CFreeBurn::ID_BORDCOLOR_DEFAULT, CFreeBurn::onCmdColorDefault),    
  126.     
  127.     // These are handling messages for commands, updates, etc. for the main program controls
  128.     FXMAPFUNCS(SEL_UPDATE,   CFreeBurn::ID_DISC_SIZE,
  129.                              CFreeBurn::ID_PERCENT_FULL,      CFreeBurn::updMainControls),
  130.     FXMAPFUNC(SEL_CHANGED,   CFreeBurn::ID_CAT_NUM,           CFreeBurn::updCatalogNum),
  131.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_USE_CD_TEXT,       CFreeBurn::cmdUseCdText),
  132.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_EDIT_CD_TEXT,      CFreeBurn::cmdEditCdText),
  133.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_ADD_TRACK,         CFreeBurn::cmdAddTrack),
  134.     FXMAPFUNCS(SEL_COMMAND,  CFreeBurn::ID_AUDIO_TRACK,
  135.                              CFreeBurn::ID_XA_RAW_TRACK,      CFreeBurn::cmdTrackType),
  136.     FXMAPFUNCS(SEL_COMMAND,  CFreeBurn::ID_EDIT_TRACK,
  137.                              CFreeBurn::ID_DELETE_TRACK,      CFreeBurn::cmdModTrackCommand),
  138.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_MODIFY_TRACK,      CFreeBurn::cmdModifyTrack),
  139.     
  140.     // These are handling messages to open the various dialogs and process basic toolbar/menu commands
  141.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_NEW,               CFreeBurn::newDiscLayout),
  142.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_OPEN,              CFreeBurn::openDiscToc),
  143.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_SAVE,              CFreeBurn::saveDiscToc),
  144.     FXMAPFUNC(SEL_UPDATE,    CFreeBurn::ID_SAVE,              CFreeBurn::updSave),
  145.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_CLOSE,             CFreeBurn::closeDiscLayout),
  146.     FXMAPFUNC(SEL_UPDATE,    CFreeBurn::ID_CLOSE,             CFreeBurn::updClose),
  147.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_BURN_CD,           CFreeBurn::burnDisc),
  148.     FXMAPFUNC(SEL_UPDATE,    CFreeBurn::ID_BURN_CD,           CFreeBurn::updBurnDisc),
  149.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_CD_IMAGE,          CFreeBurn::imageDisc),
  150.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_PREFERENCES,       CFreeBurn::editPreferences),
  151.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_HELP,              CFreeBurn::showHelp),
  152.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_HELP_CDRECORD,     CFreeBurn::showHelpCdrecord),
  153.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_HELP_MKISOFS,      CFreeBurn::showHelpMkisofs),
  154.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_HELP_CDRDAO,       CFreeBurn::showHelpCdrdao),
  155.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_ABOUT,             CFreeBurn::aboutFreeburn),    
  156.     
  157.     // these handle messages for the various ways the application can be terminated
  158.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_EXIT,              CFreeBurn::exitApp),
  159.     FXMAPFUNC(SEL_SIGNAL,    CFreeBurn::ID_EXIT,              CFreeBurn::exitApp),
  160.     FXMAPFUNC(SEL_CLOSE,     CFreeBurn::ID_TITLE,             CFreeBurn::exitApp), 
  161.        
  162.     // these handle messages to get or set the values of various settings in the application
  163.     FXMAPFUNC(SEL_COMMAND,   CFreeBurn::ID_ICONTHEME,         CFreeBurn::onCmdIconTheme),
  164.     FXMAPFUNC(SEL_UPDATE,    CFreeBurn::ID_ICONTHEME,         CFreeBurn::onUpdIconTheme),    
  165. };
  167. // Macro for the CFreeBurn class hierarchy implementation
  168. FXIMPLEMENT(CFreeBurn,FXMainWindow,CFreeBurnMap,ARRAYNUMBER(CFreeBurnMap))
  170. // Construct the application window
  171. CFreeBurn::CFreeBurn(FXApp *app):FXMainWindow(app,fbAppTitle,NULL,NULL,DECOR_ALL,FB_XPOS,FB_YPOS,FB_WIDTH,FB_HEIGHT,0,0)
  172. {
  173.     // Setup any class variables
  174.     readThemeSettings();
  175.     m_programToExecute = TRACK_AT_ONCE;
  176.     m_programToExecuteDataTarget.connect(m_programToExecute);
  177.     m_discExists = FALSE;
  178.     m_discSaved  = TRUE;
  179.     m_trackAddType    = 0;
  180.     m_modTrackCommand = 0;
  181.     
  182.     // set up the system process/threading class
  183.     m_SystemClass          = new CFreeburnSystem();
  184.     m_ReadOutputHandle     = m_SystemClass->getProcessEventHandle();
  185.     m_ThreadCompleteHandle = m_SystemClass->getCompleteEventHandle();
  186.     
  187.     // setup mkisofs string (thanks microsoft...)
  188. FXString mkisofsString;
  189. mkisofsString.append(fbHelpMkisofsText);
  190. mkisofsString.append(fbHelpMkisofsText2);
  191.     
  192.     // set up the help windows
  193.     m_HelpWindow         = new HelpWindow(this, fbHelpText,           fbHelpTitleText,         FALSE);
  194.     m_CdrecordHelpWindow = new HelpWindow(this, fbHelpCdrecordText,   fbHelpCdrecordTitleText, TRUE);
  195.     m_MkisofsHelpWindow  = new HelpWindow(this, mkisofsString.text(), fbHelpMkisofsTitleText,  TRUE);
  196.     m_CdrdaoHelpWindow   = new HelpWindow(this, fbHelpCdrdaoText,     fbHelpCdrdaoTitleText,   TRUE);
  197.     
  198.     // Load the icons for use
  199.     loadThemeIcons();
  200.     setThemeIcons();
  201.     m_bigIcon   = new FXPNGIcon(getApp(), fbicon_big_png);
  202.     m_smallIcon = new FXPNGIcon(getApp(), fbicon_small_png);
  203.     
  204.     // Set the application icons
  205.     setIcon(m_bigIcon);
  206.     setMiniIcon(m_smallIcon);
  208.     // Make main window; set myself as the target
  209.     setTarget(this);
  210.     setSelector(ID_TITLE);
  212.     // Setup the m_menuBar
  213.     FXToolbarShell* menuBarShell = new FXToolbarShell(this, FRAME_RAISED|FRAME_THICK);
  214.     m_menuBar = new FXMenubar(this, menuBarShell, LAYOUT_SIDE_TOP|LAYOUT_FILL_X);
  215.     m_menuBarGrip = new FXToolbarGrip(m_menuBar, m_menuBar, FXMenubar::ID_TOOLBARGRIP, TOOLBARGRIP_DOUBLE);
  216.     
  217.     // populate the menubar with some menus
  218.     setupProgramMenus();
  220.     // Setup the m_toolBar
  221.     FXToolbarShell* toolBarShell = new FXToolbarShell(this,FRAME_RAISED|FRAME_THICK);
  222.     m_toolBar     = new FXToolbar(this, toolBarShell, 
  223.         LAYOUT_SIDE_TOP|LAYOUT_FILL_X|PACK_UNIFORM_HEIGHT);
  224.     m_toolBarGrip = new FXToolbarGrip(m_toolBar,m_toolBar,FXToolbar::ID_TOOLBARGRIP,TOOLBARGRIP_DOUBLE);
  225.     
  226.     // populate the toolbar with its buttons
  227.     setupToolBar();
  229.     // Setup the status bar
  230.     m_statusBar = new FXStatusbar(this, LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|STATUSBAR_WITH_DRAGCORNER);
  232.     // Set up the main content frame and populate it with controls
  233.     setupContentFrame();
  234.   
  235.     // Make a tool tip
  236.     new FXTooltip(getApp(), 0);
  237. }
  239. // FreeBurn destructor
  240. CFreeBurn::~CFreeBurn()
  241. {
  242.     // here we delete the widgets and other data that need to
  243.     // be deleted explicitly, in a semi-logical order in the 
  244.     // reverse of the application's creation.  The memory
  245.     // allocated from the disc layout should already be closed
  246.     // from the closeDisc method.
  247.     
  248.     delete m_HelpWindow;
  249.     delete m_CdrecordHelpWindow;
  250.     delete m_MkisofsHelpWindow;
  251.     delete m_CdrdaoHelpWindow;   
  252.     
  253.     delete m_DefaultNewIcon;
  254.     delete m_DefaultOpenIcon;
  255.     delete m_DefaultSaveIcon;
  256.     delete m_DefaultCloseIcon;
  257.     delete m_DefaultBurnCdIcon;
  258.     delete m_DefaultCdImageIcon;
  259.     delete m_DefaultPreferencesIcon;
  260.     delete m_DefaultHelpIcon;
  261.     delete m_DefaultExitIcon;
  262.     delete m_DefaultThemePreviewIcon;
  263.     delete m_DefaultFindIcon;
  264.     
  265.     delete m_GnomeNewIcon;
  266.     delete m_GnomeOpenIcon;
  267.     delete m_GnomeSaveIcon;
  268.     delete m_GnomeCloseIcon;
  269.     delete m_GnomeBurnCdIcon;
  270.     delete m_GnomeCdImageIcon;
  271.     delete m_GnomePreferencesIcon;
  272.     delete m_GnomeHelpIcon;
  273.     delete m_GnomeExitIcon;
  274.     delete m_GnomeThemePreviewIcon;
  275.     delete m_GnomeFindIcon;
  276.     
  277.     delete m_KdeNewIcon;
  278.     delete m_KdeOpenIcon;
  279.     delete m_KdeSaveIcon;
  280.     delete m_KdeCloseIcon;
  281.     delete m_KdeBurnCdIcon;
  282.     delete m_KdeCdImageIcon;
  283.     delete m_KdePreferencesIcon;
  284.     delete m_KdeHelpIcon;
  285.     delete m_KdeExitIcon;
  286.     delete m_KdeThemePreviewIcon;
  287.     delete m_KdeFindIcon;
  288.     
  289.     delete m_XpNewIcon;
  290.     delete m_XpOpenIcon;
  291.     delete m_XpSaveIcon;
  292.     delete m_XpCloseIcon;
  293.     delete m_XpBurnCdIcon;
  294.     delete m_XpCdImageIcon;
  295.     delete m_XpPreferencesIcon;
  296.     delete m_XpHelpIcon;
  297.     delete m_XpExitIcon;
  298.     delete m_XpThemePreviewIcon;
  299.     delete m_XpFindIcon;
  300.     
  301.     delete m_bigIcon;
  302.     delete m_smallIcon;
  303.     
  304.     delete m_toolBar;
  306.     delete m_fileMenu;
  307.     delete m_optionsMenu;
  308.     delete m_helpMenu;
  309.     delete m_menuBar;
  310. } 
  312. // Create and initialize 
  313. void CFreeBurn::create(){
  315.     // read the program settings from the registry
  316.     readProgramSettings();
  318.     // Create the windows
  319.     FXMainWindow::create();
  320.   
  321.     // Make the main window appear
  322.     show(PLACEMENT_VISIBLE);
  323. }
  325. // method to run to create a new disc layout in the program
  326. long CFreeBurn::newDiscLayout(FXObject*, FXSelector, void*)
  327. {
  328.     // if the layout isn't saved, then ask if the user wants
  329.     // to save the layout
  330.     if (!m_discSaved)
  331.     {
  332.         if(!saveChanges()) return 1;
  333.     }
  334.     
  335.     // close the current disc layout
  336.     closeDisc();
  337.     
  338.     // initialize variables to hold the information about creating the disc
  339.     FXint discSize = _74_650_DISC;
  340.     FXint discType = CD_DA;
  341.     
  342.     // initialize data targets for the disc initialization variables
  343.     FXDataTarget discSizeTarget;
  344.     discSizeTarget.connect(discSize);
  345.     FXDataTarget discTypeTarget;
  346.     discTypeTarget.connect(discType);
  347.     
  348.     // Create an instance of the create disc dialog
  349.     CFreeburnNewDiscDialog newDiscDialog(this, &discSizeTarget, &discTypeTarget);
  350.     
  351.     // run the dialog
  352.     if (newDiscDialog.execute(PLACEMENT_OWNER))
  353.     {
  354.         // create the disc class if the dialog returns TRUE, and set
  355.         // the discExists and discSaved flags to TRUE.
  356.         m_mainDisc   = new CFreeburnDisc(discSize, discType);
  357.         m_discExists = TRUE;
  358.         m_discSaved  = FALSE;
  359.         
  360.         // set the track option menu
  361.         switch(discType)
  362.         {
  363.             case CD_DA:
  364.                 m_trackOptions->setPopup(m_cddaPopup);
  365.                 // set the default track type for this disc type
  366.                 m_trackAddType = AUDIO;
  367.                 break;
  368.             case CD_ROM:
  369.                 m_trackOptions->setPopup(m_cdromPopup);
  370.                 // set the default track type for this disc type
  371.                 m_trackAddType = MODE_1;
  372.                 break;
  373.             case CDROM_XA:
  374.                 m_trackOptions->setPopup(m_cdxaPopup);
  375.                 // set the default track type for this disc type
  376.                 m_trackAddType = AUDIO;
  377.                 break;
  378.         }
  379.      }
  380.         
  381.     return 1;
  382. }
  384. // method to run to open a .toc file
  385. long CFreeBurn::openDiscToc(FXObject*, FXSelector, void*)
  386. {
  387.     // if the layout isn't saved, then ask if the user wants
  388.     // to save the layout
  389.     if (!m_discSaved)
  390.     {
  391.         if(!saveChanges()) return 1;
  392.     }
  393.     
  394.     FXMessageBox::information(this,MBOX_OK|PLACEMENT_CURSOR,"Open TOC",
  395.         "Open TOC not yet fully implemented.");
  396.     
  397.     return 1;
  398. }
  400. // method to run to save a .toc file
  401. long CFreeBurn::saveDiscToc(FXObject*, FXSelector, void*)
  402. {
  403.     FXMessageBox::information(this,MBOX_OK|PLACEMENT_CURSOR,"Save TOC",
  404.         "Save TOC not yet fully implemented.");
  405.         
  406.     m_discSaved = TRUE;
  407.     
  408.     return 1;
  409. }
  411. // method to enable/disable the save buttons/commands if they are not needed
  412. long CFreeBurn::updSave(FXObject* sender, FXSelector, void* ptr)
  413. {
  414.     FXuint msg = (m_discExists && !m_discSaved) ? FXWindow::ID_ENABLE : FXWindow::ID_DISABLE;
  415.     
  416.     sender->handle(this, MKUINT(msg,SEL_COMMAND), ptr);
  417.     
  418.     return 1;
  419. }
  421. // method to close the current disc layout
  422. long CFreeBurn::closeDiscLayout(FXObject*, FXSelector, void*)
  423. {
  424.     // if the layout isn't saved, then ask if the user wants
  425.     // to save the layout
  426.     if (!m_discSaved)
  427.     {
  428.         if(!saveChanges()) return 1;
  429.     }
  430.     
  431.     // close the current disc layout
  432.     closeDisc();
  433.     
  434.     return 1;
  435. }
  437. // method to enable/disable the close commands if they are not needed
  438. long CFreeBurn::updClose(FXObject* sender, FXSelector, void* ptr)
  439. {
  440.     FXuint msg = m_discExists ? FXWindow::ID_ENABLE : FXWindow::ID_DISABLE;
  441.     
  442.     sender->handle(this, MKUINT(msg,SEL_COMMAND), ptr);
  443.     
  444.     return 1;
  445. }
  447. // method to run when the burn disc command is executed
  448. long CFreeBurn::burnDisc(FXObject*, FXSelector, void*)
  449. {
  450.     m_programToExecute = TRACK_AT_ONCE;
  451.     m_useUnixShell     = FALSE;
  452.     m_commandLineOptions.clear();
  453.     
  454.     CFreeburnBurnDiscDialog burnDialog(this, &m_programToExecuteDataTarget);
  455.     
  456.     burnDialog.setHelpIcon(m_helpIcon);
  457.     burnDialog.setCommandString(m_commandLineOptions);
  458.     burnDialog.setShellFlag(m_useUnixShell);
  459.     
  460.     if (burnDialog.execute(PLACEMENT_OWNER))
  461.     {
  462.         m_commandLineOptions = burnDialog.getCommandString();
  463.         m_useUnixShell       = burnDialog.getShellFlag();
  464.         runProgram();
  465.     }
  466.     
  467.     return 1;
  468. }
  470. // method to enable/disable the burn disc command if they are not needed
  471. long CFreeBurn::updBurnDisc(FXObject* sender, FXSelector, void* ptr)
  472. {
  473.     FXuint msg = m_discExists ? FXWindow::ID_ENABLE : FXWindow::ID_DISABLE;
  474.     
  475.     sender->handle(this, MKUINT(msg,SEL_COMMAND), ptr);
  476.     
  477.     return 1;
  478. }
  480. // method to run when the image disc command is executed
  481. long CFreeBurn::imageDisc(FXObject*, FXSelector, void*)
  482. {
  483.     m_programToExecute = RUN_MKISOFS;
  484.     m_useUnixShell     = FALSE;
  485.     m_commandLineOptions.clear();
  486.     
  487.     CFreeburnDiscImageDialog imageDialog(this);
  488.     
  489.     imageDialog.setHelpIcon(m_helpIcon);
  490.     imageDialog.setCommandString(m_commandLineOptions);
  491.     imageDialog.setShellFlag(m_useUnixShell);
  492.     
  493.     if (imageDialog.execute(PLACEMENT_OWNER))
  494.     {
  495.         m_commandLineOptions = imageDialog.getCommandString();
  496.         m_useUnixShell       = imageDialog.getShellFlag();
  497.         runProgram();
  498.     }
  499.     
  500.     return 1;
  501. }
  503. // method to run to execute an external program and set up the necessary
  504. // data and objects needed to start the program
  505. void CFreeBurn::runProgram()
  506. {
  507.     // First, set up the command line string
  508.     FXString programString;
  509.     FXString commandString;
  510.     
  511.     // assign programString to the program the user wants 
  512.     // to execute (cdrecord, cdrdao, or mkisofs)
  513.     switch(m_programToExecute)
  514.     {
  515.         case RUN_CDRECORD:
  516.             programString = m_cdrecordPath;
  517.             break;
  518.         case RUN_CDRDAO:
  519.             programString = m_cdrdaoPath;
  520.             break;
  521.         case RUN_MKISOFS:
  522.             programString = m_mkisofsPath;
  523.             break;
  524.     }
  525.     
  526.     // make sure the program exists first...if not, show an error and exit
  527.     // the method so we don't get errors running FreeBurn.
  528.     if (!(FXFile::exists(programString)))
  529.     {
  530.         FXMessageBox::error(this,MBOX_OK|PLACEMENT_OWNER,fbCmdNotExistTitleText,
  531.         fbCmdNotExistMessageText, FXFile::name(programString), programString);
  532.         
  533.         return;
  534.     }
  535.     
  536.     if (m_useUnixShell) // set up the command to execute through the UNIX shell
  537.     {
  538.         // make sure that the unix shell program exists first...
  539.         if (!(FXFile::exists(m_shellPath)))
  540.         {
  541.             FXMessageBox::error(this,MBOX_OK|PLACEMENT_OWNER,fbCmdNotExistTitleText,
  542.             fbCmdNotExistMessageText, FXFile::name(m_shellPath), m_shellPath);
  543.         
  544.             return;
  545.         }
  546.         commandString = m_shellPath;
  547.         FXString unixCommand;
  548.         FreeburnHelper::winPathToUnixPath(programString, unixCommand);
  549.         commandString.append(SHELL_COMMAND);
  550.         commandString.append(QUOTE);
  551.         commandString.append(unixCommand);
  552.         commandString.append(SPACE);
  553.         commandString.append(m_commandLineOptions);
  554.         commandString.append(QUOTE);
  555.     }
  556.     else                // set up the command to execute as it is
  557.     {
  558.         commandString = programString;
  559.         commandString.append(SPACE);
  560.         commandString.append(m_commandLineOptions);
  561.     }
  562.     
  563.     // create the command dialog
  564.     CFreeburnCommandDialog commandDialog(this);
  565.     m_CommandDialog = &commandDialog;
  566.         
  567.     // set the save icon for the dialog
  568.     commandDialog.setSaveIcon(m_SaveIcon);
  569.     
  570.     // set the text of the command to execute
  571.     commandDialog.setCommandLabelText(commandString);
  572.     
  573.     // send the command out to run
  574.     FXint returnValue; // returnValue is used to see if there is an error sending the command
  575.     returnValue = m_SystemClass->createCommandWithPipes(commandString);
  577.     // if the return value from createCommandWithPipes is anything but
  578.     // 0, there is an error.  The error number will give us a hint as to
  579.     // where the error occured.  This is the only place where we will use
  580.     // a string that isn't from one of the [CLASSNAME]Text files, since
  581.     // we are only using this for error purposes, and there probably won't
  582.     // ever be an error
  583.     if (returnValue != 0)
  584.     {
  585.         FXMessageBox::error(this,MBOX_OK|PLACEMENT_OWNER,fbCmdErrorTitleText,
  586.         fbCmdErrorMessageText, returnValue);
  588.         commandDialog.outputComplete();
  589.         m_CommandDialog = NULL;
  590.         
  591.         return;
  592.     }
  594.     // execute the dialog to display the command output
  595.     commandDialog.execute(PLACEMENT_OWNER);
  596.     
  597. }
  599. // method to run when we receive a message from the thread that 
  600. // is catching command output that it has a string for us to read
  601. long CFreeBurn::getThreadBuffer(FXObject*, FXSelector, void*)
  602. {
  603.     FXString outputString;
  604.     
  605.     m_SystemClass->getStringText(outputString);
  606.     
  607.     m_CommandDialog->sendOutputText(outputString);
  608.     
  609.     return 1;
  610. }
  612. // method to run when we receive a message from the thread that
  613. // is catching command output that is is finished reading output
  614. long CFreeBurn::threadComplete(FXObject*, FXSelector, void*)
  615. {
  616.     m_CommandDialog->outputComplete();
  617.     
  618.     m_CommandDialog = NULL;
  619.     
  620.     return 1;
  621. }    
  623. // method to run when the properties command is executed
  624. long CFreeBurn::editPreferences(FXObject*, FXSelector, void*)
  625. {
  626.     // setup local method variables so we can revert to the old
  627.     // values in case the dialog is cancelled
  628.     FXString tempShellPath    = m_shellPath;
  629.     FXString tempCdrecordPath = m_cdrecordPath;
  630.     FXString tempMkisofsPath  = m_mkisofsPath;
  631.     FXString tempCdrdaoPath   = m_cdrdaoPath;    
  632.     FXint    tempThemeValue   = m_theme;
  633.     FXColor  tempBaseColor    = getBaseColor();
  634.     FXColor  tempBackColor    = getBackgroundColor();
  635.     FXColor  tempForeColor    = getForegroundColor();
  636.     FXColor  tempBordColor    = getBorderColor();
  637.     
  638.     // show the prefs dialog
  639.     CFreeburnPreferences prefsDialog(this, m_theme);
  640.     
  641.     // set the command line strings for the programs
  642.     prefsDialog.setShellString(m_shellPath);
  643.     prefsDialog.setCdrecordString(m_cdrecordPath);
  644.     prefsDialog.setMkisofsString(m_mkisofsPath);
  645.     prefsDialog.setCdrdaoString(m_cdrdaoPath);
  646.     
  647.     // set the icon to use for the find button
  648.     prefsDialog.setFindIcon(m_FindIcon);
  649.     
  650.     // get the preview label from the prefs dialog
  651.     m_PreviewLabel = prefsDialog.getPreviewLabel();
  652.     // set the preview icon
  653.     m_PreviewLabel->setIcon(m_ThemePreviewIcon);
  654.     
  655.     // if the dialog returns false (cancel), then set the path
  656.     // strings and app colors back to what they were
  657.     if (prefsDialog.execute(PLACEMENT_OWNER))   // change anything that is different
  658.     {
  659.         // get the program strings
  660.         m_shellPath    = prefsDialog.getShellString();
  661.         m_cdrecordPath = prefsDialog.getCdrecordString();
  662.         m_mkisofsPath  = prefsDialog.getMkisofsString();
  663.         m_cdrdaoPath   = prefsDialog.getCdrdaoString();
  664.         
  665.         if (m_theme != tempThemeValue) // The icon theme is changed...
  666.         {
  667.             // change the theme icons for the toolbar buttons
  668.             changeToolBarIcons();
  669.             
  670.             // change the theme icons for the menu panes
  671.             changeMenuIcons();            
  672.         }
  673.     }
  674.     else // dialog was cancelled, so don't make any changes
  675.     {
  676.         m_shellPath      = tempShellPath;
  677.         m_cdrecordPath   = tempCdrecordPath;
  678.         m_mkisofsPath    = tempMkisofsPath;
  679.         m_cdrdaoPath     = tempCdrdaoPath;
  680.         m_theme          = tempThemeValue;
  681.         setBaseColor      (tempBaseColor);
  682.         setBackgroundColor(tempBackColor);
  683.         setForegroundColor(tempForeColor);
  684.         setBorderColor    (tempBordColor);
  685.         // revert the icons back to the proper theme
  686.         setThemeIcons();        
  687.     }
  688.     
  689.     // the application (for some reason) gets sent back at times
  690.     // when colors change, so let's raise the app back to the top
  691.     raise();
  692.     
  693.     return 1;
  694. }
  696. // method to run when the help command is executed
  697. long CFreeBurn::showHelp(FXObject*, FXSelector, void*)
  698. {
  699.     m_HelpWindow->execute(PLACEMENT_OWNER);
  700.     
  701.     return 1;
  702. }
  704. // method to run to show the cdrecord man page help window
  705. long CFreeBurn::showHelpCdrecord (FXObject*, FXSelector, void*)
  706. {
  707.     m_CdrecordHelpWindow->execute(PLACEMENT_OWNER);
  708.     
  709.     return 1;
  710. }
  712. // method to run to show the mkisofs man page help window
  713. long CFreeBurn::showHelpMkisofs  (FXObject*, FXSelector, void*)
  714. {
  715.     m_MkisofsHelpWindow->execute(PLACEMENT_OWNER);
  716.     
  717.     return 1;
  718. }
  720. // method to run to show the cdrdao man page help window
  721. long CFreeBurn::showHelpCdrdao   (FXObject*, FXSelector, void*)
  722. {
  723.     m_CdrdaoHelpWindow->execute(PLACEMENT_OWNER);
  724.     
  725.     return 1;
  726. }
  728. // method to run when the exit command is executed
  729. long CFreeBurn::exitApp(FXObject*, FXSelector, void*)
  730. {
  731.     // if the layout isn't saved, then ask if the user wants
  732.     // to save the layout
  733.     if (!m_discSaved)
  734.     {
  735.         if(!saveChanges()) return 1;
  736.     }
  737.     
  738.     // save program settings to the registry
  739.     writeProgramSettings();
  740.     
  741.     // exit the application
  742.     getApp()->exit(0);
  744.     return 1;
  745. }
  747. // method to run when about command is executed
  748. long CFreeBurn::aboutFreeburn (FXObject*, FXSelector, void*)
  749. {
  750.     // show the about dialog
  751.     CFreeburnAbout aboutDialog(this);
  752.     aboutDialog.execute(PLACEMENT_OWNER);
  753.     
  754.     return 1;
  755. }
  757. // method to handle setting the theme value
  758. long CFreeBurn::onCmdIconTheme(FXObject* sender, FXSelector, void*)
  759. {
  760.     FXint theme;
  761.     sender->handle(this, MKUINT(ID_GETINTVALUE,SEL_COMMAND), (void*)&theme);
  762.     m_theme = theme;
  763.     
  764.     // load the icons for the new theme
  765.     setThemeIcons();
  766.             
  767.     // set the new preview icon
  768.     m_PreviewLabel->setIcon(m_ThemePreviewIcon);
  770.     return 1;
  771. }
  774. // method to handle getting the theme value
  775. long CFreeBurn::onUpdIconTheme(FXObject* sender, FXSelector, void*)
  776. {
  777.     FXint theme = m_theme;
  778.     sender->handle(this,MKUINT(ID_SETINTVALUE,SEL_COMMAND),(void*)&theme);
  779.     
  780.     return 1;
  781. }
  783. // method to handle updating the main window controls
  784. long CFreeBurn::updMainControls(FXObject*, FXSelector sel, void*)
  785. {
  786.     FXString spaceString;
  787.     
  788.     // fisrt, determine if the disc exists or not
  789.     if (m_discExists)
  790.     {
  791.         // the disc exists, so switch on the selector
  792.         switch(SELID(sel))
  793.         {
  794.             case ID_DISC_SIZE:
  795.                 // disc exists, so set the text of the disc and make
  796.                 // sure the widget is enabled.
  797.                 m_sizeField->enable();
  798.                 
  799.                 // now, set the field to the specify the size
  800.                 // of the disc
  801.                 switch(m_mainDisc->discSizeType())
  802.                 {
  803.                     case _74_650_DISC:
  804.                         m_sizeField->setText(fb74650DiscText);
  805.                         break;
  806.                     case _80_700_DISC:
  807.                         m_sizeField->setText(fb80700DiscText);
  808.                         break;
  809.                 }
  810.                 
  811.                 break;
  812.             case ID_DISC_TYPE:
  813.                 // disc exists, so set the text of the disc and make
  814.                 // sure the widget is enabled.
  815.                 m_typeField->enable();
  816.                 
  817.                 // now, set the field to the specify the size
  818.                 // of the disc
  819.                 switch(m_mainDisc->discType())
  820.                 {
  821.                     case CD_DA:
  822.                         m_typeField->setText(fbAudioDiscText);
  823.                         break;
  824.                     case CD_ROM:
  825.                         m_typeField->setText(fbCdRomDiscText);
  826.                         break;
  827.                     case CDROM_XA:
  828.                         m_typeField->setText(fbCdRomXaDiscText);
  829.                         break;
  830.                 }
  831.                 
  832.                 break;
  833.             case ID_CAT_NUM:
  834.                 // disc exists, so set enable the widget
  835.                 m_catalogField->enable();
  836.                 
  837.                 break;
  838.             case ID_USE_CD_TEXT:
  839.                 // disc exists, so set enable the widget
  840.                 m_cdTextButton->enable();
  841.                 
  842.                 break;
  843.             case ID_EDIT_CD_TEXT:
  844.                 // now check if CD Text is enabled first.
  845.                 if (m_mainDisc->usingCdText())
  846.                     // CD Text is on, so set enable the widget
  847.                     m_editTextBut->enable();
  848.                 else
  849.                     // CD Text is disabled, so disable the edit 
  850.                     // CD Text button
  851.                     m_editTextBut->disable();
  852.                 
  853.                 break;
  854.             case ID_TRACK_TYPE:
  855.                 // check if the max track number is reached yet.
  856.                 if (m_mainDisc->trackCount() >= MAX_CD_TRACKS)
  857.                     m_trackOptions->disable();
  858.                 else
  859.                     m_trackOptions->enable();
  860.                 
  861.                 break;
  862.             case ID_ADD_TRACK:
  863.                 // check if the max track number is reached yet.
  864.                 if (m_mainDisc->trackCount() >= MAX_CD_TRACKS)
  865.                     m_addTrackBut->disable();
  866.                 else
  867.                     m_addTrackBut->enable();
  868.                 
  869.                 break;
  870.             case ID_MODIFY_TRACK_OPT:
  871.                 // also check if there are any tracks on the disc
  872.                 if (m_mainDisc->trackCount() >= 1)
  873.                     m_modTrackOpts->enable();
  874.                 else
  875.                     m_modTrackOpts->disable();
  876.                 
  877.                 break;
  878.             case ID_TRACK_NUM:
  879.                 // enable if there are any tracks on the disc
  880.                 if (m_mainDisc->trackCount() >= 1)
  881.                     m_modTrackNum->enable();
  882.                 else
  883.                     m_modTrackNum->disable();
  884.                 
  885.                 break;
  886.             case ID_MODIFY_TRACK:
  887.                 // enable if there are any tracks on the disc
  888.                 if (m_mainDisc->trackCount() >= 1)
  889.                     m_modTrackBut->enable();
  890.                 else
  891.                     m_modTrackBut->disable();
  892.                     
  893.                 break;
  894.             case ID_USED_SPACE:
  895.                 // set the used space to the space (in blocks) used on the disc
  896.                 m_usedSpaceField->enable();
  897.                 
  898.                 spaceString.format("%d", m_mainDisc->discCurrentSize());
  899.                 m_usedSpaceField->setText(spaceString);
  900.                 
  901.                 break;
  902.             case ID_FREE_SPACE:
  903.                 // set the free space to the space (in blocks) free on the disc
  904.                 m_freeSpaceField->enable();
  905.                 
  906.                 spaceString.format("%d", m_mainDisc->discFreeSpace());
  907.                 m_freeSpaceField->setText(spaceString);
  908.                 
  909.                 break;
  910.             case ID_PERCENT_FULL:
  911.                 // update the percent full progress bar for the disc
  912.                 m_percentFull->enable();
  913.                 m_percentFull->setProgress(m_mainDisc->discCurrentSize() / (m_mainDisc->discCurrentSize() + m_mainDisc->discFreeSpace()));
  914.                 
  915.                 break;
  916.         }
  917.     }
  918.     else
  919.     {
  920.         // the disc doesn't exist, switch on the selector
  921.         switch(SELID(sel))
  922.         {
  923.             case ID_DISC_SIZE:
  924.                 // disable the size field, since there is no disc allocated.
  925.                 // also set the text to "" (Or empty) so the field is clear
  926.                 m_sizeField->setText(EMPTY_STRING);
  927.                 m_sizeField->disable();
  928.                 
  929.                 break;
  930.             case ID_DISC_TYPE:
  931.                 // disable the size field, since there is no disc allocated.
  932.                 // also set the text to "" (Or empty) so the field is clear
  933.                 m_typeField->setText(EMPTY_STRING);
  934.                 m_typeField->disable();
  935.                 
  936.                 break;
  937.             case ID_CAT_NUM:
  938.                 // disable the field, since there is no disc allocated.
  939.                 // also set the text to "" (Or empty) so the field is clear
  940.                 m_catalogField->setText(EMPTY_STRING);
  941.                 m_catalogField->disable();
  942.                 
  943.                 break;
  944.             case ID_USE_CD_TEXT:
  945.                 // disable the field, since there is no disc allocated.
  946.                 // also set the text to "" (Or empty) so the field is clear
  947.                 m_cdTextButton->setCheck(FALSE);
  948.                 m_cdTextButton->disable();
  949.                 
  950.                 break;
  951.             case ID_EDIT_CD_TEXT:
  952.                 // disable the field, since there is no disc allocated.
  953.                 // also set the text to "" (or empty) so the field is clear
  954.                 m_editTextBut->disable();
  955.                 
  956.                 break;
  957.             case ID_TRACK_TYPE:
  958.                 // disable the track type option box
  959.                 m_trackOptions->disable();
  960.                 
  961.                 break;
  962.             case ID_ADD_TRACK:
  963.                 // disable the add track button
  964.                 m_addTrackBut->disable();
  965.                 
  966.                 break;
  967.             case ID_MODIFY_TRACK_OPT:
  968.                 // disable the modify track option box
  969.                 m_modTrackOpts->disable();
  970.                 
  971.                 break;
  972.             case ID_TRACK_NUM:
  973.                 // disable the track number spinner
  974.                 m_modTrackNum->disable();
  975.                 
  976.                 break;
  977.             case ID_MODIFY_TRACK:
  978.                 // disable the modify track button
  979.                 m_modTrackBut->disable();
  980.                 
  981.                 break;
  982.             case ID_USED_SPACE:
  983.                 // disable the used space field
  984.                 m_usedSpaceField->setText(EMPTY_STRING);
  985.                 m_usedSpaceField->disable();
  986.                 
  987.                 break;
  988.             case ID_FREE_SPACE:
  989.                 // disable the free space field
  990.                 m_freeSpaceField->setText(EMPTY_STRING);
  991.                 m_freeSpaceField->disable();
  992.                 
  993.                 break;
  994.             case ID_PERCENT_FULL:
  995.                 // disable the percent full progress bar
  996.                 m_percentFull->setProgress(0);
  997.                 m_percentFull->disable();
  998.                 
  999.                 break;
  1000.         }
  1001.     }
  1002.     
  1003.     return 1;
  1004. }
  1006. // method to handle updating the catalog number control
  1007. long CFreeBurn::updCatalogNum(FXObject*, FXSelector, void* ptr)
  1008. {
  1009.     // The catalog number string has changed, so update the disc class
  1010.     // with the new catalog number.
  1011.     m_mainDisc->catalogNumber((FXchar *)ptr);
  1012.     
  1013.     return 1;
  1014. }
  1016. // method to update the use cd text flag
  1017. long CFreeBurn::cmdUseCdText(FXObject*, FXSelector, void*)
  1018. {
  1019.     // set the flag in the disc class for using cd text
  1020.     m_mainDisc->usingCdText(m_cdTextButton->getCheck());
  1021.     
  1022.     return 1;
  1023. }
  1025. // method to edit the global cd text
  1026. long CFreeBurn::cmdEditCdText(FXObject*, FXSelector, void*)
  1027. {
  1028.     // First, back up all the CD Text strings
  1029.     FXString titleString      = m_mainDisc->discTitle();
  1030.     FXString performerString  = m_mainDisc->discPerformer();
  1031.     FXString songwriterString = m_mainDisc->discSongWriter();
  1032.     FXString composerString   = m_mainDisc->discComposer();
  1033.     FXString arrangerString   = m_mainDisc->discArranger();
  1034.     FXString messageString    = m_mainDisc->discMessage();
  1035.     FXString discidString     = m_mainDisc->discId();
  1036.     FXString genreString      = m_mainDisc->discGenre();
  1037.     
  1038.     // Now, create the dialog
  1039.     CFreeburnGlobalTextDialog globalTextDialog(this);
  1040.     
  1041.     // set the property strings in the dialog
  1042.     globalTextDialog.setTitleString(titleString);
  1043.     globalTextDialog.setPerformerString(performerString);
  1044.     globalTextDialog.setSongwriterString(songwriterString);
  1045.     globalTextDialog.setComposerString(composerString);
  1046.     globalTextDialog.setArrangerString(arrangerString);
  1047.     globalTextDialog.setMessageString(messageString);
  1048.     globalTextDialog.setDiscidString(discidString);
  1049.     globalTextDialog.setGenreString(genreString);
  1050.     
  1051.     // execute the dialog
  1052.     if (globalTextDialog.execute(PLACEMENT_OWNER))
  1053.     {
  1054.         m_mainDisc->discTitle(globalTextDialog.getTitleString());
  1055.         m_mainDisc->discPerformer(globalTextDialog.getPerformerString());
  1056.         m_mainDisc->discSongWriter(globalTextDialog.getSongwriterString());
  1057.         m_mainDisc->discComposer(globalTextDialog.getComposerString());
  1058.         m_mainDisc->discArranger(globalTextDialog.getArrangerString());
  1059.         m_mainDisc->discMessage(globalTextDialog.getMessageString());
  1060.         m_mainDisc->discId(globalTextDialog.getDiscidString());
  1061.         m_mainDisc->discGenre(globalTextDialog.getGenreString());
  1062.     }
  1063.     else
  1064.     {
  1065.         // dialog was cancelled, so revert the strings back to what they should be
  1066.         m_mainDisc->discTitle(titleString);
  1067.         m_mainDisc->discPerformer(performerString);
  1068.         m_mainDisc->discSongWriter(songwriterString);
  1069.         m_mainDisc->discComposer(composerString);
  1070.         m_mainDisc->discArranger(arrangerString);
  1071.         m_mainDisc->discMessage(messageString);
  1072.         m_mainDisc->discId(discidString);
  1073.         m_mainDisc->discGenre(genreString);
  1074.     }
  1075.         
  1076.     return 1;
  1077. }
  1079. // method to update the track type to add
  1080. long CFreeBurn::cmdTrackType(FXObject*, FXSelector sel, void*)
  1081. {
  1082.     // to set the track type, first determine what item is set
  1083.     // with a switch, then set to the appropriate type.
  1084.     switch(SELID(sel))
  1085.     {
  1086.         case ID_AUDIO_TRACK:
  1087.             m_trackAddType = AUDIO;
  1088.             break;
  1089.         case ID_DATA_TRACK:
  1090.             m_trackAddType = MODE_1;
  1091.             break;
  1092.         case ID_RAW_TRACK:
  1093.             m_trackAddType = MODE_1_RAW;
  1094.             break;
  1095.         case ID_XA_DATA_TRACK:
  1096.             m_trackAddType = MODE_2_FORM_1;
  1097.             break;
  1098.         case ID_XA_AUDIO_TRACK:
  1099.             m_trackAddType = MODE_2_FORM_2;
  1100.             break;
  1101.         case ID_XA_RAW_TRACK:
  1102.             m_trackAddType = MODE_2_RAW;
  1103.             break;
  1104.     }
  1105.     
  1106.     return 1;
  1107. }
  1109. // method to add a new track to the CD layout
  1110. long CFreeBurn::cmdAddTrack(FXObject*, FXSelector, void*)
  1111. {
  1112.     // create the new track
  1113.     m_mainDisc->createTrack(m_trackAddType);
  1114.     
  1115.     // set the new range for the spinner
  1116.     m_modTrackNum->setRange(MIN_CD_TRACKS, m_mainDisc->trackCount());
  1117.     
  1118.     // set the value in the spinner to the newly created track
  1119.     m_modTrackNum->setValue(m_mainDisc->trackCount());
  1120.     
  1121.     // create the track editor dialog
  1122.     CFreeburnTrackDialog trackDialog(this, m_mainDisc);
  1123.     
  1124.     // execute the dialog
  1125.     trackDialog.execute();
  1126.     
  1127.     return 1;
  1128. }
  1130. // method to change the command for modifying the track
  1131. long CFreeBurn::cmdModTrackCommand(FXObject*, FXSelector sel, void*)
  1132. {
  1133.     // to set the track type, first determine what item is set
  1134.     // with a switch, then set to the appropriate type.
  1135.     switch(SELID(sel))
  1136.     {
  1137.         case ID_EDIT_TRACK:
  1138.             m_modTrackCommand = EDIT_TRACK;
  1139.             break;
  1140.         case ID_DELETE_TRACK:
  1141.             m_modTrackCommand = DELETE_TRACK;
  1142.             break;
  1143.     }
  1144.     
  1145.     return 1;
  1146. }
  1148. // method to modify an existing track of the CD layout
  1149. long CFreeBurn::cmdModifyTrack(FXObject*, FXSelector, void*)
  1150. {
  1151.     if (m_modTrackCommand == EDIT_TRACK)
  1152.     {
  1153.         // set the active track number in the disc class to
  1154.         // the number the user has selected in the dialog
  1155.         m_mainDisc->setActiveTrack(m_modTrackNum->getValue());
  1156.         
  1157.         // create a track editor dialog, then execute it
  1158.         CFreeburnTrackDialog trackDialog(this, m_mainDisc);
  1159.         trackDialog.execute();
  1160.     }
  1161.     else if (m_modTrackCommand == DELETE_TRACK)
  1162.     {            
  1163.         // ask the user if it indeed wants to delete the selected track
  1164.         FXuint answer = FXMessageBox::question(this, MBOX_YES_NO_CANCEL|PLACEMENT_CURSOR,
  1165.             fbDeleteTrackTitleText, fbDeleteTrackMessageText, m_modTrackNum->getValue());
  1166.     
  1167.         // if the answer is yes, try to delete the track
  1168.         if (answer == MBOX_CLICKED_YES)
  1169.         {
  1170.             // Delete the track.  If it's successful, reset the track range.
  1171.             // If it's not, notify the user that the delete was unsuccessful.
  1172.             if (m_mainDisc->deleteTrack(m_modTrackNum->getValue()))
  1173.             {
  1174.                 // set the new range for the spinner
  1175.                 // if the track count is less than MIN_CD_TRACKS, set the range to 0..0
  1176.                 if (m_mainDisc->trackCount() < MIN_CD_TRACKS)
  1177.                     m_modTrackNum->setRange(0, 0);
  1178.                 else
  1179.                     m_modTrackNum->setRange(MIN_CD_TRACKS, m_mainDisc->trackCount());
  1180.             }
  1181.             else
  1182.             {
  1183.                 FXMessageBox::error(this, MBOX_OK|PLACEMENT_CURSOR, fbDeleteTrackErrorTitleText,
  1184.                     fbDeleteTrackErrorMessageText);
  1185.             }
  1186.         }
  1187.     
  1188.     }
  1189.     
  1190.     return 1;
  1191. }
  1193. // method to handle commands for changing the colors of the application
  1194. long CFreeBurn::onCmdColor(FXObject*, FXSelector sel, void* ptr)
  1195. {
  1196.     FXColor color = (FXColor)(long)ptr;
  1197.   
  1198.     // call the proper method based on what was actually selected
  1199.     // and give it the color to update to
  1200.     switch(SELID(sel))
  1201.     {
  1202.         case ID_BASECOLOR: 
  1203.             setBaseColor(color); 
  1204.             break;
  1205.         case ID_BACKCOLOR: 
  1206.             setBackgroundColor(color); 
  1207.             break;
  1208.         case ID_FORECOLOR: 
  1209.             setForegroundColor(color); 
  1210.             break;
  1211.         case ID_BORDCOLOR: 
  1212.             setBorderColor(color); 
  1213.             break;
  1214.     }
  1215.   
  1216.     return 1;
  1217. }
  1219. // Update colors
  1220. long CFreeBurn::onUpdColor(FXObject* sender, FXSelector sel, void*)
  1221. {
  1222.     FXColor color;
  1223.   
  1224.     // get the right color based on what we want to change
  1225.     switch(SELID(sel))
  1226.     {
  1227.         case ID_BASECOLOR: 
  1228.             color = getBaseColor(); 
  1229.             break;
  1230.         case ID_BACKCOLOR: 
  1231.             color = getBackgroundColor(); 
  1232.             break;
  1233.         case ID_FORECOLOR: 
  1234.             color = getForegroundColor(); 
  1235.             break;
  1236.         case ID_BORDCOLOR: 
  1237.             color = getBorderColor(); 
  1238.             break;
  1239.     }
  1240.   
  1241.     // send the color back to whoever asked for it
  1242.     sender->handle(this,MKUINT(ID_SETINTVALUE,SEL_COMMAND),(void*)&color);
  1243.   
  1244.     return 1;
  1245. }
  1247. // method to set the base color for the application (widget colors)
  1248. void CFreeBurn::setBaseColor(FXColor color)
  1249. {
  1250.     // Each setBackColor is followed by a setHiliteColor and
  1251.     // setShadowColor so that everything looks right.  We'll
  1252.     // create variables for these colors so they only need
  1253.     // to be calculated once each time this method is called.
  1254.     FXColor hiliteColor = makeHiliteColor(color);
  1255.     FXColor shadowColor = makeShadowColor(color);
  1256.     
  1257.     // The colors of the widgets are changed in an order where
  1258.     // the stuff the user sees is changed first, so the change
  1259.     // is quicker(the toolbar, statusbar, etc. will be seen 
  1260.     // before a menu pane).  It may not make a difference, but
  1261.     // it may on a slower computer or sometime in the future, so
  1262.     // it doesn't hurt.
  1263.     
  1264.     // First, set the color of the menu bar
  1265.     m_menuBar->setBackColor(color);
  1266.     m_menuBar->setHiliteColor(hiliteColor);
  1267.     m_menuBar->setShadowColor(shadowColor);
  1268.     
  1269.     // Now set the color of the menu bar grip
  1270.     m_menuBarGrip->setBackColor(color);
  1271.     m_menuBarGrip->setHiliteColor(hiliteColor);
  1272.     m_menuBarGrip->setShadowColor(shadowColor);
  1273.     
  1274.     // Now, set the color for the menu titles
  1275.     // The regular back color AND the selected back
  1276.     // color need to be changed so it looks right when
  1277.     // selected and not selected.
  1278.     m_FileMenuTitle->setBackColor(color);
  1279.     m_FileMenuTitle->setSelBackColor(color);
  1280.     m_FileMenuTitle->setHiliteColor(hiliteColor);
  1281.     m_FileMenuTitle->setShadowColor(shadowColor);
  1282.     
  1283.     m_OptionsMenuTitle->setBackColor(color);
  1284.     m_OptionsMenuTitle->setSelBackColor(color);
  1285.     m_OptionsMenuTitle->setHiliteColor(hiliteColor);
  1286.     m_OptionsMenuTitle->setShadowColor(shadowColor);
  1287.     
  1288.     m_HelpMenuTitle->setBackColor(color);
  1289.     m_HelpMenuTitle->setSelBackColor(color);
  1290.     m_HelpMenuTitle->setHiliteColor(hiliteColor);
  1291.     m_HelpMenuTitle->setShadowColor(shadowColor);
  1292.     
  1293.     // The toolbar is next for color change
  1294.     m_toolBar->setBackColor(color);
  1295.     m_toolBar->setHiliteColor(hiliteColor);
  1296.     m_toolBar->setShadowColor(shadowColor);
  1297.     
  1298.     // Now set the color of the toolbar grip
  1299.     m_toolBarGrip->setBackColor(color);
  1300.     m_toolBarGrip->setHiliteColor(hiliteColor);
  1301.     m_toolBarGrip->setShadowColor(shadowColor);
  1302.     
  1303.     // Now do the toolbar buttons
  1304.     m_NewDiscButton->setBackColor(color);
  1305.     m_NewDiscButton->setHiliteColor(hiliteColor);
  1306.     m_NewDiscButton->setShadowColor(shadowColor);
  1307.     
  1308.     m_OpenDiscButton->setBackColor(color);
  1309.     m_OpenDiscButton->setHiliteColor(hiliteColor);
  1310.     m_OpenDiscButton->setShadowColor(shadowColor);
  1311.     
  1312.     m_SaveDiscButton->setBackColor(color);
  1313.     m_SaveDiscButton->setHiliteColor(hiliteColor);
  1314.     m_SaveDiscButton->setShadowColor(shadowColor);
  1315.     
  1316.     m_ToolSeparator1->setBackColor(color);
  1317.     m_ToolSeparator1->setHiliteColor(hiliteColor);
  1318.     m_ToolSeparator1->setShadowColor(shadowColor);
  1319.     
  1320.     m_BurnCdButton->setBackColor(color);
  1321.     m_BurnCdButton->setHiliteColor(hiliteColor);
  1322.     m_BurnCdButton->setShadowColor(shadowColor);
  1323.     
  1324.     m_CdImageButton->setBackColor(color);
  1325.     m_CdImageButton->setHiliteColor(hiliteColor);
  1326.     m_CdImageButton->setShadowColor(shadowColor);
  1327.     
  1328.     m_ToolSeparator2->setBackColor(color);
  1329.     m_ToolSeparator2->setHiliteColor(hiliteColor);
  1330.     m_ToolSeparator2->setShadowColor(shadowColor);
  1331.     
  1332.     m_PrefsButton->setBackColor(color);
  1333.     m_PrefsButton->setHiliteColor(hiliteColor);
  1334.     m_PrefsButton->setShadowColor(shadowColor);
  1335.     
  1336.     m_HelpButton->setBackColor(color);
  1337.     m_HelpButton->setHiliteColor(hiliteColor);
  1338.     m_HelpButton->setShadowColor(shadowColor);
  1339.     
  1340.     m_ToolSeparator3->setBackColor(color);
  1341.     m_ToolSeparator3->setHiliteColor(hiliteColor);
  1342.     m_ToolSeparator3->setShadowColor(shadowColor);
  1343.     
  1344.     m_ExitButton->setBackColor(color);
  1345.     m_ExitButton->setHiliteColor(hiliteColor);
  1346.     m_ExitButton->setShadowColor(shadowColor);
  1347.     
  1348.     // change the main content window
  1349.     m_contents->setBackColor(color);
  1350.     m_contents->setHiliteColor(hiliteColor);
  1351.     m_contents->setShadowColor(shadowColor);
  1352.     
  1353.     // change the status bar colors
  1354.     // we'll also have to change the status line
  1355.     // and drag corner elements of the status bar, too
  1356.     m_statusBar->setBackColor(color);
  1357.     m_statusBar->setHiliteColor(hiliteColor);
  1358.     m_statusBar->setShadowColor(shadowColor);
  1359.     m_statusBar->getStatusline()->setBackColor(color);
  1360.     m_statusBar->getStatusline()->setHiliteColor(hiliteColor);
  1361.     m_statusBar->getStatusline()->setShadowColor(shadowColor);
  1362.     m_statusBar->getDragCorner()->setBackColor(color);
  1363.     m_statusBar->getDragCorner()->setHiliteColor(hiliteColor);
  1364.     m_statusBar->getDragCorner()->setShadowColor(shadowColor);
  1365.     
  1366.     // Now we'll change the colors for the menu panes
  1367.     m_fileMenu->setBackColor(color);
  1368.     m_fileMenu->setHiliteColor(hiliteColor);
  1369.     m_fileMenu->setShadowColor(shadowColor);
  1370.     
  1371.     m_optionsMenu->setBackColor(color);
  1372.     m_optionsMenu->setHiliteColor(hiliteColor);
  1373.     m_optionsMenu->setShadowColor(shadowColor);
  1374.     
  1375.     m_helpMenu->setBackColor(color);
  1376.     m_helpMenu->setHiliteColor(hiliteColor);
  1377.     m_helpMenu->setShadowColor(shadowColor);
  1378.         
  1379.     // Next, set the colors for the menu commands
  1380.     // (menu separators are included with the commands)
  1381.     // First, the file menu commands
  1382.     m_NewMenuCommand->setBackColor(color);
  1383.     m_NewMenuCommand->setHiliteColor(hiliteColor);
  1384.     m_NewMenuCommand->setShadowColor(shadowColor);
  1385.     
  1386.     m_OpenMenuCommand->setBackColor(color);
  1387.     m_OpenMenuCommand->setHiliteColor(hiliteColor);
  1388.     m_OpenMenuCommand->setShadowColor(shadowColor);
  1389.     
  1390.     m_SaveMenuCommand->setBackColor(color);
  1391.     m_SaveMenuCommand->setHiliteColor(hiliteColor);
  1392.     m_SaveMenuCommand->setShadowColor(shadowColor);
  1393.     
  1394.     m_FileMenuSeparator->setHiliteColor(hiliteColor);
  1395.     m_FileMenuSeparator->setShadowColor(shadowColor);
  1396.     
  1397.     m_CloseMenuCommand->setBackColor(color);
  1398.     m_CloseMenuCommand->setHiliteColor(hiliteColor);
  1399.     m_CloseMenuCommand->setShadowColor(shadowColor);
  1400.     
  1401.     m_ExitMenuCommand->setBackColor(color);
  1402.     m_ExitMenuCommand->setHiliteColor(hiliteColor);
  1403.     m_ExitMenuCommand->setShadowColor(shadowColor);
  1404.     // Then, the options menu commands
  1405.     m_PrefsMenuCommand->setBackColor(color);
  1406.     m_PrefsMenuCommand->setHiliteColor(hiliteColor);
  1407.     m_PrefsMenuCommand->setShadowColor(shadowColor);
  1408.     // Now the help menu commands
  1409.     m_HelpMenuCommand->setBackColor(color);
  1410.     m_HelpMenuCommand->setHiliteColor(hiliteColor);
  1411.     m_HelpMenuCommand->setShadowColor(shadowColor);
  1412.     
  1413.     m_CdrecordHelpMenuCommand->setBackColor(color);
  1414.     m_CdrecordHelpMenuCommand->setHiliteColor(hiliteColor);
  1415.     m_CdrecordHelpMenuCommand->setShadowColor(shadowColor);
  1416.     
  1417.     m_MkisofsHelpMenuCommand->setBackColor(color);
  1418.     m_MkisofsHelpMenuCommand->setHiliteColor(hiliteColor);
  1419.     m_MkisofsHelpMenuCommand->setShadowColor(shadowColor);
  1420.     
  1421.     m_CdrdaoHelpMenuCommand->setBackColor(color);
  1422.     m_CdrdaoHelpMenuCommand->setHiliteColor(hiliteColor);
  1423.     m_CdrdaoHelpMenuCommand->setShadowColor(shadowColor);
  1424.     
  1425.     m_HelpMenuSeparator->setHiliteColor(hiliteColor);
  1426.     m_HelpMenuSeparator->setShadowColor(shadowColor);
  1427.     
  1428.     m_AboutMenuCommand->setBackColor(color);
  1429.     m_AboutMenuCommand->setHiliteColor(hiliteColor);
  1430.     m_AboutMenuCommand->setShadowColor(shadowColor);
  1431.     
  1432.     // set the colors for the main window controls
  1433.     setMainControlsBaseColor(color, hiliteColor, shadowColor);
  1434.     
  1435.     // set the colors for the already-created help windows
  1436.     m_HelpWindow->setWindowBaseColor(color, hiliteColor, shadowColor);
  1437.     m_CdrecordHelpWindow->setWindowBaseColor(color, hiliteColor, shadowColor);
  1438.     m_MkisofsHelpWindow->setWindowBaseColor(color, hiliteColor, shadowColor);
  1439.     m_CdrdaoHelpWindow->setWindowBaseColor(color, hiliteColor, shadowColor);
  1440.     
  1441.     // finally, after all the visible changes are made, change the
  1442.     // application base color (and hilite and shadow colors) so
  1443.     // everything is changed (i.e. in child dialogs)
  1444.     getApp()->setBaseColor(color);
  1445.     getApp()->setHiliteColor(hiliteColor);
  1446.     getApp()->setShadowColor(shadowColor);
  1447. }
  1449. // method for getting the current base color
  1450. FXColor CFreeBurn::getBaseColor() const
  1451. {
  1452.     return getApp()->getBaseColor();
  1453. }
  1455. // method for changing the background color for things
  1456. // that use a background color (i.e. input widgets) 
  1457. // instead of a set base color.
  1458. void CFreeBurn::setBackgroundColor(FXColor color)
  1459. {
  1460.     // set the main window controls background colors
  1461.     setMainControlsBackgroundColor(color);
  1462.     
  1463.     // set the colors for the already-created help windows
  1464.     m_HelpWindow->setWindowBackColor(color);
  1465.     m_CdrecordHelpWindow->setWindowBackColor(color);
  1466.     m_MkisofsHelpWindow->setWindowBackColor(color);
  1467.     m_CdrdaoHelpWindow->setWindowBackColor(color); 
  1468.     
  1469.     // after all the widgets are set, now set the
  1470.     // app back color
  1471.     getApp()->setBackColor(color);
  1472. }
  1474. // method for getting the current background color
  1475. FXColor CFreeBurn::getBackgroundColor() const
  1476. {
  1477.    return getApp()->getBackColor();
  1478. }
  1480. // method for changing the foreground color for
  1481. // the widgets, including setting the text color
  1482. // for most of the widgets
  1483. void CFreeBurn::setForegroundColor(FXColor color)
  1484. {
  1485.     // Now, set the color for the menu titles
  1486.     m_FileMenuTitle->setTextColor(color);
  1487.     m_FileMenuTitle->setSelTextColor(color);
  1488.     
  1489.     m_OptionsMenuTitle->setTextColor(color);
  1490.     m_OptionsMenuTitle->setSelTextColor(color);
  1491.     
  1492.     m_HelpMenuTitle->setTextColor(color);
  1493.     m_HelpMenuTitle->setSelTextColor(color);
  1494.     
  1495.     // Now do the toolbar buttons
  1496.     m_NewDiscButton->setTextColor(color);
  1497.     
  1498.     m_OpenDiscButton->setTextColor(color);
  1499.     
  1500.     m_SaveDiscButton->setTextColor(color);
  1501.     
  1502.     m_BurnCdButton->setTextColor(color);
  1503.     
  1504.     m_CdImageButton->setTextColor(color);
  1505.     
  1506.     m_PrefsButton->setTextColor(color);
  1507.     
  1508.     m_HelpButton->setTextColor(color);
  1509.     
  1510.     m_ExitButton->setTextColor(color);
  1511.     
  1512.     // change the status bar colors
  1513.     m_statusBar->getStatusline()->setTextColor(color);
  1514.     
  1515.     // Next, set the colors for the menu commands
  1516.     // (menu separators are included with the commands)
  1517.     // First, the file menu commands
  1518.     m_NewMenuCommand->setTextColor(color);
  1519.     m_OpenMenuCommand->setTextColor(color);
  1520.     m_SaveMenuCommand->setTextColor(color);
  1521.     m_CloseMenuCommand->setTextColor(color);
  1522.     m_ExitMenuCommand->setTextColor(color);
  1523.     // Then, the options menu commands
  1524.     m_PrefsMenuCommand->setTextColor(color);
  1525.     // Now the help menu commands
  1526.     m_HelpMenuCommand->setTextColor(color);    
  1527.     m_CdrecordHelpMenuCommand->setTextColor(color);    
  1528.     m_MkisofsHelpMenuCommand->setTextColor(color);    
  1529.     m_CdrdaoHelpMenuCommand->setTextColor(color);    
  1530.     m_AboutMenuCommand->setTextColor(color);
  1531.     
  1532.     // set the main window controls foreground colors
  1533.     setMainControlsForegroundColor(color);
  1534.     
  1535.     // set the colors for the already-created help windows
  1536.     m_HelpWindow->setWindowForeColor(color);
  1537.     m_CdrecordHelpWindow->setWindowForeColor(color);
  1538.     m_MkisofsHelpWindow->setWindowForeColor(color);
  1539.     m_CdrdaoHelpWindow->setWindowForeColor(color); 
  1540.     
  1541.     // finally, after all the visible changes are made, change the
  1542.     // application foreground color 
  1543.     getApp()->setForeColor(color);
  1544. }
  1546. FXColor CFreeBurn::getForegroundColor() const
  1547. {
  1548.     return getApp()->getForeColor();
  1549. }
  1551. void CFreeBurn::setBorderColor(FXColor color)
  1552. {
  1553.     // menubar first
  1554.     m_menuBar->setBorderColor(color);
  1555.     
  1556.     // change the toolbar
  1557.     m_toolBar->setBorderColor(color);
  1558.     
  1559.     // now the toolbar buttons
  1560.     m_NewDiscButton->setBorderColor(color);
  1561.     m_OpenDiscButton->setBorderColor(color);
  1562.     m_SaveDiscButton->setBorderColor(color);
  1563.     m_BurnCdButton->setBorderColor(color);
  1564.     m_CdImageButton->setBorderColor(color);
  1565.     m_PrefsButton->setBorderColor(color);
  1566.     m_HelpButton->setBorderColor(color);
  1567.     m_ExitButton->setBorderColor(color);
  1568.     
  1569.     // next the content frame
  1570.     m_contents->setBorderColor(color);
  1572.     // now the status bar (and status line)
  1573.     m_statusBar->setBorderColor(color);
  1574.     m_statusBar->getStatusline()->setBorderColor(color);
  1576.     // then the menu panes
  1577.     m_fileMenu->setBorderColor(color);
  1578.     m_optionsMenu->setBorderColor(color);
  1579.     m_helpMenu->setBorderColor(color);
  1580.         
  1581.     // set the main window controls background colors
  1582.     setMainControlsBorderColor(color);
  1583.     
  1584.     // set the colors for the already-created help windows
  1585.     m_HelpWindow->setWindowBordColor(color);
  1586.     m_CdrecordHelpWindow->setWindowBordColor(color);
  1587.     m_MkisofsHelpWindow->setWindowBordColor(color);
  1588.     m_CdrdaoHelpWindow->setWindowBordColor(color); 
  1589.     
  1590.     // finally, set the application value
  1591.     getApp()->setBorderColor(color);
  1592. }
  1594. FXColor CFreeBurn::getBorderColor() const
  1595. {
  1596.     return getApp()->getBorderColor();
  1597. }
  1599. // method to handle commands for changing the colors of the application
  1600. long CFreeBurn::onCmdColorDefault(FXObject*, FXSelector sel, void*)
  1601. {
  1602.     switch(SELID(sel))
  1603.     {
  1604.         case ID_BASECOLOR_DEFAULT: 
  1605.             setDefaultBaseColor(); 
  1606.             break;
  1607.         case ID_BACKCOLOR_DEFAULT: 
  1608.             setDefaultBackgroundColor(); 
  1609.             break;
  1610.         case ID_FORECOLOR_DEFAULT: 
  1611.             setDefaultForegroundColor(); 
  1612.             break;
  1613.         case ID_BORDCOLOR_DEFAULT: 
  1614.             setDefaultBorderColor(); 
  1615.             break;
  1616.     }
  1617.   
  1618.     return 1;
  1619. }
  1621. // method to set the default base color
  1622. void CFreeBurn::setDefaultBaseColor()
  1623. {
  1624.     FXColor baseColor;
  1625.     
  1626. #ifndef WIN32
  1628.     baseColor = FXRGB(192,192,192);
  1630. #else
  1632.     DWORD dwColor;
  1633.     dwColor   = GetSysColor(COLOR_3DFACE);
  1634.     baseColor = FXRGB(GetRValue(dwColor),GetGValue(dwColor),GetBValue(dwColor)); 
  1635.     
  1636. #endif
  1638.     setBaseColor(baseColor);
  1640. }
  1642. // method to set the default background color
  1643. void CFreeBurn::setDefaultBackgroundColor()
  1644. {
  1645.     FXColor backColor;
  1646.     
  1647. #ifndef WIN32
  1649.     backColor = FXRGB(255,255,255);
  1651. #else
  1653.     DWORD dwColor;
  1654.     dwColor   = GetSysColor(COLOR_WINDOW);
  1655.     backColor = FXRGB(GetRValue(dwColor),GetGValue(dwColor),GetBValue(dwColor)); 
  1656.     
  1657. #endif
  1659.     setBackgroundColor(backColor);
  1661. }
  1663. // method to set the default foreground color
  1664. void CFreeBurn::setDefaultForegroundColor()
  1665. {
  1666.     FXColor foreColor;
  1667.     
  1668. #ifndef WIN32
  1670.     foreColor = FXRGB(0,0,0);
  1672. #else
  1674.     DWORD dwColor;
  1675.     dwColor   = GetSysColor(COLOR_BTNTEXT);
  1676.     foreColor = FXRGB(GetRValue(dwColor),GetGValue(dwColor),GetBValue(dwColor)); 
  1677.     
  1678. #endif
  1680.     setForegroundColor(foreColor);
  1682. }
  1684. // method to set the default border color
  1685. void CFreeBurn::setDefaultBorderColor()
  1686. {
  1687.     FXColor borderColor;
  1688.     
  1689. #ifndef WIN32
  1691.     borderColor = FXRGB(0,0,0);
  1693. #else
  1695.     DWORD dwColor;
  1696.     dwColor     = GetSysColor(COLOR_WINDOWFRAME);
  1697.     borderColor = FXRGB(GetRValue(dwColor),GetGValue(dwColor),GetBValue(dwColor)); 
  1698.     
  1699. #endif
  1701.     setBorderColor(borderColor);
  1703. }
  1705. // Load the proper icons for the program based on the configured theme
  1706. void CFreeBurn::loadThemeIcons()
  1707. {
  1708.     // first, load all the icons for all the themes so we have them to use...
  1709.     m_DefaultNewIcon          = new FXPNGIcon(getApp(), w_new_png);
  1710.     m_DefaultOpenIcon         = new FXPNGIcon(getApp(), w_open_png);
  1711.     m_DefaultSaveIcon         = new FXPNGIcon(getApp(), w_save_png);
  1712.     m_DefaultCloseIcon        = new FXPNGIcon(getApp(), w_close_png);
  1713.     m_DefaultBurnCdIcon       = new FXPNGIcon(getApp(), w_burncd_png); 
  1714.     m_DefaultCdImageIcon      = new FXPNGIcon(getApp(), w_cdimage_png); 
  1715.     m_DefaultPreferencesIcon  = new FXPNGIcon(getApp(), w_preferences_png);
  1716.     m_DefaultHelpIcon         = new FXPNGIcon(getApp(), w_help_png);
  1717.     m_DefaultExitIcon         = new FXPNGIcon(getApp(), w_exit_png);
  1718.     m_DefaultThemePreviewIcon = new FXPNGIcon(getApp(), w_theme_preview_png);
  1719.     m_DefaultFindIcon         = new FXPNGIcon(getApp(), w_find_png);
  1720.     
  1721.     m_GnomeNewIcon            = new FXPNGIcon(getApp(), g_new_png);
  1722.     m_GnomeOpenIcon           = new FXPNGIcon(getApp(), g_open_png);
  1723.     m_GnomeSaveIcon           = new FXPNGIcon(getApp(), g_save_png);
  1724.     m_GnomeCloseIcon          = new FXPNGIcon(getApp(), g_close_png);
  1725.     m_GnomeBurnCdIcon         = new FXPNGIcon(getApp(), g_burncd_png);
  1726.     m_GnomeCdImageIcon        = new FXPNGIcon(getApp(), g_cdimage_png);
  1727.     m_GnomePreferencesIcon    = new FXPNGIcon(getApp(), g_preferences_png);
  1728.     m_GnomeHelpIcon           = new FXPNGIcon(getApp(), g_help_png);
  1729.     m_GnomeExitIcon           = new FXPNGIcon(getApp(), g_exit_png);
  1730.     m_GnomeThemePreviewIcon   = new FXPNGIcon(getApp(), g_theme_preview_png);
  1731.     m_GnomeFindIcon           = new FXPNGIcon(getApp(), g_find_png);
  1732.     
  1733.     m_KdeNewIcon              = new FXPNGIcon(getApp(), k_new_png);
  1734.     m_KdeOpenIcon             = new FXPNGIcon(getApp(), k_open_png);
  1735.     m_KdeSaveIcon             = new FXPNGIcon(getApp(), k_save_png);
  1736.     m_KdeCloseIcon            = new FXPNGIcon(getApp(), k_close_png);
  1737.     m_KdeBurnCdIcon           = new FXPNGIcon(getApp(), k_burncd_png);
  1738.     m_KdeCdImageIcon          = new FXPNGIcon(getApp(), k_cdimage_png);
  1739.     m_KdePreferencesIcon      = new FXPNGIcon(getApp(), k_preferences_png);
  1740.     m_KdeHelpIcon             = new FXPNGIcon(getApp(), k_help_png);
  1741.     m_KdeExitIcon             = new FXPNGIcon(getApp(), k_exit_png);
  1742.     m_KdeThemePreviewIcon     = new FXPNGIcon(getApp(), k_theme_preview_png);
  1743.     m_KdeFindIcon             = new FXPNGIcon(getApp(), k_find_png);
  1744.     
  1745.     m_XpNewIcon               = new FXPNGIcon(getApp(), xp_new_png);
  1746.     m_XpOpenIcon              = new FXPNGIcon(getApp(), xp_open_png);
  1747.     m_XpSaveIcon              = new FXPNGIcon(getApp(), xp_save_png);
  1748.     m_XpCloseIcon             = new FXPNGIcon(getApp(), xp_close_png);
  1749.     m_XpBurnCdIcon            = new FXPNGIcon(getApp(), xp_burncd_png);
  1750.     m_XpCdImageIcon           = new FXPNGIcon(getApp(), xp_cdimage_png);
  1751.     m_XpPreferencesIcon       = new FXPNGIcon(getApp(), xp_preferences_png);
  1752.     m_XpHelpIcon              = new FXPNGIcon(getApp(), xp_help_png);
  1753.     m_XpExitIcon              = new FXPNGIcon(getApp(), xp_exit_png);
  1754.     m_XpThemePreviewIcon      = new FXPNGIcon(getApp(), xp_theme_preview_png);
  1755.     m_XpFindIcon              = new FXPNGIcon(getApp(), xp_find_png);
  1756.     
  1757.     // create all the icons for use...
  1758.     m_DefaultNewIcon->create();
  1759.     m_DefaultOpenIcon->create();
  1760.     m_DefaultSaveIcon->create();
  1761.     m_DefaultCloseIcon->create();
  1762.     m_DefaultBurnCdIcon->create();
  1763.     m_DefaultCdImageIcon->create();
  1764.     m_DefaultPreferencesIcon->create();
  1765.     m_DefaultHelpIcon->create();
  1766.     m_DefaultExitIcon->create();
  1767.     m_DefaultThemePreviewIcon->create();
  1768.     m_DefaultFindIcon->create();
  1769.     
  1770.     m_GnomeNewIcon->create();
  1771.     m_GnomeOpenIcon->create();
  1772.     m_GnomeSaveIcon->create();
  1773.     m_GnomeCloseIcon->create();
  1774.     m_GnomeBurnCdIcon->create();
  1775.     m_GnomeCdImageIcon->create();
  1776.     m_GnomePreferencesIcon->create();
  1777.     m_GnomeHelpIcon->create();
  1778.     m_GnomeExitIcon->create();
  1779.     m_GnomeThemePreviewIcon->create();
  1780.     m_GnomeFindIcon->create();
  1782.     m_KdeNewIcon->create();
  1783.     m_KdeOpenIcon->create();
  1784.     m_KdeSaveIcon->create();
  1785.     m_KdeCloseIcon->create();
  1786.     m_KdeBurnCdIcon->create();
  1787.     m_KdeCdImageIcon->create();
  1788.     m_KdePreferencesIcon->create();
  1789.     m_KdeHelpIcon->create();
  1790.     m_KdeExitIcon->create();
  1791.     m_KdeThemePreviewIcon->create();
  1792.     m_KdeFindIcon->create();
  1793.     
  1794.     m_XpNewIcon->create();
  1795.     m_XpOpenIcon->create();
  1796.     m_XpSaveIcon->create();
  1797.     m_XpCloseIcon->create();
  1798.     m_XpBurnCdIcon->create();
  1799.     m_XpCdImageIcon->create();
  1800.     m_XpPreferencesIcon->create();
  1801.     m_XpHelpIcon->create();
  1802.     m_XpExitIcon->create();
  1803.     m_XpThemePreviewIcon->create();
  1804.     m_XpFindIcon->create();
  1805. }
  1807. // set the proper icons for the program based on the configured theme
  1808. void CFreeBurn::setThemeIcons()
  1809. {
  1810.     // set the default icons based on the current theme...
  1811.     if (m_theme == GNOME_THEME)    // GNOME theme
  1812.     {
  1813.         m_NewIcon          = m_GnomeNewIcon;
  1814.         m_OpenIcon         = m_GnomeOpenIcon;
  1815.         m_SaveIcon         = m_GnomeSaveIcon;
  1816.         m_CloseIcon        = m_GnomeCloseIcon;
  1817.         m_burnCdIcon       = m_GnomeBurnCdIcon;
  1818.         m_cdImageIcon      = m_GnomeCdImageIcon;
  1819.         m_preferencesIcon  = m_GnomePreferencesIcon;
  1820.         m_helpIcon         = m_GnomeHelpIcon;
  1821.         m_exitIcon         = m_GnomeExitIcon;
  1822.         m_ThemePreviewIcon = m_GnomeThemePreviewIcon;
  1823.         m_FindIcon         = m_GnomeFindIcon;
  1824.     }
  1825.     else if (m_theme == KDE_THEME) // KDE theme
  1826.     {
  1827.         m_NewIcon          = m_KdeNewIcon;
  1828.         m_OpenIcon         = m_KdeOpenIcon;
  1829.         m_SaveIcon         = m_KdeSaveIcon;
  1830.         m_CloseIcon        = m_KdeCloseIcon;
  1831.         m_burnCdIcon       = m_KdeBurnCdIcon;
  1832.         m_cdImageIcon      = m_KdeCdImageIcon;
  1833.         m_preferencesIcon  = m_KdePreferencesIcon;
  1834.         m_helpIcon         = m_KdeHelpIcon;
  1835.         m_exitIcon         = m_KdeExitIcon;
  1836.         m_ThemePreviewIcon = m_KdeThemePreviewIcon;
  1837.         m_FindIcon         = m_KdeFindIcon;
  1838.     }
  1839.     else if (m_theme == XP_THEME)  // XP theme
  1840.     {
  1841.         m_NewIcon          = m_XpNewIcon;
  1842.         m_OpenIcon         = m_XpOpenIcon;
  1843.         m_SaveIcon         = m_XpSaveIcon;
  1844.         m_CloseIcon        = m_XpCloseIcon;
  1845.         m_burnCdIcon       = m_XpBurnCdIcon;
  1846.         m_cdImageIcon      = m_XpCdImageIcon;
  1847.         m_preferencesIcon  = m_XpPreferencesIcon;
  1848.         m_helpIcon         = m_XpHelpIcon;
  1849.         m_exitIcon         = m_XpExitIcon;
  1850.         m_ThemePreviewIcon = m_XpThemePreviewIcon;
  1851.         m_FindIcon         = m_XpFindIcon;
  1852.     }
  1853.     else // use default theme if no valid theme is given
  1854.     {
  1855.         m_NewIcon          = m_DefaultNewIcon;
  1856.         m_OpenIcon         = m_DefaultOpenIcon;
  1857.         m_SaveIcon         = m_DefaultSaveIcon;
  1858.         m_CloseIcon        = m_DefaultCloseIcon;
  1859.         m_burnCdIcon       = m_DefaultBurnCdIcon;
  1860.         m_cdImageIcon      = m_DefaultCdImageIcon;
  1861.         m_preferencesIcon  = m_DefaultPreferencesIcon;
  1862.         m_helpIcon         = m_DefaultHelpIcon;
  1863.         m_exitIcon         = m_DefaultExitIcon;
  1864.         m_ThemePreviewIcon = m_DefaultThemePreviewIcon;
  1865.         m_FindIcon         = m_DefaultFindIcon;
  1866.     }
  1867. }
  1869. // setup the program toolbar with buttons and stuff
  1870. void CFreeBurn::setupToolBar()
  1871. {
  1872.     // setup and add the m_toolBar buttons
  1873.     m_NewDiscButton   = new FXButton(m_toolBar, fbNewButtonText,       m_NewIcon, 
  1874.         this, ID_NEW,         BUTTON_TOOLBAR|FRAME_RAISED|LAYOUT_TOP|LAYOUT_LEFT);
  1875.     m_OpenDiscButton  = new FXButton(m_toolBar, fbOpenButtonText,       m_OpenIcon, 
  1876.         this, ID_OPEN,        BUTTON_TOOLBAR|FRAME_RAISED|LAYOUT_TOP|LAYOUT_LEFT);
  1877.     m_SaveDiscButton  = new FXButton(m_toolBar, fbSaveButtonText,       m_SaveIcon, 
  1878.         this, ID_SAVE,        BUTTON_TOOLBAR|FRAME_RAISED|LAYOUT_TOP|LAYOUT_LEFT);
  1879.     m_ToolSeparator1  = new FXVerticalSeparator(m_toolBar);
  1880.     m_BurnCdButton    = new FXButton(m_toolBar, fbBurnCDButtonText,     m_burnCdIcon, 
  1881.         this, ID_BURN_CD,     BUTTON_TOOLBAR|FRAME_RAISED|LAYOUT_TOP|LAYOUT_LEFT);
  1882.     m_CdImageButton   = new FXButton(m_toolBar, fbCDImageButtonText,    m_cdImageIcon,
  1883.         this, ID_CD_IMAGE,    BUTTON_TOOLBAR|FRAME_RAISED|LAYOUT_TOP|LAYOUT_LEFT);
  1884.     m_ToolSeparator2  = new FXVerticalSeparator(m_toolBar);
  1885.     m_PrefsButton     = new FXButton(m_toolBar, fbPropertiesButtonText, m_preferencesIcon, 
  1886.         this, ID_PREFERENCES, BUTTON_TOOLBAR|FRAME_RAISED|LAYOUT_TOP|LAYOUT_LEFT);
  1887.     m_HelpButton    = new FXButton(m_toolBar, fbHelpButtonText,         m_helpIcon,
  1888.         this, ID_HELP,        BUTTON_TOOLBAR|FRAME_RAISED|LAYOUT_TOP|LAYOUT_LEFT);
  1889.     m_ToolSeparator3  = new FXVerticalSeparator(m_toolBar);
  1890.     m_ExitButton      = new FXButton(m_toolBar, fbExitButtonText,       m_exitIcon,
  1891.         this, ID_EXIT,        BUTTON_TOOLBAR|FRAME_RAISED|LAYOUT_TOP|LAYOUT_LEFT);
  1892.         
  1893. }
  1895. // change the icons for the buttons in the toolbar
  1896. void CFreeBurn::changeToolBarIcons()
  1897. {
  1898.     m_NewDiscButton->setIcon(m_NewIcon);
  1899.     m_OpenDiscButton->setIcon(m_OpenIcon);
  1900.     m_SaveDiscButton->setIcon(m_SaveIcon);
  1901.     m_BurnCdButton->setIcon(m_burnCdIcon);
  1902.     m_CdImageButton->setIcon(m_cdImageIcon);
  1903.     m_PrefsButton->setIcon(m_preferencesIcon);
  1904.     m_HelpButton->setIcon(m_helpIcon);
  1905.     m_ExitButton->setIcon(m_exitIcon);
  1906. }
  1908. // setup all the program menus
  1909. void CFreeBurn::setupProgramMenus()
  1910. {
  1911.     // Construct menu panes and add
  1912.     // them to the m_menuBar
  1913.     m_fileMenu = new FXMenuPane(this);
  1914.     m_FileMenuTitle = new FXMenuTitle(m_menuBar, fbFileMenuTitle,    NULL, m_fileMenu);
  1915.     
  1916.     m_optionsMenu = new FXMenuPane(this);
  1917.     m_OptionsMenuTitle = new FXMenuTitle(m_menuBar, fbOptionsMenuTitle, NULL, m_optionsMenu);
  1918.     
  1919.     m_helpMenu = new FXMenuPane(this);
  1920.     m_HelpMenuTitle = new FXMenuTitle(m_menuBar, fbHelpMenuTitle,    NULL, m_helpMenu);
  1921.     
  1922.     // setup and add the file menu commands
  1923.     m_NewMenuCommand    = new FXMenuCommand(m_fileMenu, fbFileMenuNewText,   m_NewIcon,   this, ID_NEW);
  1924.     m_OpenMenuCommand   = new FXMenuCommand(m_fileMenu, fbFileMenuOpenText,  m_OpenIcon,  this, ID_OPEN);
  1925.     m_SaveMenuCommand   = new FXMenuCommand(m_fileMenu, fbFileMenuSaveText,  m_SaveIcon,  this, ID_SAVE);
  1926.     m_FileMenuSeparator = new FXMenuSeparator(m_fileMenu);
  1927.     m_CloseMenuCommand  = new FXMenuCommand(m_fileMenu, fbFileMenuCloseText, m_CloseIcon, this, ID_CLOSE);
  1928.     m_ExitMenuCommand   = new FXMenuCommand(m_fileMenu, fbFileMenuQuitText,  m_exitIcon,  this, ID_EXIT);
  1929.     
  1930.     // setup and add the options menu commands
  1931.     m_PrefsMenuCommand = new FXMenuCommand(m_optionsMenu, fbOptionsMenuPropertiesText, 
  1932.         m_preferencesIcon, this, ID_PREFERENCES);
  1933.     
  1934.     // setup and add the help menu commands
  1935.     m_HelpMenuCommand         = new FXMenuCommand(m_helpMenu, fbHelpMenuHelpText,      
  1936.         m_helpIcon,  this, ID_HELP);
  1937.     m_CdrecordHelpMenuCommand = new FXMenuCommand(m_helpMenu, fbHelpMenuCdrecordText,  
  1938.         m_helpIcon,  this, ID_HELP_CDRECORD);
  1939.     m_MkisofsHelpMenuCommand  = new FXMenuCommand(m_helpMenu, fbHelpMenuMkisofsText,
  1940.         m_helpIcon,  this, ID_HELP_MKISOFS);
  1941.     m_CdrdaoHelpMenuCommand   = new FXMenuCommand(m_helpMenu, fbHelpMenuCdrdaoText,
  1942.         m_helpIcon,  this, ID_HELP_CDRDAO);
  1943.     m_HelpMenuSeparator = new FXMenuSeparator(m_helpMenu);
  1944.     m_AboutMenuCommand        = new FXMenuCommand(m_helpMenu, fbHelpMenuAboutText,
  1945.         m_smallIcon, this, ID_ABOUT);
  1946. }
  1948. // change the icons for all the menu commands
  1949. void CFreeBurn::changeMenuIcons()
  1950. {
  1951.     // the File menu commands...
  1952.     m_NewMenuCommand->setIcon(m_NewIcon);
  1953.     m_OpenMenuCommand->setIcon(m_OpenIcon);
  1954.     m_SaveMenuCommand->setIcon(m_SaveIcon);
  1955.     m_CloseMenuCommand->setIcon(m_CloseIcon);
  1956.     m_ExitMenuCommand->setIcon(m_exitIcon);
  1957.     // then the Options menu commands...
  1958.     m_PrefsMenuCommand->setIcon(m_preferencesIcon);
  1959.     // finally the Help menu commands (About doesn't change)
  1960.     m_HelpMenuCommand->setIcon(m_helpIcon);
  1961.     m_CdrecordHelpMenuCommand->setIcon(m_helpIcon);
  1962.     m_MkisofsHelpMenuCommand->setIcon(m_helpIcon);
  1963.     m_CdrdaoHelpMenuCommand->setIcon(m_helpIcon);
  1964. }
  1966. // set up the main content window controls
  1967. void CFreeBurn::setupContentFrame()
  1968. {
  1969.     m_contents      = new FXVerticalFrame(this, FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X|LAYOUT_FILL_Y,
  1970.                     0, 0, 0, 0, 15, 15, 15, 15);
  1971.     
  1972.     m_mainFrame = new FXVerticalFrame(m_contents, LAYOUT_CENTER_X|LAYOUT_CENTER_Y);
  1973.     
  1974.     m_Group1 = new FXGroupBox(m_mainFrame, fbDiscConfigBoxText, GROUPBOX_NORMAL|FRAME_LINE);
  1975.     // matrix to hold all the window controls in a nice looking layout
  1976.     m_contentMatrix = new FXMatrix(m_Group1, 4, MATRIX_BY_COLUMNS|PACK_UNIFORM_HEIGHT, 
  1977.         0, 0, 0, 0, 0, 0, 0, 0, 5, 15);
  1978.     
  1979.     // row 1
  1980.     m_DiscSizeLabel = new FXLabel(m_contentMatrix, fbDiscSizeLabelText, NULL, JUSTIFY_RIGHT|LAYOUT_FILL_X);
  1981.     m_sizeField     = new FXTextField(m_contentMatrix, 20, this, ID_DISC_SIZE, 
  1982.         TEXTFIELD_READONLY|FRAME_SUNKEN|FRAME_THICK);
  1983.     m_DiscTypeLabel = new FXLabel(m_contentMatrix, fbDiscTypeLabelText, NULL, JUSTIFY_RIGHT|LAYOUT_FILL_X);
  1984.     m_typeField     = new FXTextField(m_contentMatrix, 20, this, ID_DISC_TYPE, 
  1985.         TEXTFIELD_READONLY|FRAME_SUNKEN|FRAME_THICK);
  1986.     
  1987.     // row 2
  1988.     m_catalogLabel  = new FXLabel(m_contentMatrix, fbCatNumLabelText, NULL, JUSTIFY_RIGHT);
  1989.     m_catalogField  = new FXTextField(m_contentMatrix, CD_CATALOG_STRING_LENGTH, this, ID_CAT_NUM, 
  1990.         TEXTFIELD_LIMITED|FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X);
  1991.     m_cdTextButton  = new FXCheckButton(m_contentMatrix, fbCdTextLabelText, this, ID_USE_CD_TEXT,
  1992.         ICON_BEFORE_TEXT);
  1993.     m_editTextBut   = new FXButton(m_contentMatrix, fbEditGlobalCdTextButtonText, NULL, this, ID_EDIT_CD_TEXT,
  1994.         FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X);
  1995.     
  1996.     m_Group2 = new FXGroupBox(m_mainFrame, fbTrackFuncsBoxText, GROUPBOX_NORMAL|FRAME_LINE|LAYOUT_FILL_X);
  1997.     
  1998.     m_secondMatrix = new FXMatrix(m_Group2, 4, MATRIX_BY_COLUMNS|PACK_UNIFORM_HEIGHT|LAYOUT_CENTER_X);
  1999.     
  2000.     // row 3
  2001.     m_addTrackLabel = new FXLabel(m_secondMatrix, fbAddCdTrackLabelText, NULL, JUSTIFY_CENTER_X|LAYOUT_FILL_X);
  2002.     m_trackOptions  = new FXOptionMenu(m_secondMatrix, NULL, 
  2003.         FRAME_RAISED|FRAME_THICK|JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
  2004.         m_trackOptions->setTarget(this);
  2005.         m_trackOptions->setSelector(ID_TRACK_TYPE);
  2006.     m_trackLabel1   = new FXLabel(m_secondMatrix,  fbTrackLabel1Text, NULL);
  2007.     m_addTrackBut   = new FXButton(m_secondMatrix, fbAddTrackButtonText, NULL, this, ID_ADD_TRACK,
  2008.         FRAME_RAISED|FRAME_THICK);
  2009.         
  2010.     // row 4
  2011.     m_modTrackPopup = new FXPopup(this);
  2012.     m_editTrack     = new FXOption(m_modTrackPopup, fbEditTrackOptionText,   NULL, this, 
  2013.         ID_EDIT_TRACK,   JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
  2014.     m_deleteTrack   = new FXOption(m_modTrackPopup, fbDeleteTrackOptionText, NULL, this, 
  2015.         ID_DELETE_TRACK, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
  2016.     m_modTrackOpts  = new FXOptionMenu(m_secondMatrix, NULL,
  2017.         LAYOUT_TOP|FRAME_RAISED|FRAME_THICK|JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
  2018.         m_modTrackOpts->setTarget(this);
  2019.         m_modTrackOpts->setSelector(ID_MODIFY_TRACK_OPT);
  2020.         m_modTrackOpts->setPopup(m_modTrackPopup);
  2021.     m_modTrackLabel = new FXLabel(m_secondMatrix, fbModTrackLabelText, NULL, JUSTIFY_CENTER_X|LAYOUT_FILL_X);
  2022.     m_modTrackNum   = new FBSpinner(m_secondMatrix, 2, this, ID_TRACK_NUM, SPIN_NORMAL|FRAME_SUNKEN|FRAME_THICK);
  2023.         // set the initial range of the spinner to 0..0
  2024.         m_modTrackNum->setRange(0, 0);
  2025.         // set the help text for the spinner
  2026.         m_modTrackNum->setHelpText(fbTrackNumberHelpText);
  2027.     m_modTrackBut   = new FXButton(m_secondMatrix, fbModTrackButtonText, NULL, this, ID_MODIFY_TRACK,
  2028.         FRAME_RAISED|FRAME_THICK);
  2029.         
  2030.     // The popup for audio tracks
  2031.     m_cddaPopup     = new FXPopup(this);
  2032.     m_cddaAudio     = new FXOption(m_cddaPopup, fbAudioTrackOptionText, NULL, this, 
  2033.         ID_AUDIO_TRACK, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
  2034.     m_trackOptions->setPopup(m_cddaPopup);
  2035.     
  2036.     // The popup for data tracks
  2037.     m_cdromPopup    = new FXPopup(this);
  2038.     m_cdromData     = new FXOption(m_cdromPopup, fbDataTrackOptionText,    NULL, this, 
  2039.         ID_DATA_TRACK,  JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
  2040.     m_cdromAudio    = new FXOption(m_cdromPopup, fbAudioTrackOptionText,   NULL, this, 
  2041.         ID_AUDIO_TRACK, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
  2042.     m_cdromRaw      = new FXOption(m_cdromPopup, fbRawDataTrackOptionText, NULL, this, 
  2043.         ID_RAW_TRACK,   JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
  2044.         
  2045.     // The popup for XA tracks
  2046.     m_cdxaPopup     = new FXPopup(this);
  2047.     m_cdxaAudio     = new FXOption(m_cdxaPopup, fbAudioTrackOptionText,      NULL, this, 
  2048.         ID_AUDIO_TRACK,    JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
  2049.     m_cdxaData      = new FXOption(m_cdxaPopup, fbMode2DataTrackOptionText,  NULL, this, 
  2050.         ID_XA_DATA_TRACK,  JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
  2051.     m_cdxaAudio2    = new FXOption(m_cdxaPopup, fbMode2AudioTrackOptionText, NULL, this, 
  2052.         ID_XA_AUDIO_TRACK, JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
  2053.     m_cdxaRaw       = new FXOption(m_cdxaPopup, fbMode2RawTrackOptionText,   NULL, this, 
  2054.         ID_XA_RAW_TRACK,   JUSTIFY_HZ_APART|ICON_AFTER_TEXT);
  2055.         
  2056.     // The bottom area for reporting disc used and free space
  2057.     m_spaceFrame     = new FXHorizontalFrame(m_contents, LAYOUT_BOTTOM|LAYOUT_FILL_X|LAYOUT_CENTER_X);
  2058.     m_usedSpaceLabel = new FXLabel(m_spaceFrame, fbDiscUsedSpaceLabelText, NULL, LAYOUT_LEFT, 0, 0, 0, 0, 15, 5);
  2059.     m_usedSpaceField = new FXTextField(m_spaceFrame, 6, this, ID_USED_SPACE, 
  2060.         TEXTFIELD_READONLY|TEXTFIELD_INTEGER|FRAME_SUNKEN|FRAME_THICK|LAYOUT_LEFT);
  2061.     m_freeSpaceLabel = new FXLabel(m_spaceFrame, fbDiscFreeSpaceLabelText, NULL, LAYOUT_LEFT, 0, 0, 0, 0, 15, 5);
  2062.     m_freeSpaceField = new FXTextField(m_spaceFrame, 6, this, ID_FREE_SPACE, 
  2063.         TEXTFIELD_READONLY|TEXTFIELD_INTEGER|FRAME_SUNKEN|FRAME_THICK|LAYOUT_LEFT);
  2064.     m_percentFull    = new FXProgressBar(m_spaceFrame, this, ID_PERCENT_FULL, 
  2065.         FRAME_SUNKEN|FRAME_THICK|PROGRESSBAR_PERCENTAGE|PROGRESSBAR_HORIZONTAL|LAYOUT_FILL_X);
  2066. }
  2068. // set the base color for the main window controls
  2069. void CFreeBurn::setMainControlsBaseColor(FXColor color, FXColor hilite, FXColor shadow)
  2070. {
  2071.     // set the colors for all vertical frames
  2072.     m_mainFrame->setBackColor(color);
  2073.     m_mainFrame->setHiliteColor(hilite);
  2074.     m_mainFrame->setShadowColor(shadow);
  2075.     
  2076.     // set the colors for all horizontal frames
  2077.     m_spaceFrame->setBackColor(color);
  2078.     m_spaceFrame->setHiliteColor(hilite);
  2079.     m_spaceFrame->setShadowColor(shadow);
  2080.     
  2081.     // set the colors for all group boxes
  2082.     m_Group1->setBackColor(color);
  2083.     m_Group1->setHiliteColor(hilite);
  2084.     m_Group1->setShadowColor(shadow);
  2085.     m_Group2->setBackColor(color);
  2086.     m_Group2->setHiliteColor(hilite);
  2087.     m_Group2->setShadowColor(shadow);
  2088.     
  2089.     // set the colors for all matricies
  2090.     m_contentMatrix->setBackColor(color);
  2091.     m_contentMatrix->setHiliteColor(hilite);
  2092.     m_contentMatrix->setShadowColor(shadow);
  2093.     m_secondMatrix->setBackColor(color);
  2094.     m_secondMatrix->setHiliteColor(hilite);
  2095.     m_secondMatrix->setShadowColor(shadow);
  2096.     
  2097.     // set the colors for all labels
  2098.     m_DiscSizeLabel->setBackColor(color);
  2099.     m_DiscSizeLabel->setHiliteColor(hilite);
  2100.     m_DiscSizeLabel->setShadowColor(shadow);
  2101.     m_DiscTypeLabel->setBackColor(color);
  2102.     m_DiscTypeLabel->setHiliteColor(hilite);
  2103.     m_DiscTypeLabel->setShadowColor(shadow);
  2104.     m_catalogLabel->setBackColor(color);
  2105.     m_catalogLabel->setHiliteColor(hilite);
  2106.     m_catalogLabel->setShadowColor(shadow);
  2107.     m_addTrackLabel->setBackColor(color);
  2108.     m_addTrackLabel->setHiliteColor(hilite);
  2109.     m_addTrackLabel->setShadowColor(shadow);
  2110.     m_trackLabel1->setBackColor(color);
  2111.     m_trackLabel1->setHiliteColor(hilite);
  2112.     m_trackLabel1->setShadowColor(shadow);
  2113.     m_modTrackLabel->setBackColor(color);
  2114.     m_modTrackLabel->setHiliteColor(hilite);
  2115.     m_modTrackLabel->setShadowColor(shadow);
  2116.     m_usedSpaceLabel->setBackColor(color);
  2117.     m_usedSpaceLabel->setHiliteColor(hilite);
  2118.     m_usedSpaceLabel->setShadowColor(shadow);
  2119.     m_freeSpaceLabel->setBackColor(color);
  2120.     m_freeSpaceLabel->setHiliteColor(hilite);
  2121.     m_freeSpaceLabel->setShadowColor(shadow);
  2122.     
  2123.     // set the colors for all text fields
  2124.     m_sizeField->setHiliteColor(hilite);
  2125.     m_sizeField->setShadowColor(shadow);
  2126.     m_typeField->setHiliteColor(hilite);
  2127.     m_typeField->setShadowColor(shadow);
  2128.     m_catalogField->setHiliteColor(hilite);
  2129.     m_catalogField->setShadowColor(shadow);
  2130.     m_usedSpaceField->setHiliteColor(hilite);
  2131.     m_usedSpaceField->setShadowColor(shadow);
  2132.     m_freeSpaceField->setHiliteColor(hilite);
  2133.     m_freeSpaceField->setShadowColor(shadow);
  2134.     
  2135.     // set the colors for all check boxes
  2136.     m_cdTextButton->setBackColor(color);
  2137.     m_cdTextButton->setHiliteColor(hilite);
  2138.     m_cdTextButton->setShadowColor(shadow);
  2139.     
  2140.     // set the colors for all buttons
  2141.     m_editTextBut->setBackColor(color);
  2142.     m_editTextBut->setHiliteColor(hilite);
  2143.     m_editTextBut->setShadowColor(shadow);
  2144.     m_addTrackBut->setBackColor(color);
  2145.     m_addTrackBut->setHiliteColor(hilite);
  2146.     m_addTrackBut->setShadowColor(shadow);
  2147.     m_modTrackBut->setBackColor(color);
  2148.     m_modTrackBut->setHiliteColor(hilite);
  2149.     m_modTrackBut->setShadowColor(shadow);
  2150.     
  2151.     // set the colors for all option menus
  2152.     m_trackOptions->setBackColor(color);
  2153.     m_trackOptions->setHiliteColor(hilite);
  2154.     m_trackOptions->setShadowColor(shadow);
  2155.     m_modTrackOpts->setBackColor(color);
  2156.     m_modTrackOpts->setHiliteColor(hilite);
  2157.     m_modTrackOpts->setShadowColor(shadow);
  2158.     
  2159.     // set the colors for all pop-ups
  2160.     m_cddaPopup->setBackColor(color);
  2161.     m_cddaPopup->setHiliteColor(hilite);
  2162.     m_cddaPopup->setShadowColor(shadow);
  2163.     m_cdromPopup->setBackColor(color);
  2164.     m_cdromPopup->setHiliteColor(hilite);
  2165.     m_cdromPopup->setShadowColor(shadow);
  2166.     m_cdxaPopup->setBackColor(color);
  2167.     m_cdxaPopup->setHiliteColor(hilite);
  2168.     m_cdxaPopup->setShadowColor(shadow);
  2169.     m_modTrackPopup->setBackColor(color);
  2170.     m_modTrackPopup->setHiliteColor(hilite);
  2171.     m_modTrackPopup->setShadowColor(shadow);
  2172.     
  2173.     // set the colors for all options
  2174.     m_cddaAudio->setBackColor(color);
  2175.     m_cddaAudio->setHiliteColor(hilite);
  2176.     m_cddaAudio->setShadowColor(shadow);
  2177.     m_cdromData->setBackColor(color);
  2178.     m_cdromData->setHiliteColor(hilite);
  2179.     m_cdromData->setShadowColor(shadow);
  2180.     m_cdromAudio->setBackColor(color);
  2181.     m_cdromAudio->setHiliteColor(hilite);
  2182.     m_cdromAudio->setShadowColor(shadow);
  2183.     m_cdromRaw->setBackColor(color);
  2184.     m_cdromRaw->setHiliteColor(hilite);
  2185.     m_cdromRaw->setShadowColor(shadow);
  2186.     m_cdxaAudio->setBackColor(color);
  2187.     m_cdxaAudio->setHiliteColor(hilite);
  2188.     m_cdxaAudio->setShadowColor(shadow);
  2189.     m_cdxaData->setBackColor(color);
  2190.     m_cdxaData->setHiliteColor(hilite);
  2191.     m_cdxaData->setShadowColor(shadow);
  2192.     m_cdxaAudio2->setBackColor(color);
  2193.     m_cdxaAudio2->setHiliteColor(hilite);
  2194.     m_cdxaAudio2->setShadowColor(shadow);
  2195.     m_cdxaRaw->setBackColor(color);
  2196.     m_cdxaRaw->setHiliteColor(hilite);
  2197.     m_cdxaRaw->setShadowColor(shadow);
  2198.     m_editTrack->setBackColor(color);
  2199.     m_editTrack->setHiliteColor(hilite);
  2200.     m_editTrack->setShadowColor(shadow);
  2201.     m_deleteTrack->setBackColor(color);
  2202.     m_deleteTrack->setHiliteColor(hilite);
  2203.     m_deleteTrack->setShadowColor(shadow);
  2204.     
  2205.     // set the colors for all spinners
  2206.     m_modTrackNum->fbSetBaseColor(color);
  2207.     m_modTrackNum->fbSetHiliteColor(hilite);
  2208.     m_modTrackNum->fbSetShadowColor(shadow);
  2209. }
  2211. // set the background color for the main window controls
  2212. void CFreeBurn::setMainControlsBackgroundColor(FXColor color)
  2213. {
  2214.     // set the colors for all text fields
  2215.     m_sizeField->setBackColor(color);
  2216.     m_typeField->setBackColor(color);
  2217.     m_catalogField->setBackColor(color);
  2218.     m_usedSpaceField->setBackColor(color);
  2219.     m_freeSpaceField->setBackColor(color);
  2220.     
  2221.     // set the colors for all check boxes
  2222.     m_cdTextButton->setBoxColor(color);    
  2223.     
  2224.     // set the colors for all spinners
  2225.     m_modTrackNum->fbSetBackgroundColor(color);
  2226.     
  2227.     // set the colors for the progress bars
  2228.     m_percentFull->setBarBGColor(color);
  2229. }
  2231. // set the foreground color for the main window controls
  2232. void CFreeBurn::setMainControlsForegroundColor(FXColor color)
  2233. {
  2234.     // set the colors for all group boxes
  2235.     m_Group1->setTextColor(color);
  2236.     m_Group2->setTextColor(color);
  2237.     
  2238.     // set the colors for all labels
  2239.     m_DiscSizeLabel->setTextColor(color);
  2240.     m_DiscTypeLabel->setTextColor(color);
  2241.     m_catalogLabel->setTextColor(color);
  2242.     m_addTrackLabel->setTextColor(color);
  2243.     m_trackLabel1->setTextColor(color);
  2244.     m_modTrackLabel->setTextColor(color);
  2245.     m_usedSpaceLabel->setTextColor(color);
  2246.     m_freeSpaceLabel->setTextColor(color);
  2247.     
  2248.     // set the colors for all text fields
  2249.     m_sizeField->setTextColor(color);
  2250.     m_typeField->setTextColor(color);
  2251.     m_catalogField->setTextColor(color);
  2252.     m_usedSpaceField->setTextColor(color);
  2253.     m_freeSpaceField->setTextColor(color);
  2254.     
  2255.     // set the colors for all check boxes
  2256.     m_cdTextButton->setTextColor(color);    
  2257.     
  2258.     // set the colors for all buttons
  2259.     m_editTextBut->setTextColor(color);
  2260.     m_addTrackBut->setTextColor(color);
  2261.     m_modTrackBut->setTextColor(color);
  2262.     
  2263.     // set the colors for all option menus
  2264.     m_trackOptions->setTextColor(color);
  2265.     m_modTrackOpts->setTextColor(color);
  2266.     
  2267.     // set the colors for all options
  2268.     m_cddaAudio->setTextColor(color);
  2269.     m_cdromData->setTextColor(color);
  2270.     m_cdromAudio->setTextColor(color);
  2271.     m_cdromRaw->setTextColor(color);
  2272.     m_cdxaAudio->setTextColor(color);
  2273.     m_cdxaData->setTextColor(color);
  2274.     m_cdxaAudio2->setTextColor(color);
  2275.     m_cdxaRaw->setTextColor(color);
  2276.     m_editTrack->setTextColor(color);
  2277.     m_deleteTrack->setTextColor(color);
  2278.     
  2279.     // set the colors for all spinners
  2280.     m_modTrackNum->fbSetForegroundColor(color);
  2281. }
  2283. // set the border color for the main window controls
  2284. void CFreeBurn::setMainControlsBorderColor(FXColor color)
  2285. {
  2286.     // set the colors for all vertical frames
  2287.     m_mainFrame->setBorderColor(color);
  2288.     
  2289.     // set the colors for all horizontal frames
  2290.     m_spaceFrame->setBorderColor(color);
  2291.     
  2292.     // set the colors for all group boxes
  2293.     m_Group1->setBorderColor(color);
  2294.     m_Group2->setBorderColor(color);
  2295.     
  2296.     // set the colors for all matricies
  2297.     m_contentMatrix->setBorderColor(color);
  2298.     
  2299.     // set the colors for all labels
  2300.     m_DiscSizeLabel->setBorderColor(color);
  2301.     m_DiscTypeLabel->setBorderColor(color);
  2302.     m_catalogLabel->setBorderColor(color);
  2303.     m_addTrackLabel->setBorderColor(color);
  2304.     m_trackLabel1->setBorderColor(color);
  2305.     m_modTrackLabel->setBorderColor(color);
  2306.     m_usedSpaceLabel->setBorderColor(color);
  2307.     m_freeSpaceLabel->setBorderColor(color);
  2308.     
  2309.     // set the colors for all text fields
  2310.     m_sizeField->setBorderColor(color);
  2311.     m_typeField->setBorderColor(color);
  2312.     m_catalogField->setBorderColor(color);
  2313.     m_usedSpaceField->setBorderColor(color);
  2314.     m_freeSpaceField->setBorderColor(color);
  2315.     
  2316.     // set the colors for all check boxes
  2317.     m_cdTextButton->setBorderColor(color);    
  2318.     
  2319.     // set the colors for all buttons
  2320.     m_editTextBut->setBorderColor(color);
  2321.     m_addTrackBut->setBorderColor(color);
  2322.     m_modTrackBut->setBorderColor(color);
  2323.     
  2324.     // set the colors for all option menus
  2325.     m_trackOptions->setBorderColor(color);
  2326.     m_modTrackOpts->setBorderColor(color);
  2327.     
  2328.     // set the colors for all pop-ups
  2329.     m_cddaPopup->setBorderColor(color);
  2330.     m_cdromPopup->setBorderColor(color);
  2331.     m_cdxaPopup->setBorderColor(color);
  2332.     m_modTrackPopup->setBorderColor(color);
  2333.     
  2334.     // set the colors for all options
  2335.     m_cddaAudio->setBorderColor(color);
  2336.     m_cdromData->setBorderColor(color);
  2337.     m_cdromAudio->setBorderColor(color);
  2338.     m_cdromRaw->setBorderColor(color);
  2339.     m_cdxaAudio->setBorderColor(color);
  2340.     m_cdxaData->setBorderColor(color);
  2341.     m_cdxaAudio2->setBorderColor(color);
  2342.     m_cdxaRaw->setBorderColor(color);
  2343.     m_editTrack->setBorderColor(color);
  2344.     m_deleteTrack->setBorderColor(color);
  2345.     
  2346.     // set the colors for all spinners
  2347.     m_modTrackNum->fbSetBorderColor(color);
  2348. }
  2351. // Save changes to the layout to a .toc file
  2352. FXbool CFreeBurn::saveChanges()
  2353. {
  2354.     FXuint   answer;
  2355.     FXString file;
  2356.     
  2357.     // ask if the user wants to save the unsaved log file
  2358.     answer = FXMessageBox::question(this,MBOX_YES_NO_CANCEL|PLACEMENT_CURSOR,
  2359.         fbSaveChangesTitleText,fbSaveChangesMessageText);
  2360.     
  2361.     // if not, exit
  2362.     if(answer==MBOX_CLICKED_CANCEL) return FALSE;
  2363.     
  2364.     // if yes...
  2365.     if(answer==MBOX_CLICKED_YES)
  2366.     {
  2367.         /*file=m_fileName;
  2368.         
  2369.         // if we don't have a m_fileName, we need to
  2370.         // get a m_fileName.  this is the same process
  2371.         // as the "save as" process.
  2372.         if(!m_haveFileName)
  2373.         {
  2374.             FXFileDialog savedialog(this,"Save Log");
  2375.             savedialog.setSelectMode(SELECTFILE_ANY);
  2376.             savedialog.setPatternList("All Files (*.*)");
  2377.             savedialog.setFilename(file);
  2378.             if(!savedialog.execute()) return FALSE;
  2379.             
  2380.             file=savedialog.getFilename();
  2381.             
  2382.             if(FXFile::exists(file))
  2383.             {
  2384.                 if(MBOX_CLICKED_NO==FXMessageBox::question(this,MBOX_YES_NO,"Overwrite File",
  2385.                     "Overwrite existing file: %s?",file.text())) return FALSE;
  2386.             }
  2387.             file=savedialog.getFilename();
  2388.         }
  2389.         // finally, save the file.
  2390.         saveFile(file);*/
  2391.         FXMessageBox::information(this, MBOX_OK|PLACEMENT_CURSOR, "Saving Unimplemented", 
  2392.             "Saving files has not yet been implemented.");
  2393.     }
  2394.     // success
  2395.     return TRUE;
  2396. }
  2398. // method to close out and delete any current disc settings
  2399. FXbool CFreeBurn::closeDisc()
  2400. {
  2401.     if (m_discExists)
  2402.     {
  2403.         // delete/clear any data from the old layout
  2404.         delete m_mainDisc;
  2405.     
  2406.         // reset the settings of the layout flags
  2407.         m_discExists = FALSE;
  2408.         m_discSaved  = TRUE;
  2409.     }
  2410.     
  2411.     return TRUE;
  2412. }
  2414. // Read the settings for the FreeBurn theme from the registry to set up icons and stuff
  2415. void CFreeBurn::readThemeSettings()
  2416. {
  2417.     m_theme = getApp()->reg().readIntEntry(fbRegSectionProgramText, fbRegPropertyThemeText, DEFAULT_THEME);
  2418. }
  2420. // Read registry settings for the application
  2421. void CFreeBurn::readProgramSettings()
  2422. {
  2423.     // read the position and height/width settings from the registry
  2424.     m_xpos   = getApp()->reg().readIntEntry(fbRegSectionProgramText, fbRegPropertyXposText,   FB_XPOS);
  2425.     m_ypos   = getApp()->reg().readIntEntry(fbRegSectionProgramText, fbRegPropertyYposText,   FB_YPOS);
  2426.     m_width  = getApp()->reg().readIntEntry(fbRegSectionProgramText, fbRegPropertyWidthText,  FB_WIDTH);
  2427.     m_height = getApp()->reg().readIntEntry(fbRegSectionProgramText, fbRegPropertyHeightText, FB_HEIGHT);
  2428.     
  2429.     // read the path to commands from the registry
  2430.     m_shellPath    = getApp()->reg().readStringEntry(fbRegSectionCommandPathsText, 
  2431.         fbRegPropertyShellPathText,    fbRegDefaultShellPathText);
  2432.     m_cdrecordPath = getApp()->reg().readStringEntry(fbRegSectionCommandPathsText, 
  2433.         fbRegPropertyCdrecordPathText, fbRegDefaultCdrecordPathText);
  2434.     m_mkisofsPath  = getApp()->reg().readStringEntry(fbRegSectionCommandPathsText, 
  2435.         fbRegPropertyMkisofsPathText,  fbRegDefaultMkisofsPathText);
  2436.     m_cdrdaoPath   = getApp()->reg().readStringEntry(fbRegSectionCommandPathsText, 
  2437.         fbRegPropertyCdrdaoPathText,   fbRegDefaultCdrdaoPathText);
  2438.     
  2439.     // Set the program options that were read from the registry
  2440.     // The x -4 offset and the y -27 offset are to account for a 
  2441.     // slightly off saving of the x and y attributes of the window,
  2442.     // so the window will come up where it should
  2443.     position((m_xpos-4),(m_ypos-27),m_width,m_height);    
  2444. }
  2446. // Write registry settings for the application
  2447. void CFreeBurn::writeProgramSettings()
  2448. {
  2449.     // write the current program theme to the registry
  2450.     getApp()->reg().writeIntEntry(fbRegSectionProgramText, fbRegPropertyThemeText, m_theme);
  2451.     
  2452.     // write the position, height, and width settings to the registry
  2453.     getApp()->reg().writeIntEntry(fbRegSectionProgramText, fbRegPropertyXposText,   getX());
  2454.     getApp()->reg().writeIntEntry(fbRegSectionProgramText, fbRegPropertyYposText,   getY());
  2455.     getApp()->reg().writeIntEntry(fbRegSectionProgramText, fbRegPropertyWidthText,  getWidth());
  2456.     getApp()->reg().writeIntEntry(fbRegSectionProgramText, fbRegPropertyHeightText, getHeight());
  2457.     
  2458.     // write the external program paths to the registry
  2459.     getApp()->reg().writeStringEntry(fbRegSectionCommandPathsText, 
  2460.         fbRegPropertyShellPathText,    m_shellPath.text());
  2461.     getApp()->reg().writeStringEntry(fbRegSectionCommandPathsText, 
  2462.         fbRegPropertyCdrecordPathText, m_cdrecordPath.text());
  2463.     getApp()->reg().writeStringEntry(fbRegSectionCommandPathsText, 
  2464.         fbRegPropertyMkisofsPathText,  m_mkisofsPath.text());
  2465.     getApp()->reg().writeStringEntry(fbRegSectionCommandPathsText, 
  2466.         fbRegPropertyCdrdaoPathText,   m_cdrdaoPath.text());
  2467. }
  2469. // Main program starts here
  2470. int main(int argc,char *argv[])
  2471. {
  2472.     // Make application
  2473.     FXApp application(FB_APP_NAME,FB_VENDOR_NAME);
  2474.     
  2475.     // set the Registry mode to use a text file, 
  2476.     // and not the Windows Registry
  2477.     application.reg().setAsciiMode(TRUE);
  2479.     // Start app
  2480.     application.init(argc,argv);
  2482.     // the main program window
  2483.     CFreeBurn* fb = new CFreeBurn(&application);
  2484.     
  2485.     // now, add the process/thread event handlers since we're going to
  2486.     // be using external programs a lot to make FreeBurn work good
  2487.     
  2488.     // This event handler will handle the event that lets the app know it can
  2489.     // read a string that was output from the process
  2490.     application.addInput(fb->getReadOutputHandle(),     INPUT_EXCEPT, fb, CFreeBurn::ID_GET_THREAD_BUFFER);
  2491.     // This event handler lets the app know that the process is done, so the buttons can be
  2492.     // re-enabled.
  2493.     application.addInput(fb->getThreadCompleteHandle(), INPUT_EXCEPT, fb, CFreeBurn::ID_THREAD_COMPLETE);
  2495.     // Create the application's windows
  2496.     application.create();
  2497.   
  2498.     // Run the application
  2499.     return application.run();
  2500. }