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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
windows.cxx
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：35k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

windows.cxx：源码内容
  1. /*
  2.  * windows.cxx
  3.  *
  4.  * Resource compiler MS-Windows resource binary file generator
  5.  *
  6.  * Portable Windows Library
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  * Contributor(s): ______________________________________.
  28.  *
  29.  * $Log: windows.cxx,v $
  30.  * Revision 1.36  2000/06/21 03:15:24  robertj
  31.  * Added ability to append resources to existing file.
  32.  *
  33.  * Revision 1.35  1999/07/27 09:48:13  robertj
  34.  * Removed warning.
  35.  *
  36.  * Revision 1.34  1998/12/23 01:16:15  robertj
  37.  * New directory structure
  38.  *
  39.  * Revision 1.33  1998/09/26 01:24:23  robertj
  40.  * Added open source license
  41.  *
  42.  * Revision 1.32  1998/09/26 01:00:35  robertj
  43.  * Fixed X Windows name conflict.
  44.  *
  45.  * Revision 1.31  1998/09/14 13:54:56  robertj
  46.  * Fixed ansi to unicode conversion in resource output.
  47.  * Added tab stops to list boxes.
  48.  * Fixed group boxes (PStaticBox) so is clipped to specified size allowing single lines.
  49.  *
  50.  * Revision 1.30  1996/01/23 13:26:35  robertj
  51.  * Changed resource ID mechanism.
  52.  *
  53.  * Revision 1.29  1996/01/02 13:06:02  robertj
  54.  * Changes to support editor.
  55.  *
  56.  * Revision 1.28  1995/12/23 03:53:03  robertj
  57.  * Removed multiple classes for layout types.
  58.  *
  59.  * Revision 1.27  1995/12/10 12:12:10  robertj
  60.  * Changes to support graphical resource file editor.
  61.  *
  62.  * Revision 1.26  1995/08/24 12:52:49  robertj
  63.  * Added general control type for arbitrary dialog controls.
  64.  * Added output file extension variable.
  65.  *
  66.  * Revision 1.25  1995/07/02 06:24:24  robertj
  67.  * Fixed bug with menu accelerators resource in WIN32.
  68.  *
  69.  * Revision 1.24  1995/04/22 01:04:29  robertj
  70.  * Fixed styles for controls in WIN16.
  71.  *
  72.  * Revision 1.23  1995/04/02 09:28:18  robertj
  73.  * Added "balloon" help.
  74.  *
  75.  * Revision 1.22  1995/03/22 13:58:25  robertj
  76.  * Fixed bug in colour table in resource images, icons etc.
  77.  *
  78.  * Revision 1.21  1995/02/11  04:15:14  robertj
  79.  * Strange problem with variable "small" in MSVC 2.0.
  80.  *
  81.  * Revision 1.20  1995/01/27  11:25:54  robertj
  82.  * Added pattern resource.
  83.  *
  84.  * Revision 1.19  1995/01/11  09:45:22  robertj
  85.  * Documentation and normalisation.
  86.  *
  87.  * Revision 1.18  1994/12/12  13:14:08  robertj
  88.  * Changed RealEdit to FloatEdit.
  89.  *
  90.  * Revision 1.17  1994/10/30  11:30:39  robertj
  91.  * Fixed standard get directory dialog resource.
  92.  *
  93.  * Revision 1.16  1994/10/23  06:09:03  robertj
  94.  * Changed TextEditor so return does not close dialogs.
  95.  *
  96.  * Revision 1.15  1994/08/22  00:23:54  robertj
  97.  * Fixed bug in standard get directory dialog.
  98.  *
  99.  * Revision 1.14  1994/07/02  03:25:39  robertj
  100.  * Fixed bug.
  101.  *
  102.  * Revision 1.13  1994/06/25  12:16:28  robertj
  103.  * Synchonsiation with unix implementation.
  104.  *
  105.  * Revision 1.12  1994/04/03  08:37:00  robertj
  106.  * *** empty log message ***
  107.  *
  108.  * Revision 1.11  1994/04/01  14:29:16  robertj
  109.  * New format PRC file
  110.  *
  111.  * Revision 1.10  1994/01/03  04:34:30  robertj
  112.  * Changed scan lines in internal structure to top to bottom.
  113.  *
  114.  * Revision 1.9  1993/12/31  07:05:07  robertj
  115.  * Changed pixmap images for one pixel one number in PRC file.
  116.  *
  117.  * Revision 1.8  1993/12/14  18:54:42  robertj
  118.  * WIN32 port.
  119.  *
  120.  * Revision 1.7  1993/08/20  21:31:56  robertj
  121.  * Fixed bug in extra byte in bitmap image raster data.
  122.  *
  123.  * Revision 1.7  1993/08/10  13:08:09  robertj
  124.  * Fixed bug with extra byte in bitmap image scan lines.
  125.  *
  126.  * Revision 1.6  1993/07/17  02:57:00  robertj
  127.  * Further implementation
  128.  *
  129.  * Revision 1.5  1993/07/16  14:48:43  robertj
  130.  * Fixed header comment.
  131.  * Fixed DWORD padding on scan lines in bitmaps.
  132.  *
  133.  * Revision 1.4  1993/07/16  12:53:12  robertj
  134.  * Added converted form of C literal string to resource objects.
  135.  * Changed DIALOGSTRINGS resource format to be more usefull.
  136.  *
  137.  * Revision 1.3  1993/07/15  04:38:31  robertj
  138.  * Rationalised lex.h, parse.h and main.h out of existance.
  139.  *
  140.  * Revision 1.2  1993/07/14  01:57:48  robertj
  141.  * Fixed bug in not getting long alignment in bitmaps.
  142.  *
  143.  * Revision 1.1  1993/07/03  06:00:47  robertj
  144.  * Initial revision
  145.  *
  146.  */
  148. #include <ptlib.h>
  149. #ifndef WIN32
  150. #undef NEAR
  151. #endif
  152. #include <windows.h>
  153. #include <fcntl.h>
  155. #include "pwrc.h"
  156. #include "pwlib/stdresid.h"
  159. #define DIALOGSTRINGS "DIALOGSTRINGS"
  161. PString OutputExtension(".res");
  162. PString CxxExtension(".cxx");
  164. static enum { OutputMenus, CountAccelerators, OutputAccelerators } MenuPass;
  165. static int HasAccelerators;
  166. static BYTE LastAcceleratorFlags;
  167. static BOOL LastMenu;
  169. static BOOL OutputDialogStrings;
  170. static BYTE DialogControlCode;
  171. static DWORD DialogControlStyle;
  173. static enum {
  174.   BilevelIcon,
  175.   BilevelCursor,
  176.   ColourIcon,
  177.   ColourCursor,
  178.   PixmapImage,
  179.   IconDirMap,
  180.   CursorDirMap
  181. } OutputIconCursor;
  182. static WORD IconCursorID;
  184. static int PixDataWidth;
  185. static int PixDataDepth;
  188. //////////////////////////////////////////////////////////////////////////////
  189. // Support classes for binary stream output
  191. class BinByte {
  192.   public:
  193.     inline BinByte(int nb)
  194.       : b((char)nb) { }
  195.     inline friend ostream & operator<<(ostream & out, const BinByte & b)
  196.       { out.put(b.b); return out; }
  197.   protected:
  198.     char b;
  199. };
  201. class BinWord {
  202.   public:
  203.     inline BinWord(int nw)
  204.       : w((short)nw) { }
  205.     inline friend ostream & operator<<(ostream & out, const BinWord & w)
  206.       { out.write((char *)&w.w, sizeof(w.w)); return out; }
  207.   protected:
  208.     short w;
  209. };
  211. #ifdef WIN32
  212. #define BinTextChar BinWord
  213. #else
  214. #define BinTextChar BinByte
  215. #endif
  217. class BinLong {
  218.   public:
  219.     inline BinLong(long nl)
  220.       : l(nl) { }
  221.     inline friend ostream & operator<<(ostream & out, const BinLong & l)
  222.       { out.write((char *)&l.l, sizeof(l.l)); return out; }
  223.   protected:
  224.     long l;
  225. };
  227. class BinStr {
  228.   public:
  229.     inline BinStr(const PString & str)
  230.       : s(str) { }
  231.     friend ostream & operator<<(ostream & out, const BinStr & s);
  232.   protected:
  233.     PString s;
  234. };
  237. static int ConvertAnsiToUnicode(const PString & s, PWORDArray & unicode)
  238. {
  239.   int len = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, s, s.GetLength(), NULL, 0);
  240.   MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, s, -1, unicode.GetPointer(len), len);
  241.   return len;
  242. }
  245. ostream & operator<<(ostream & out, const BinStr & s)
  246. {
  247. #ifdef WIN32
  248.   PWORDArray wide;
  249.   int len = ConvertAnsiToUnicode(s.s, wide);
  250.   for (int i = 0; i < len; i++)
  251.     out << BinWord(wide[i]);
  252.   return out << BinWord(0);
  253. #else
  254.   return out << s.s << BinByte(0);
  255. #endif
  256. }
  259. class ResHdr {
  260.   public:
  261.     inline ResHdr(int rType, int rId)
  262.       : type((short)rType), id((short)rId), lenpos(-1) { }
  263.     inline ResHdr(const PString & rType, int rId)
  264.       : sType(rType), id((short)rId), lenpos(-1) { }
  265.     inline void SetType(int rType)
  266.       { type = (short)rType; }
  267.     inline void SetType(const PString & rType)
  268.       { sType = rType; }
  269.     friend ostream & operator<<(ostream & out, ResHdr & h);
  270.   protected:
  271.     short type, id;
  272.     PString sType;
  273.     streampos lenpos;
  274.     streampos endhdrpos;
  275. };
  278. ostream & operator<<(ostream & out, ResHdr & h)
  279. {
  280.   if (h.lenpos != -1) {
  281.     BinLong len = out.tellp() - h.endhdrpos;
  282.     out.seekp(h.lenpos);
  283.     out << len;
  284. #ifdef WIN32
  285.     out << BinLong(h.endhdrpos - h.lenpos);
  286. #endif
  287.     out.seekp(0, ios::end);
  288.   }
  289.   else {
  290. #ifdef WIN32
  291.     while (((h.lenpos = out.tellp())&3) != 0) // Align to long
  292.       out.put('');
  293.     out << BinLong(0) << BinLong(0);
  294.     if (h.sType.IsEmpty())
  295.       out << BinWord(0xffff) << BinWord(h.type);
  296.     else
  297.       out << BinStr(h.sType);
  298.     out << BinWord(0xffff) << BinWord(h.id);
  299.     while ((out.tellp()&3) != 0) // Align to long
  300.       out.put('');
  301.     out << BinLong(0) << BinLong(0x04091030) << BinLong(0) << BinLong(0);
  302. #else
  303.     if (h.sType.IsEmpty())
  304.       out << BinByte(0xffff) << BinWord(h.type);
  305.     else
  306.       out << h.sType << BinByte(0);
  307.     out << BinByte(0xff) << BinWord(h.id) << BinWord(0x1030);
  308.     h.lenpos = out.tellp();
  309.     out << BinLong(0);
  310. #endif
  311.     h.endhdrpos = out.tellp();
  312.   }
  313.   return out;
  314. }
  317. ///////////////////////////////////////////////////////////////
  318. //
  319. //  StringDict::PrintOn
  320. //
  322. void StringDict::PrintOn(ostream & out) const
  323. {
  324.   char set[4096/8];
  325.   memset(set, 0, sizeof(set));
  326.   for (int i = 0; i < GetSize(); i++) {
  327.     unsigned id = (unsigned)GetKeyAt(i) >> 4;
  328.     set[id>>3] |= 1 << (id&7);
  329.   }
  331.   for (i = 0; i < 4096; i++) {
  332.     if ((set[i>>3]&(1<<(i&7))) != 0) {
  333.       ResHdr hdr(6, i+1);
  334.       out << hdr;
  335.       for (int j = 0; j < 16; j++) {
  336.         ResourceObject * res;
  337.         if ((res = (ResourceObject *)GetAt(i*16+j)) == NULL)
  338.           out << BinTextChar(0);
  339.         else {
  340. #ifdef WIN32
  341.           PWORDArray wide;
  342.           int len = ConvertAnsiToUnicode(res->GetConvertedText(), wide);
  343.           out << BinWord(len);
  344.           for (int k = 0; k < len; k++)
  345.             out << BinWord(wide[k]);
  346. #else
  347.           out << BinByte(res->GetConvertedText().GetLength()) << res->GetConvertedText();
  348. #endif
  349.         }
  350.       }
  351.       out << hdr;
  352.     }
  353.   }
  354. }
  357. ///////////////////////////////////////////////////////////////
  358. //
  359. //  MenuItem::PrintOn
  360. //
  362. void MenuItem::PrintOn(ostream & out) const
  364. {
  365.   switch (MenuPass) {
  366.     case OutputMenus :
  367.       out << BinWord(LastMenu ? (WORD)MF_END : 0) << BinWord(id);
  368.       if (accel.IsEmpty() || accel[0].GetValue() < PKeyCode::A ||
  369.                              accel[0].GetValue() > PKeyCode::Space)
  370.         out << BinStr(textConverted);
  371.       else {
  372.         static char *ValueStrings[] = {
  373.           NULL, NULL, NULL, NULL,
  374.           "A","B","C","D","E","F","G","H","I","J","K","L","M",
  375.           "N","O","P","Q","R","S","T","U","V","W","X","Y","Z",
  376.           "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
  377.           "NumPad0", "NumPad1", "NumPad2", "NumPad3", "NumPad4",
  378.           "NumPad5", "NumPad6", "NumPad7", "NumPad8", "NumPad9",
  379.           "NumPad+", "NumPad-", "NumPad*", "NumPad/", "NumPad,", "NumPad.",
  380.           "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10","F11","F12",
  381.           "F13","F14","F15","F16","F17","F18","F19","F20","F21","F22","F23","F24",
  382.           "Up", "Down", "Left", "Right", "PgUp", "PgDn", "Home", "End",
  383.           "Ins", "Del", "Undo", "Cut", "Copy", "Paste", "Clear", "Cancel", "Help", "Quit",
  384.           "BkSp", "Tab", "Enter", "Esc", "Space"
  385.         };
  386.         static int ModifierOrder[] = {
  387.           PKeyCode::Option,
  388.           PKeyCode::Command,
  389.           PKeyCode::Alt,
  390.           PKeyCode::Shift,
  391.           PKeyCode::Control,
  392.           PKeyCode::CapsLock,
  393.           PKeyCode::Accelerator1,
  394.           PKeyCode::Accelerator2,
  395.           0
  396.         };
  398.         PString modifers;
  399.         for (int i = 0; ModifierOrder[i] != 0; i++) {
  400.           if (accel[0].IsModifier(ModifierOrder[i])) {
  401.             switch (accel[0].GetModifiers() & ModifierOrder[i]) {
  402.               case PKeyCode::Shift:
  403.                 modifers += "Shift+";
  404.                 break;
  405.               case PKeyCode::Command:
  406.               case PKeyCode::Control:
  407.               case PKeyCode::Accelerator1:
  408.                 modifers += "Ctrl+";
  409.                 break;
  410.               case PKeyCode::Alt:
  411.                 modifers += "Alt+";
  412.                 break;
  413.               case PKeyCode::Option:
  414.                 modifers += "Opt";
  415.                 break;
  416.               case PKeyCode::Accelerator2:
  417.                 modifers += "Ctrl+Shift+";
  418.             }
  419.           }
  420.         }
  421.         out << BinStr(textConverted +
  422.                           "t" + modifers + ValueStrings[accel[0].GetValue()]);
  423.       }
  424.       break;
  426.     case CountAccelerators :
  427.       if (!accel.IsEmpty())
  428.         HasAccelerators = TRUE;
  429.       break;
  431.     case OutputAccelerators :
  432.       for (PINDEX i = 0; i < accel.GetSize(); i++) {
  433.         static WORD toVK[] = { 
  434.           0, VK_LBUTTON, VK_RBUTTON, VK_MBUTTON,
  435.           'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
  436.           'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
  437.           '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
  438.           VK_NUMPAD0, VK_NUMPAD1, VK_NUMPAD2, VK_NUMPAD3, VK_NUMPAD4,
  439.           VK_NUMPAD5, VK_NUMPAD6, VK_NUMPAD7, VK_NUMPAD8, VK_NUMPAD9,
  440.           VK_ADD, VK_SUBTRACT, VK_MULTIPLY, VK_DIVIDE, VK_SEPARATOR, VK_DECIMAL,    
  441.           VK_F1, VK_F2, VK_F3, VK_F4, VK_F5, VK_F6, VK_F7, VK_F8,
  442.           VK_F9, VK_F10, VK_F11, VK_F12, VK_F13, VK_F14, VK_F15, VK_F16,
  443.           VK_F17, VK_F18, VK_F19, VK_F20, VK_F21, VK_F22, VK_F23, VK_F24, 
  444.           VK_UP, VK_DOWN, VK_LEFT, VK_RIGHT, VK_PRIOR, VK_NEXT, VK_HOME, VK_END,
  445.           VK_INSERT, VK_DELETE, VK_F20, VK_F21, VK_F22, VK_F23,
  446.           VK_CLEAR, VK_CANCEL, VK_HELP, VK_F24,
  447.           VK_BACK, VK_TAB, VK_RETURN, VK_ESCAPE, VK_SPACE,
  448.           VK_CAPITAL, VK_SHIFT, VK_CONTROL, VK_MENU, VK_CONTROL, VK_MENU, VK_MENU,
  449.           VK_PAUSE, VK_SELECT, 0x2a, VK_EXECUTE, VK_SNAPSHOT, VK_NUMLOCK, VK_SCROLL,
  450.           0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
  451.           0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe6, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee,
  452.           0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5
  453.         };
  454.         BYTE flags = 1;
  455.         if (accel[i].IsModifier(PKeyCode::Shift))
  456.           flags |= 0x04;
  457.         if (accel[i].IsModifier(PKeyCode::Control|PKeyCode::Command|PKeyCode::Accelerator1))
  458.           flags |= 0x08;
  459.         if (accel[i].IsModifier(PKeyCode::Alt|PKeyCode::Option))
  460.           flags |= 0x10;
  461.         if (accel[i].IsModifier(PKeyCode::Accelerator2))
  462.           flags |= 0x0c;
  463.         LastAcceleratorFlags = flags;
  464.         out << BinTextChar(flags)
  465.             << BinWord(toVK[accel[i].GetValue()])
  466.             << BinWord(id);
  467. #ifdef WIN32
  468.         out << BinWord(0);
  469. #endif
  470.       }
  471.   }
  472. }
  475. ///////////////////////////////////////////////////////////////
  476. //
  477. //  Separator::PrintOn
  478. //
  480. void Separator::PrintOn(ostream & out) const
  482. {
  483.   if (MenuPass == OutputMenus)
  484.     out << BinWord((WORD)(MF_SEPARATOR|(LastMenu ? MF_END : 0)))
  485.         << BinWord(0) << BinTextChar(0);
  486. }
  489. ///////////////////////////////////////////////////////////////
  490. //
  491. //  Menu::PrintOn
  492. //
  494. void Menu::PrintOn(ostream & out) const
  496. {
  497.   if (MenuPass == OutputMenus)
  498.     out << BinWord((WORD)(MF_POPUP|(LastMenu ? MF_END : 0)))
  499.         << BinStr(textConverted);
  501.   // output items
  502.   for (int i = 0; i < items.GetSize(); i++) {
  503.     LastMenu = i == items.GetSize()-1;
  504.     out << items[i];
  505.   }
  506. }
  509. ///////////////////////////////////////////////////////////////
  510. //
  511. //  Menubar::PrintOn
  512. //
  514. void MenuBar::PrintOn(ostream & out) const
  516. {
  517.   ResHdr hdr(4, id);
  519.   switch (MenuPass) {
  520.     case OutputMenus :
  521.       out << hdr << BinWord(0) << BinWord(0);
  522.       break;
  524.     case OutputAccelerators :
  525.       hdr.SetType(9);
  526.       out << hdr;
  527.       break;
  528.   }
  529.   
  530.   // output data for menubar
  531.   for (int i = 0; i < menus.GetSize(); i++) {
  532.     LastMenu = i == menus.GetSize()-1;
  533.     out << menus[i];
  534.   }
  536.   if (MenuPass != CountAccelerators)
  537.     out << hdr;
  538. }
  541. ///////////////////////////////////////////////////////////////
  542. //
  543. //  MenubarDict::PrintOn
  544. //
  546. void MenubarDict::PrintOn(ostream & out) const
  548. {
  549.   //  output each of the menubars
  550.   for (int i = 0; i < GetSize(); i++) {
  551.     MenuPass = OutputMenus;
  552.     out << GetDataAt(i);
  553.     MenuPass = CountAccelerators;
  554.     HasAccelerators = FALSE;
  555.     out << GetDataAt(i);
  556.     if (HasAccelerators) {
  557.       MenuPass = OutputAccelerators;
  558.       out << GetDataAt(i);
  559. #ifdef WIN32
  560.       out.seekp(-8, ios::cur);
  561. #else
  562.       out.seekp(-5, ios::cur);
  563. #endif
  564.       out << BinByte(LastAcceleratorFlags|0x80);
  565.       out.seekp(0, ios::end);
  566.     }
  567.   }
  568. }
  570. ///////////////////////////////////////////////////////////////
  571. //
  572. //  output routines for various control types
  573. //
  575. void Point::PrintOn(ostream & out) const
  576. {
  577.   out << BinWord(x) << BinWord(y);
  578. }
  581. void Control::PrintOn(ostream & out) const
  582. {
  583.   if (OutputDialogStrings) {
  584.     out << BinStr(PString(PString::Literal, balloonHelp));
  585.     return;
  586.   }
  588. #ifdef WIN32
  589.   while ((out.tellp()&3) != 0) // Align to long
  590.     out.put('');
  591.   out << BinLong(DialogControlStyle|WS_VISIBLE|WS_CHILD) << BinLong(0)
  592.       << pos << dim << BinWord(id) << BinWord(0xffff)
  593. #else
  594.   out << pos << dim << BinWord(id)
  595.       << BinLong(DialogControlStyle|WS_VISIBLE|WS_CHILD)
  596. #endif
  597.       << BinTextChar(DialogControlCode);
  599.   if (iconID == -1)
  600.     out << BinStr(textConverted) << BinTextChar(0);
  601. }
  604. void PushButton::PrintOn(ostream & out) const
  605. {
  606.   DialogControlCode = 0x80;
  607.   DialogControlStyle = (options&DefaultButtonOption) != 0 ? BS_DEFPUSHBUTTON
  608.                                                    : BS_PUSHBUTTON;
  609.   DialogControlStyle |= WS_TABSTOP;
  610.   Control::PrintOn(out);
  611. }
  614. void CheckBox::PrintOn(ostream & out) const
  615. {
  616.   DialogControlCode = 0x80;
  617.   DialogControlStyle = BS_AUTOCHECKBOX|WS_TABSTOP;
  618.   Control::PrintOn(out);
  619. }
  622. void Check3Way::PrintOn(ostream & out) const
  623. {
  624.   DialogControlCode = 0x80;
  625.   DialogControlStyle = BS_AUTO3STATE|WS_TABSTOP;
  626.   Control::PrintOn(out);
  627. }
  630. void RadioButton::PrintOn(ostream & out) const
  631. {
  632.   DialogControlCode = 0x80;
  633.   DialogControlStyle = BS_RADIOBUTTON|WS_TABSTOP;
  634.   Control::PrintOn(out);
  635. }
  638. void LeftText::PrintOn(ostream & out) const
  639. {
  640.   DialogControlCode = 0x82;
  641.   DialogControlStyle = SS_LEFT;
  642.   Control::PrintOn(out);
  643. }
  646. void CentreText::PrintOn(ostream & out) const
  647. {
  648.   DialogControlCode = 0x82;
  649.   DialogControlStyle = SS_CENTER;
  650.   Control::PrintOn(out);
  651. }
  654. void RightText::PrintOn(ostream & out) const
  655. {
  656.   DialogControlCode = 0x82;
  657.   DialogControlStyle = SS_RIGHT;
  658.   Control::PrintOn(out);
  659. }
  662. void StaticBox::PrintOn(ostream & out) const
  663. {
  664.   DialogControlCode = 0x80;
  665.   DialogControlStyle = BS_GROUPBOX|WS_CLIPSIBLINGS;
  666.   Control::PrintOn(out);
  667. }
  670. void EditBox::PrintOn(ostream & out) const
  671. {
  672.   DialogControlCode = 0x81;
  673.   DialogControlStyle = ES_LEFT|ES_AUTOHSCROLL|WS_BORDER|WS_TABSTOP;
  674.   Control::PrintOn(out);
  675. }
  678. void IntEditBox::PrintOn(ostream & out) const
  679. {
  680.   DialogControlCode = 0x81;
  681.   DialogControlStyle = ES_LEFT|WS_BORDER|WS_TABSTOP;
  682.   ((IntEditBox*)this)->textConverted = psprintf("INTEDITBOX %li %li %li %li",
  683.                                      minimum, maximum, smallNudge, largeNudge);
  684.   Control::PrintOn(out);
  685. }
  688. void FloatEditBox::PrintOn(ostream & out) const
  689. {
  690.   DialogControlCode = 0x81;
  691.   DialogControlStyle = ES_LEFT|WS_BORDER|WS_TABSTOP;
  692.   ((FloatEditBox*)this)->textConverted =
  693.                             psprintf("FLOATEDITBOX %li %li %li %li",
  694.                                      minimum, maximum, smallNudge, largeNudge);
  695.   Control::PrintOn(out);
  696. }
  699. void TextEditor::PrintOn(ostream & out) const
  700. {
  701.   DialogControlCode = 0x81;
  702.   DialogControlStyle = ES_LEFT|ES_MULTILINE|ES_WANTRETURN|
  703.                                     WS_VSCROLL|WS_HSCROLL|WS_BORDER|WS_TABSTOP;
  704.   Control::PrintOn(out);
  705. }
  708. void Password::PrintOn(ostream & out) const
  709. {
  710.   DialogControlCode = 0x81;
  711.   DialogControlStyle = ES_LEFT|ES_PASSWORD|WS_BORDER|WS_TABSTOP;
  712.   Control::PrintOn(out);
  713. }
  716. void ListControl::PrintOn(ostream & out) const
  717. {
  718.   Control::PrintOn(out);
  719.   if (OutputDialogStrings)
  720.     for (PINDEX i = 0; i < strList.GetSize(); i++)
  721.       out << BinStr(PString(PString::Literal, strList[i]));
  722. }
  725. void ChoiceBox::PrintOn(ostream & out) const
  726. {
  727.   DialogControlCode = 0x85;
  728.   DialogControlStyle = CBS_DROPDOWNLIST|WS_VSCROLL|WS_BORDER|WS_TABSTOP;
  729.   if ((options&Special) != 0)
  730.     DialogControlStyle |= CBS_SORT|CBS_OWNERDRAWFIXED|CBS_HASSTRINGS;
  731.   else if ((options&SortedOption) != 0)
  732.     DialogControlStyle |= CBS_SORT;
  733.   ListControl::PrintOn(out);
  734. }
  737. void ListBox::PrintOn(ostream & out) const
  738. {
  739.   DialogControlCode = 0x83;
  740.   DialogControlStyle = LBS_USETABSTOPS|LBS_NOINTEGRALHEIGHT|LBS_NOTIFY|WS_BORDER|WS_TABSTOP;
  741.   if ((options&Special) != 0)
  742.     DialogControlStyle |= WS_VSCROLL|LBS_OWNERDRAWFIXED|LBS_HASSTRINGS|LBS_SORT;
  743.   else {
  744.     if ((options&SortedOption) != 0)
  745.       DialogControlStyle |= LBS_SORT;
  746.     if ((options&MultiSelectOption) != 0)
  747.       DialogControlStyle |= LBS_EXTENDEDSEL;
  748.     if ((options&MultiColumnOption) != 0)
  749.       DialogControlStyle |= LBS_MULTICOLUMN|WS_HSCROLL;
  750.     else
  751.       DialogControlStyle |= LBS_DISABLENOSCROLL|WS_VSCROLL;
  752.     if (GetResClass() != "PStringListBox")
  753.       DialogControlStyle |= (options&MultiColumnOption) != 0
  754.                                 ? LBS_OWNERDRAWFIXED : LBS_OWNERDRAWVARIABLE;
  755.   }
  756.   ListControl::PrintOn(out);
  757. }
  760. void ComboBox::PrintOn(ostream & out) const
  761. {
  762.   DialogControlCode = 0x85;
  763.   DialogControlStyle =
  764.                 CBS_AUTOHSCROLL|CBS_DROPDOWN|WS_VSCROLL|WS_BORDER|WS_TABSTOP;
  765.   if ((options&SortedOption) != 0)
  766.     DialogControlStyle |= CBS_SORT;
  767.   if ((options&Special) != 0)
  768.     DialogControlStyle |= CBS_OWNERDRAWFIXED|CBS_HASSTRINGS;
  769.   ListControl::PrintOn(out);
  770. }
  773. void HScrollBar::PrintOn(ostream & out) const
  774. {
  775.   DialogControlCode = 0x84;
  776.   DialogControlStyle = SBS_HORZ|WS_TABSTOP;
  777.   ((HScrollBar*)this)->textConverted = psprintf("%li %li %li %li",
  778.                                      minimum, maximum, smallNudge, largeNudge);
  779.   Control::PrintOn(out);
  780. }
  783. void VScrollBar::PrintOn(ostream & out) const
  784. {
  785.   DialogControlCode = 0x84;
  786.   DialogControlStyle = SBS_VERT|WS_TABSTOP;
  787.   ((VScrollBar*)this)->textConverted = psprintf("%li %li %li %li",
  788.                                      minimum, maximum, smallNudge, largeNudge);
  789.   Control::PrintOn(out);
  790. }
  793. void StaticIcon::PrintOn(ostream & out) const
  794. {
  795.   DialogControlCode = 0x82;
  796.   DialogControlStyle = SS_ICON;
  797.   Control::PrintOn(out);
  798.   if (!OutputDialogStrings)
  799.     out << BinTextChar(0xffff) << BinWord(iconID) << BinTextChar(0);
  800. }
  803. void UserControl::PrintOn(ostream & out) const 
  804. { 
  805.   DialogControlCode = 0x82;
  806.   DialogControlStyle = SS_LEFT;
  807.   Control::PrintOn(out);
  808. } 
  811. ///////////////////////////////////////////////////////////////
  812. //
  813. //  Layout::PrintOn
  814. //
  816. void Layout::PrintOn(ostream & out) const
  817. {
  818.   ResHdr hdr(5, id);
  819.   
  820.   if (OutputDialogStrings) {
  821.     hdr.SetType(DIALOGSTRINGS);
  822.     out << hdr;
  823.   }
  824.   else {
  825.     DWORD style = WS_CLIPCHILDREN|WS_CLIPSIBLINGS|DS_SETFONT;
  826.     if (subtype == 0)
  827.       style |= WS_CHILD;
  828.     else
  829.       style |= WS_POPUP|WS_CAPTION|WS_SYSMENU|DS_MODALFRAME;
  830.     out << hdr
  831.         << BinLong(style)          // Window style
  832. #ifdef WIN32
  833.         << BinLong(0)  // Window extended style
  834. #endif
  835.         << BinTextChar(itemList.GetSize()) // number of items
  836.         << BinWord(pos.X())
  837.         << BinWord(pos.Y())
  838.         << BinWord(dim.X())
  839.         << BinWord(dim.Y())
  840.         << BinTextChar(0)     // Menu name (no menu)
  841.         << BinTextChar(0)     // Class name (default class)
  842.         << BinStr(textConverted);  // caption
  843.     if (fontName.IsEmpty())
  844.       out << BinWord(8) << BinStr("MS Sans Serif");
  845.     else
  846.       out << BinWord(fontSize)
  847.           << BinStr(PString(PString::Literal, fontName));
  848.   }
  850.   for (int i = 0; i < itemList.GetSize(); i++) {
  851.     out << itemList[i];
  852.     if (OutputDialogStrings)
  853.       out << BinTextChar(0); // Terminator
  854.   }
  857.   out << hdr;
  858. }
  860. ///////////////////////////////////////////////////////////////
  861. //
  862. //  DialogDict::PrintOn
  863. //
  865. void DialogDict::PrintOn(ostream & out) const
  867. {
  868.   //  output each of the dialogs
  869.   for (int i = 0; i < GetSize(); i++) {
  870.     OutputDialogStrings = FALSE;
  871.     out << GetDataAt (i);
  872.     OutputDialogStrings = TRUE;
  873.     out << GetDataAt (i);
  874.   }
  875. }
  878. ///////////////////////////////////////////////////////////////
  879. //
  880. //  BinaryData::PrintOn
  881. //
  883. void BinaryData::PrintOn(ostream & out) const
  884. {
  885.   out.write(theArray, GetSize());
  886. }
  889. ///////////////////////////////////////////////////////////////
  890. //
  891. //  PixData::PrintOn
  892. //
  894. void PixData::PrintOn(ostream & out) const
  895. {
  896.   if (PixDataDepth > 8) {
  897.     for (int y = GetSize()/PixDataWidth/3-1; y >= 0; y--) {
  898.       const char * pixels = theArray+y*PixDataWidth*3;
  899.       for (PINDEX x = 0; x < PixDataWidth*3; x++)
  900.         out << *pixels++ << ' ';
  901.       while ((x++&3) != 0) // Align to long
  902.         out.put('');
  903.     }
  904.   }
  905.   else {
  906.     for (int y = GetSize()/PixDataWidth-1; y >= 0; y--) {
  907.       const char * pixels = theArray+y*PixDataWidth;
  908.       PINDEX byteCount = 0;
  909.       PINDEX pixelsPerByte = 8/PixDataDepth;
  910.       PINDEX pixelInByte = 0;
  911.       char byte = 0;
  912.       for (PINDEX pix = 0; pix < PixDataWidth; pix++) {
  913.         byte <<= PixDataDepth;
  914.         byte |= *pixels++;
  915.         if (++pixelInByte >= pixelsPerByte) {
  916.           out.put(byte);
  917.           byteCount++;
  918.           pixelInByte = 0;
  919.           byte = 0;
  920.         }
  921.       }
  922.       if (pixelInByte != 0) {
  923.         out.put((char)(byte << (8-pixelInByte)));
  924.         byteCount++;
  925.       }
  926.       while ((byteCount++&3) != 0) // Align to long
  927.         out.put('');
  928.     }
  929.   }
  930. }
  933. ///////////////////////////////////////////////////////////////
  934. //
  935. //  PixelContents::PrintOn
  936. //
  938. void PixelContents::PrintOn(ostream & out) const
  939. {
  940.   static RGBQUAD bw[2] = { { 0, 0, 0, 0 }, { 255, 255, 255, 0 } };
  942.   PixDataWidth = width;
  944.   BITMAPINFOHEADER bm;
  945.   memset(&bm, 0, sizeof(bm));
  946.   bm.biSize = sizeof(bm);
  947.   bm.biWidth = width;
  948.   bm.biHeight = height;
  949.   bm.biPlanes = 1;
  951.   switch (OutputIconCursor) {
  952.     case BilevelCursor :
  953.       out << BinWord(x) << BinWord(y); // Hotspot
  954.       // Then do common code in BiLevelIcon case
  956.     case BilevelIcon :
  957.       bm.biHeight *= 2;
  958.       bm.biBitCount = 1;
  959.       bm.biSizeImage = ((bm.biWidth+31)/32)*4*bm.biHeight;
  960.       bm.biClrUsed = bm.biClrImportant = 2L;
  961.       out.write((char *)&bm, sizeof(bm));
  962.       out.write((char *)bw, sizeof(bw));
  963.       PixDataDepth = 1;
  964.       out << xorMask << andMask;
  965.       break;
  966.     
  967.     case ColourCursor :
  968.       out << BinWord(x) << BinWord(y); // Hotspot
  969.       // Then do common code in ColourIcon case
  971.     case ColourIcon :
  972.       bm.biHeight *= 2;
  973.       // Then do common code in PixmapImage case
  975.     case PixmapImage :
  976.       bm.biBitCount = (WORD)depth;
  977.       bm.biSizeImage = ((bm.biWidth*bm.biBitCount+31)/32)*4*bm.biHeight;
  978.       bm.biClrUsed = bm.biClrImportant = 1L << bm.biBitCount;
  979.       out.write((char *)&bm, sizeof(bm));
  980.   
  981.       if (depth != 24) {
  982.         for (int i = 0; i < (int)bm.biClrUsed; i++) {
  983.           RGBQUAD rgb;
  984.           rgb.rgbRed = clut[i*3];
  985.           rgb.rgbGreen = clut[i*3+1];
  986.           rgb.rgbBlue = clut[i*3+2];
  987.           rgb.rgbReserved = 0;
  988.           out.write((char *)&rgb, sizeof(rgb));
  989.         }
  990.       }
  992.       PixDataDepth = depth;
  993.       out << pixels;
  995.       PixDataDepth = 1;
  996.       if (andMask.GetSize() > 0)
  997.         out << andMask;
  998.       break;
  1000.     case IconDirMap :
  1001.       out << BinWord(depth != 1 ? 2 : 1)
  1002.           << BinByte(width) << BinByte(height) // First the B/W icon/cursor
  1003.           << BinWord(2) // Number of colours
  1004.           << BinWord(1) // Bit planes/hotspot x
  1005.           << BinWord(1) // Bits per pixel/hotspot y
  1006.           << BinLong(sizeof(BITMAPINFOHEADER) +
  1007.                                 2*andMask.GetSize() + 2*sizeof(RGBQUAD)) // Size
  1008.           << BinWord(IconCursorID++);
  1009.   
  1010.       if (depth != 1)
  1011.         out << BinByte(width) << BinByte(height) // Second the colour icon/cursor
  1012.             << BinWord(1 << depth) // Number of colours
  1013.             << BinWord(1) // Bit planes/hotspot x
  1014.             << BinWord(depth) // Bits per pixel/hotspot y
  1015.             << BinLong(sizeof(BITMAPINFOHEADER) +
  1016.                        pixels.GetSize() + andMask.GetSize() +
  1017.                        (depth != 24 ? ((1<<depth)*sizeof(RGBQUAD)) : 0)) // Size
  1018.             << BinWord(IconCursorID++);
  1019.       break;
  1021.     case CursorDirMap :
  1022.       out << BinWord(depth != 1 ? 2 : 1)
  1023.           << BinWord(width) << BinWord(height) // First the B/W icon/cursor
  1024.           << BinWord(1) // Bit planes
  1025.           << BinWord(1) // Bits per pixel
  1026.           << BinLong(sizeof(BITMAPINFOHEADER) +
  1027.                                 2*andMask.GetSize() + 2*sizeof(RGBQUAD)) // Size
  1028.           << BinWord(IconCursorID++);
  1029.   
  1030.       if (depth != 1)
  1031.         out << BinWord(width) << BinWord(height) // Second the colour icon/cursor
  1032.             << BinWord(1) // Bit planes
  1033.             << BinWord(depth) // Bits per pixel
  1034.             << BinLong(sizeof(BITMAPINFOHEADER) +
  1035.                        pixels.GetSize() + andMask.GetSize() +
  1036.                        (depth != 24 ? ((1<<depth)*sizeof(RGBQUAD)) : 0)) // Size
  1037.             << BinWord(IconCursorID++);
  1038.   }
  1039. }
  1042. ///////////////////////////////////////////////////////////////
  1043. //
  1044. //  Icon::PrintOn
  1045. //
  1047. void Icon::PrintOn(ostream & out) const
  1048. {
  1049.   OutputIconCursor = BilevelIcon;
  1050.   ResHdr hdr(3, IconCursorID);
  1051.   out << hdr << contents << hdr;
  1053.   if (contents.depth != 1) {
  1054.     OutputIconCursor = ColourIcon;
  1055.     ResHdr colhdr(3, IconCursorID+1);
  1056.     out << colhdr << contents << colhdr;
  1057.   }
  1059.   OutputIconCursor = IconDirMap;
  1060.   ResHdr dirhdr(14, id);
  1061.   out << dirhdr << BinWord(0) << BinWord(1) << contents << dirhdr;
  1062. }
  1065. ///////////////////////////////////////////////////////////////
  1066. //
  1067. //  IconDict::PrintOn
  1068. //
  1070. void IconDict::PrintOn(ostream & out) const
  1071. {
  1072.   IconCursorID = 1;
  1073.   //  output each of the icons
  1074.   for (int i = 0; i < GetSize(); i++)
  1075.     out << GetDataAt (i);
  1076. }
  1079. ///////////////////////////////////////////////////////////////
  1080. //
  1081. //  Cursor::PrintOn
  1082. //
  1084. void CursorResource::PrintOn(ostream & out) const
  1085. {
  1086.   OutputIconCursor = BilevelCursor;
  1087.   ResHdr hdr(1, IconCursorID);
  1088.   out << hdr << contents << hdr;
  1090.   if (contents.depth != 1) {
  1091.     OutputIconCursor = ColourCursor;
  1092.     ResHdr colhdr(1, IconCursorID+1);
  1093.     out << colhdr << contents << colhdr;
  1094.   }
  1096.   OutputIconCursor = CursorDirMap;
  1097.   ResHdr dirhdr(12, id);
  1098.   out << dirhdr << BinWord(0) << BinWord(2) << contents << dirhdr;
  1099. }
  1102. ///////////////////////////////////////////////////////////////
  1103. //
  1104. //  CursorDict::PrintOn
  1105. //
  1107. void CursorDict::PrintOn(ostream & out) const
  1108. {
  1109.   IconCursorID = 1;
  1110.   //  output each of the cursors
  1111.   for (int i = 0; i < GetSize(); i++)
  1112.     out << GetDataAt (i);
  1113. }
  1116. ///////////////////////////////////////////////////////////////
  1117. //
  1118. //  Pattern::PrintOn
  1119. //
  1121. void Pattern::PrintOn(ostream & out) const
  1122. {
  1123.   ResHdr hdr(2, id);
  1124.   out << hdr << contents << hdr;
  1125. }
  1128. ///////////////////////////////////////////////////////////////
  1129. //
  1130. //  PatternDict::PrintOn
  1131. //
  1133. void PatternDict::PrintOn(ostream & out) const
  1134. {
  1135.   OutputIconCursor = PixmapImage;
  1136.   //  output each of the bitmaps
  1137.   for (int i = 0; i < GetSize(); i++)
  1138.     out << GetDataAt (i);
  1139. }
  1142. ///////////////////////////////////////////////////////////////
  1143. //
  1144. //  Image::PrintOn
  1145. //
  1147. void Image::PrintOn(ostream & out) const
  1148. {
  1149.   ResHdr hdr(2, id);
  1150.   out << hdr << contents << hdr;
  1151. }
  1154. ///////////////////////////////////////////////////////////////
  1155. //
  1156. //  ImageDict::PrintOn
  1157. //
  1159. void ImageDict::PrintOn(ostream & out) const
  1160. {
  1161.   OutputIconCursor = PixmapImage;
  1162.   //  output each of the bitmaps
  1163.   for (int i = 0; i < GetSize(); i++)
  1164.     out << GetDataAt (i);
  1165. }
  1168. ///////////////////////////////////////////////////////////////
  1169. //
  1170. //  DataResource::PrintOn
  1171. //
  1173. void DataResource::PrintOn(ostream & out) const
  1174. {
  1175.   ResHdr hdr(10, id);
  1176.   if (!textConverted.IsEmpty() && textConverted != "DATA")
  1177.     hdr.SetType(textConverted);
  1178.   out << hdr << data << hdr;
  1179. }
  1182. ///////////////////////////////////////////////////////////////
  1183. //
  1184. //  DataDict::PrintOn
  1185. //
  1187. void DataDict::PrintOn(ostream & out) const
  1188. {
  1189.   //  output each of the data resources
  1190.   for (int i = 0; i < GetSize(); i++)
  1191.     out << GetDataAt (i);
  1192. }
  1195. Control * MakeControl(Control * control, int id, int x, int y, int w, int h, char * str = NULL, int opts = 0)
  1196. {
  1197.   control->SetID(new ResourceID(id));
  1198.   control->SetPos(new Point(x, y));
  1199.   control->SetDim(new Point(w, h));
  1200.   if (str != NULL)
  1201.     control->SetText(new PString(str));
  1202.   if (opts != 0)
  1203.     control->SetOptions(opts);
  1204.   return control;
  1205. }
  1209. ///////////////////////////////////////////////////////////////
  1210. //
  1211. //  Backend
  1212. //
  1214. void ResourceFile::Backend(PFile & out)
  1215. {
  1216.   // Standard resources (always included)
  1217.   if (dialogDict.GetAt(PSTD_ID_DIALOG_OPEN_DIR) == NULL) {
  1218.     Layout * layout = new Layout("PModalDialog", 2);
  1219.     layout->SetPos (new Point(60, 40));
  1220.     layout->SetDim (new Point(170, 135));
  1221.     layout->SetText(new PString(""Directory Select""));
  1222.     layout->SetID(new ResourceID(PSTD_ID_DIALOG_OPEN_DIR));
  1223.     layout->AddControl(MakeControl(new LeftText(),     1090,    6,   6,  76,  9, ""Directory &Name:""));
  1224.     layout->AddControl(MakeControl(new EditBox(),      1159,    6,  16,  92, 12));
  1225.     layout->AddControl(MakeControl(new ListBox(),      1121,    6,  35,  92, 68, NULL, Special));
  1226.     layout->AddControl(MakeControl(new LeftText(),     1091,    6, 105,  92,  9, ""Dri&ves:""));
  1227.     layout->AddControl(MakeControl(new ChoiceBox(),    1137,    6, 115,  92, 68, NULL, Special));
  1228.     layout->AddControl(MakeControl(new PushButton(),      1,  114,   6,  50, 14, ""&Select"", DefaultButtonOption));
  1229.     layout->AddControl(MakeControl(new PushButton(),      2,  114,  26,  50, 14, ""Cancel""));
  1230.     layout->AddControl(MakeControl(new PushButton(),   1038,  114,  46,  50, 14, ""&Help""));
  1231.     layout->AddControl(MakeControl(new CheckBox(),     1040, 1000, 123,  54, 12, ""&Read Only""));
  1232.     layout->AddControl(MakeControl(new EditBox(),      1152, 1000,  16,  90, 12));
  1233.     layout->AddControl(MakeControl(new LeftText(),     1089, 1000, 110,  90,  9));
  1234.     layout->AddControl(MakeControl(new ChoiceBox(),    1136, 1000, 120,  90, 60));
  1235.     layout->AddControl(MakeControl(new LeftText(),     1088, 1000,   4, 999,  9));
  1236.     layout->AddControl(MakeControl(new ListBox(),      1120, 1000,  68,  34, 67));
  1237.     dialogDict.SetAt(PSTD_ID_DIALOG_OPEN_DIR, layout);
  1238.   }
  1240.   _setmode(out.GetHandle(), _O_BINARY);
  1242. #ifdef WIN32
  1243.   if (out.GetLength() == 0) {
  1244.     ResHdr hdr(0, 0);
  1245.     out << hdr << hdr;
  1246.   }
  1247. #endif
  1248.   out << stringDict;
  1249.   out << menubarDict;
  1250.   out << dialogDict;
  1251.   out << iconDict;
  1252.   out << cursorDict;
  1253.   out << patternDict;
  1254.   out << imageDict;
  1255.   out << dataDict;
  1256. }
  1259. // End WINDOWS.CXX ////////////////////////////////////////////////////////////