home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1998 May / Pcwk5b98.iso / Borland / Cplus45 / BC45 / POPUP.PAK / POPUP.CPP < prev    next >
C/C++ Source or Header  |  1995-08-29  |  6KB  |  228 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectWindows - (C) Copyright 1991, 1993 by Borland International
  3. //----------------------------------------------------------------------------
  4. #include <owl\owlpch.h>
  5. #include <owl\applicat.h>
  6. #include <owl\framewin.h>
  7. #include <string.h>
  8. #include <owl\dc.h>
  9.  
  10. const int CM_WINDOW = 100;                // base id for different windows.
  11.  
  12. class TSubWindow : public TFrameWindow {
  13.   public:
  14.     enum TType { Child, PopParent, PopNoParent };
  15.  
  16.     TSubWindow(TWindow* parent, TType type);
  17.    ~TSubWindow();
  18.  
  19.   protected:
  20.     void EvSize(UINT sizeType, TSize& size)
  21.       {Invalidate(); TFrameWindow::EvSize(sizeType, size);}
  22.     void Paint(TDC& dc, BOOL, TRect&);
  23.  
  24.   private:
  25.     TType Type;
  26.  
  27.   DECLARE_RESPONSE_TABLE(TSubWindow);
  28. };
  29.  
  30. DEFINE_RESPONSE_TABLE1(TSubWindow, TFrameWindow)
  31.   EV_WM_SIZE,
  32. END_RESPONSE_TABLE;
  33.  
  34. // pointers to different child windows.
  35. //
  36. TWindow* SubWinPtr[] = { 0, 0, 0 };       
  37.  
  38. // Titles for the different child windows.
  39. //
  40. const char* SubWinTitle[] = {
  41.   "Child Window", "Popup with Parent", "Popup without Parent"
  42. };
  43.  
  44. // How the different child windows will be created.
  45. //
  46. long SubWinStyle[] = {
  47.   WS_VISIBLE | WS_CHILD | WS_CAPTION | WS_BORDER
  48.              | WS_SYSMENU | WS_MINIMIZEBOX | WS_THICKFRAME,
  49.   WS_VISIBLE | WS_POPUP | WS_OVERLAPPEDWINDOW,
  50.   WS_VISIBLE | WS_POPUP | WS_OVERLAPPEDWINDOW
  51. };
  52.  
  53. // Initial position of child windows.
  54. //
  55. TPoint SubWinPos[] = {
  56.   TPoint(10, 10),
  57.   TPoint(34, 72),
  58.   TPoint(54, 92)
  59. };
  60.  
  61. // Some text to be display in the client area of the child windows.
  62. //
  63. const char* SubWinText[] = {
  64.   "Child windows cannot be moved outside their parent window.  When " \
  65.     "minimized, a child window's icon resides within the parent " \
  66.     "window.",
  67.   "Popup windows can be moved outside their parent window.  A popup " \
  68.     "with a parent is always displayed in front of the parent, " \
  69.     "even when the parent is focused.  To test this, click on the " \
  70.     "parent window.  When minimized, popup icons reside on the desktop.",
  71.   "Popup windows can be moved outside their parent window.  A popup " \
  72.     "without a parent allows the parent to be brought to the front " \
  73.     "when focused. To test this, click on the parent window.  When " \
  74.     "minimized, popup icons reside on the desktop."
  75. };
  76.  
  77. //
  78. // Create window of specified type, indicated by 'type'.
  79. // Title and position of window set according to value of 'type'.
  80. //
  81. TSubWindow::TSubWindow(TWindow* parent, TType type)
  82.   : TFrameWindow(parent, SubWinTitle[type]),
  83.     Type(type)
  84. {
  85.   Attr.Style = SubWinStyle[Type];
  86.   Attr.X = SubWinPos[Type].x;
  87.   Attr.Y = SubWinPos[Type].y;
  88.   Attr.W = 300;
  89.   Attr.H = 150;
  90. }
  91.  
  92. //
  93. // Destroy window.  SubWinPtr[Type] is set to 0 to indicate that the window
  94. // has be closed.
  95. //
  96. TSubWindow::~TSubWindow()
  97. {
  98.   SubWinPtr[Type] = 0;
  99. }
  100.  
  101. //
  102. // Draw help text in client are of window.
  103. //
  104. void
  105. TSubWindow::Paint(TDC& dc, BOOL, TRect&)
  106. {
  107.   TRect rect = GetClientRect();
  108.   rect.Inflate(-2, 0);
  109.   dc.DrawText(SubWinText[Type], strlen(SubWinText[Type]), rect, DT_WORDBREAK);
  110. }
  111.  
  112. //----------------------------------------------------------------------------
  113.  
  114. class TMainWindow : public TFrameWindow {
  115.   public:
  116.     TMainWindow(const char* title);
  117.  
  118.     void ShowSubWindow(TWindow* parent, TSubWindow::TType type);
  119.     void EvInitMenu(HMENU menu);
  120.     void CmChild();
  121.     void CmPopParent();
  122.     void CmPopNoParent();
  123.  
  124.   DECLARE_RESPONSE_TABLE(TMainWindow);
  125. };
  126.  
  127. DEFINE_RESPONSE_TABLE1(TMainWindow, TFrameWindow)
  128.   EV_WM_INITMENU,
  129.   EV_COMMAND(CM_WINDOW + TSubWindow::Child, CmChild),
  130.   EV_COMMAND(CM_WINDOW + TSubWindow::PopParent, CmPopParent),
  131.   EV_COMMAND(CM_WINDOW + TSubWindow::PopNoParent, CmPopNoParent),
  132. END_RESPONSE_TABLE;
  133.  
  134. TMainWindow::TMainWindow(const char* title)
  135.   : TFrameWindow(0, title),
  136.     TWindow(0, title)
  137. {
  138.   Attr.X = 0;
  139.   Attr.Y = 0;
  140.   Attr.W = 400;
  141.   Attr.H = 215;
  142.   AssignMenu("COMMANDS");
  143. }
  144.  
  145. //
  146. // Create sub-window.  If sub-window, specified by 'type', does not exist
  147. // then create it, else make the sub-window the active window.
  148. //
  149. void
  150. TMainWindow::ShowSubWindow(TWindow* parent, TSubWindow::TType type)
  151. {
  152.   if (!SubWinPtr[type])
  153.     (SubWinPtr[type] = new TSubWindow(parent, type))->Create();
  154.  
  155.   else {
  156.     SubWinPtr[type]->SetFocus();
  157.     SubWinPtr[type]->SetActiveWindow();
  158.   }
  159. }
  160.  
  161. //
  162. // Setup menu state.  If sub-window has been created then then check that
  163. // menu item, else uncheck it.
  164. //
  165. void
  166. TMainWindow::EvInitMenu(HMENU menu)
  167. {
  168.   for (int i = TSubWindow::Child; i <= TSubWindow::PopNoParent; i++) {
  169.     WORD state;
  170.     if (!SubWinPtr[i])
  171.       state = MF_UNCHECKED;
  172.     else
  173.       state = MF_CHECKED;
  174.     ::CheckMenuItem(menu, CM_WINDOW + i, state);
  175.   }
  176. }
  177.  
  178. //
  179. // Create the different child windows...
  180. //
  181.  
  182. void
  183. TMainWindow::CmChild()
  184. {
  185.   ShowSubWindow(this, TSubWindow::Child);
  186. }
  187.  
  188. void
  189. TMainWindow::CmPopParent()
  190. {
  191.   ShowSubWindow(this, TSubWindow::PopParent);
  192. }
  193.  
  194. void
  195. TMainWindow::CmPopNoParent()
  196. {
  197.   ShowSubWindow(0, TSubWindow::PopNoParent);
  198. }
  199.  
  200. //----------------------------------------------------------------------------
  201.  
  202. class TPopupApp : public TApplication {
  203.   public:
  204.     TPopupApp() : TApplication("Popup") {}
  205.     void InitMainWindow()
  206.                      {MainWindow = new TMainWindow("Parent Window");}
  207.  
  208.     BOOL CanClose();
  209. };
  210.  
  211. BOOL
  212. TPopupApp::CanClose()
  213. {
  214.    // In order to avoid debugging kernel warning messages, ensure that
  215.    // the parentless popup window is destroyed before exiting the
  216.    // application.
  217.    //
  218.    if (SubWinPtr[TSubWindow::PopNoParent])
  219.       SubWinPtr[TSubWindow::PopNoParent]->ShutDownWindow();
  220.    return TRUE;
  221. }
  222.  
  223. int
  224. OwlMain(int /*argc*/, char* /*argv*/ [])
  225. {
  226.   return TPopupApp().Run();
  227. }
  228.