home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1998 May / Pcwk5b98.iso / Borland / Cplus45 / BC45 / CMDENABL.PAK / CMDENAB4.CPP < prev    next >
C/C++ Source or Header  |  1995-08-29  |  6KB  |  202 lines
  1. //----------------------------------------------------------------------------
  2. //  ObjectWindows - (C) Copyright 1994 by Borland International
  3. //    Command-enabling sample application
  4. //    Fourth version adds a tool bar.
  5. //----------------------------------------------------------------------------
  6. #include <owl/owlpch.h>
  7. #include <owl/applicat.h>
  8. #include <owl/framewin.h>
  9. #include "cmdenabl.h"
  10. #include <owl/decframe.h>
  11. #include <owl/controlb.h>
  12. #include <owl/buttonga.h>
  13. #include <owl/statusba.h>
  14.  
  15. //  Class definitions:
  16. //  TCmdEnableApp -- application object initializes TApplication, overrides
  17. //    InitMainWindow.
  18. class TCmdEnableApp : public TApplication
  19. {
  20.   public:
  21.     TCmdEnableApp() : TApplication() {}
  22.   protected:
  23.     void InitMainWindow();
  24. };
  25.  
  26. //  TCmdEnableWindow -- window object initializes TWindow, adds four event
  27. //    handlers, adds response table for four events.
  28. class TCmdEnableWindow : public TWindow {
  29.   public:
  30.     TCmdEnableWindow(TWindow* parent = 0);
  31.  
  32.   protected:
  33.     bool isDirty;
  34.     bool isNewFile;
  35.  
  36.     // Event handlers
  37.     void CmFileNew();
  38.     void CmFileOpen();
  39.     void CmFileSave();
  40.     void CmFileSaveAs();
  41.     void CmToggleDirty();
  42.     void CmToggleNew();
  43.     void CmShowState();
  44.  
  45.     // Command-enabling functions
  46.     void CeFileNew(TCommandEnabler&);
  47.     void CeFileOpen(TCommandEnabler&);
  48.     void CeFileSave(TCommandEnabler&);
  49.     void CeToggleDirty(TCommandEnabler&);
  50.     void CeToggleNew(TCommandEnabler&);
  51.  
  52.     DECLARE_RESPONSE_TABLE(TCmdEnableWindow);
  53. };
  54.  
  55. DEFINE_RESPONSE_TABLE1(TCmdEnableWindow, TWindow)
  56.   EV_COMMAND(CM_FILENEW, CmFileNew),
  57.   EV_COMMAND(CM_FILEOPEN, CmFileOpen),
  58.   EV_COMMAND(CM_FILESAVE, CmFileSave),
  59.   EV_COMMAND(CM_FILESAVEAS, CmFileSaveAs),
  60.   EV_COMMAND(CM_TOGGLEDIRTY, CmToggleDirty),
  61.   EV_COMMAND(CM_TOGGLENEW, CmToggleNew),
  62.   EV_COMMAND(CM_SHOWSTATE, CmShowState),
  63.   EV_COMMAND_ENABLE(CM_FILENEW, CeFileNew),
  64.   EV_COMMAND_ENABLE(CM_FILEOPEN, CeFileOpen),
  65.   EV_COMMAND_ENABLE(CM_FILESAVE, CeFileSave),
  66.   EV_COMMAND_ENABLE(CM_TOGGLEDIRTY, CeToggleDirty),
  67.   EV_COMMAND_ENABLE(CM_TOGGLENEW, CeToggleNew),
  68. END_RESPONSE_TABLE;
  69.  
  70. // Put the OwlMain here just to get it out of the way
  71. int OwlMain(int /*argc*/, char* /*argv*/ [])
  72. {
  73.   return TCmdEnableApp().Run();
  74. }
  75.  
  76. //  Class function definitions
  77. //  class TCmdEnableApp
  78. //  TCmdEnableApp::InitMainWindow
  79. void
  80. TCmdEnableApp::InitMainWindow()
  81. {
  82.   // Construct the decorated frame window
  83.   TDecoratedFrame* frame = new TDecoratedFrame(0, "Command-enabling sample application", new TCmdEnableWindow, true);
  84.  
  85.   // Construct a control bar
  86.   TControlBar *cb = new TControlBar(frame);
  87.   cb->Insert(*new TButtonGadget(CM_FILENEW, CM_FILENEW, TButtonGadget::Command));
  88.   cb->Insert(*new TButtonGadget(CM_FILEOPEN, CM_FILEOPEN, TButtonGadget::Command));
  89.   cb->Insert(*new TButtonGadget(CM_FILESAVE, CM_FILESAVE, TButtonGadget::Command));
  90.   cb->Insert(*new TButtonGadget(CM_FILESAVEAS, CM_FILESAVEAS, TButtonGadget::Command));
  91.   cb->Insert(*new TSeparatorGadget);
  92.   cb->Insert(*new TButtonGadget(CM_TOGGLEDIRTY, CM_TOGGLEDIRTY, TButtonGadget::NonExclusive));
  93.   cb->Insert(*new TButtonGadget(CM_TOGGLENEW, CM_TOGGLENEW, TButtonGadget::NonExclusive));
  94.   cb->Insert(*new TButtonGadget(CM_SHOWSTATE, CM_SHOWSTATE, TButtonGadget::Command));
  95.  
  96.   // Turn hints on to fly-over
  97.   cb->SetHintMode(TGadgetWindow::EnterHints);
  98.  
  99.   // Create a status bar
  100.   TStatusBar *sb = new TStatusBar(frame);
  101.  
  102.   // Insert the control bar and status bar into the frame
  103.   frame->Insert(*cb, TDecoratedFrame::Top);
  104.   frame->Insert(*sb, TDecoratedFrame::Bottom);
  105.  
  106.   // Set the main window and its menu
  107.   SetMainWindow(frame);
  108.   GetMainWindow()->AssignMenu("COMMANDS");
  109. }
  110.  
  111. TCmdEnableWindow::TCmdEnableWindow(TWindow *parent) : TWindow(parent)
  112. {
  113.   isNewFile = true;
  114.   isDirty = false;
  115. }
  116.  
  117. void
  118. TCmdEnableWindow::CmFileNew()
  119. {
  120.   isDirty=false;
  121.   isNewFile=true;
  122.   MessageBox("Opened a new file.\nisDirty=false\nisNewFile=true", "File action taken");
  123. }
  124.  
  125. void
  126. TCmdEnableWindow::CmFileOpen()
  127. {
  128.   isDirty=false;
  129.   isNewFile=false;
  130.   MessageBox("Opened an existing file.\nisDirty=false\nisNewFile=false", "File action taken");
  131. }
  132.  
  133. void
  134. TCmdEnableWindow::CmFileSave()
  135. {
  136.   isDirty=false;
  137.   isNewFile=false;
  138.   MessageBox("Saved an existing file.\nisDirty=false\nisNewFile=false", "File action taken");
  139. }
  140.  
  141. void
  142. TCmdEnableWindow::CmFileSaveAs()
  143. {
  144.   isDirty=false;
  145.   isNewFile=false;
  146.   MessageBox("Saved a file under a new name.\nisDirty=false\nisNewFile=false", "File action taken");
  147. }
  148.  
  149. void
  150. TCmdEnableWindow::CmToggleDirty()
  151. {
  152.   isDirty=!isDirty;
  153. }
  154.  
  155. void
  156. TCmdEnableWindow::CmToggleNew()
  157. {
  158.   isNewFile=!isNewFile;
  159. }
  160.  
  161.  
  162. void
  163. TCmdEnableWindow::CmShowState()
  164. {
  165.   string str(isDirty ? "isDirty = true\n" : "isDirty = false\n");
  166.   str += (isNewFile ? "isNewFile = true" : "isNewFile = false");
  167.   MessageBox(str.c_str(), "Current state");
  168. }
  169.  
  170. void
  171. TCmdEnableWindow::CeFileNew(TCommandEnabler& ce)
  172. {
  173.   // Enable CmFileNew if not dirty
  174.   ce.Enable(!isDirty);
  175. }
  176.  
  177. void
  178. TCmdEnableWindow::CeFileOpen(TCommandEnabler& ce)
  179. {
  180.   // Enable CmFileOpen if not dirty
  181.   ce.Enable(!isDirty);
  182. }
  183.  
  184. void
  185. TCmdEnableWindow::CeFileSave(TCommandEnabler& ce)
  186. {
  187.   // Enable CmFileSave if not new file and is dirty.
  188.   ce.Enable(!isNewFile && isDirty);
  189. }
  190.  
  191. void
  192. TCmdEnableWindow::CeToggleDirty(TCommandEnabler& ce)
  193. {
  194.   ce.SetCheck(isDirty ? TCommandEnabler::Checked : TCommandEnabler::Unchecked);
  195. }
  196.  
  197. void
  198. TCmdEnableWindow::CeToggleNew(TCommandEnabler& ce)
  199. {
  200.   ce.SetCheck(isNewFile ? TCommandEnabler::Checked : TCommandEnabler::Unchecked);
  201. }
  202.