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

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

IP电话/视频会议

开发平台：

Visual C++

codegen.cxx：源码内容
  1. /*
  2.  * codegen.cxx
  3.  *
  4.  * Resource compiler C++ code 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: codegen.cxx,v $
  30.  * Revision 1.4  2000/06/21 02:15:25  robertj
  31.  * Removed some warnings on compiling colour icons.
  32.  *
  33.  * Revision 1.3  1999/10/18 04:41:09  robertj
  34.  * Added decompile of .BMP and .ICO files and fixed ability to have 64x64 icons
  35.  *
  36.  * Revision 1.2  1998/09/26 01:24:02  robertj
  37.  * Added open source license
  38.  *
  39.  * Revision 1.1  1998/09/26 00:46:21  robertj
  40.  * Initial revision
  41.  *
  42.  * Revision 1.22  1998/09/14 13:45:02  robertj
  43.  * Allowed suppression of some warnings.
  44.  *
  45.  * Revision 1.21  1996/05/23 10:06:38  robertj
  46.  * Fixed bug in OK/Cancel buttons of dialogs not being set as special buttons.
  47.  *
  48.  * Revision 1.20  1996/01/23 13:32:41  robertj
  49.  * More changes for editor
  50.  *
  51.  * Revision 1.19  1995/12/23 03:51:05  robertj
  52.  * Removed multiple classes for Layout types.
  53.  * Added extra collections for editor use.
  54.  *
  55.  * Revision 1.18  1995/12/10 12:11:57  robertj
  56.  * Changes to support graphical resource file editor.
  57.  *
  58.  * Revision 1.17  1995/10/14 15:19:07  robertj
  59.  * Fixed missing font size on font keyword.
  60.  * Changes required by move of standard buttons to PDialog.
  61.  *
  62.  * Revision 1.16  1995/08/24 12:46:38  robertj
  63.  * Removed redundant parent parameter for ConstructEnd().
  64.  *
  65.  * Revision 1.14  1995/07/31 12:30:10  robertj
  66.  * Changed all generated resource IDs to be in the same "number space". This
  67.  *   is to avoid problems with IDs being used for more than one type of resource
  68.  *   eg a menu item and an image for a toolbar.
  69.  * Fixed the generated #line commands to include a relative path instead of an
  70.  *   absolute one.
  71.  *
  72.  * Revision 1.13  1995/04/02 09:28:12  robertj
  73.  * Added "balloon" help.
  74.  *
  75.  * Revision 1.12  1995/02/19 04:19:25  robertj
  76.  * Added dynamically linked command processing.
  77.  *
  78. // Revision 1.11  1995/02/11  04:13:18  robertj
  79. // Changed #include generated in .cxx file to not include full path.
  80. //
  81. // Revision 1.10  1995/01/27  11:25:38  robertj
  82. // Added pattern resource.
  83. //
  84.  */
  87. #include <ptlib.h>
  88. #include "pwrc.h"
  91. extern ResourceFile * current_file;
  94. /////////////////////////////////////////
  95. //
  96. //  Line numbers from parser
  97. //
  99. ostream & operator<<(ostream & out, const LineNumber & line)
  100. {
  101.   out << "n#line " << line.number << " "";
  103.   PINDEX i;
  104.   PDirectory dir;
  105.   for (i = 0; i < dir.GetLength(); i++)
  106.     if (dir[i] != line.filename[i])
  107.       break;
  109.   PString filestr = line.filename.Mid(i);
  111.   if (filestr.Find('\') == P_MAX_INDEX)
  112.     out << filestr;
  113.   else {
  114.     for (i = 0; i < filestr.GetLength(); i++) {
  115.       if (filestr[i] != '\')
  116.         out << filestr[i];
  117.       else
  118.         out << "\\";
  119.     }
  120.   }
  122.   return out << ""n";
  123. }
  126. /////////////////////////////////////////
  127. //
  128. //  key code structure
  129. //
  131. AccelCode::AccelCode(const PString & resrcStr)
  132. {
  133.   value = NullValue;
  134.   modifiers = NoModifier;
  136.   PCaselessString code(resrcStr(1, resrcStr.GetLength()-2));
  137.   if (code.IsEmpty())
  138.     return;
  140.   PINDEX pos;
  141.   if ((pos = code.Find("shift+")) != P_MAX_INDEX) {
  142.     code.Delete(pos, 6);
  143.     modifiers |= Shift;
  144.   }
  146.   if ((pos = code.Find("ctrl+")) != P_MAX_INDEX) {
  147.     code.Delete(pos, 5);
  148.     modifiers |= Control;
  149.   }
  151.   if ((pos = code.Find("alt+")) != P_MAX_INDEX) {
  152.     code.Delete(pos, 4);
  153.     modifiers |= Alt;
  154.   }
  156.   if ((pos = code.Find("cmd+")) != P_MAX_INDEX) {
  157.     code.Delete(pos, 4);
  158.     modifiers |= Command;
  159.   }
  161.   if ((pos = code.Find("opt+")) != P_MAX_INDEX) {
  162.     code.Delete(pos, 4);
  163.     modifiers |= Option;
  164.   }
  166.   if ((pos = code.Find("acc1+")) != P_MAX_INDEX) {
  167.     code.Delete(pos, 5);
  168.     modifiers |= Accelerator1;
  169.   }
  171.   if ((pos = code.Find("acc2+")) != P_MAX_INDEX) {
  172.     code.Delete(pos, 5);
  173.     modifiers |= Accelerator2;
  174.   }
  176.   static PCaselessString simpleCode("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
  177.   static PString keypadCode("0123456789+-*/,.");
  179.   switch (code.GetLength()) {
  180.     case 1 :
  181.       if ((pos = simpleCode.Find(code[0])) != P_MAX_INDEX)
  182.         value = (Value)(pos + PKeyCode::A);
  183.       break;
  185.     case 2 :
  186.       if (code(0,0) == "F" && code[1] >= '1' && code[1] <= '9')
  187.         value = (Value)(code[1] - '1' + PKeyCode::F1);
  188.       break;
  189.       
  190.     case 3 :
  191.       if (code(0,1) == "KP" && (pos = keypadCode.Find(code[2])) != P_MAX_INDEX)
  192.         value = (Value)(pos + PKeyCode::KP0);
  193.       else if (code(0,1) == "F1" && code[2] >= '0' && code[2] <= '2')
  194.         value = (Value)(code[2] - '0' + PKeyCode::F10);
  195.       break;
  196.   }
  198.   if (value == NullValue) {
  199.     static char *miscKeys[] = {
  200.       "Up", "Down", "Left", "Right", "PgUp", "PgDn", "Home", "End",
  201.       "Ins", "Del", "Undo", "Cut", "Copy", "Paste", "Clear", "Cancel",
  202.       "Help", "Quit", "BkSp", "Tab", "Ret", "Esc", " "
  203.     };
  204.     for (PINDEX i = 0; i < PARRAYSIZE(miscKeys); i++) {
  205.       if (code == miscKeys[i]) {
  206.         value = (Value)(i + PKeyCode::Up);
  207.         break;
  208.       }
  209.     }
  210.     if (value == NullValue)
  211.       PError << StdError(Fatal) << "Unknown accelerator code " << resrcStr << endl;
  212.   }
  213. }
  216. /////////////////////////////////////////
  217. //
  218. //  point for resource position
  219. //
  221. Point::Point(long nx, long ny)
  222. {
  223.   if (nx < -32767 || nx > 32767 || ny < -32767 || ny > 32767)
  224.     PError << StdError(Warning)
  225.            << "position must be 16 bit, truncating." << endl;
  226.   x = (int)nx;
  227.   y = (int)ny;
  228. }
  231. void Point::SetX(long nx)
  232. {
  233.   if (nx < -32767 || nx > 32767)
  234.     PError << StdError(Warning)
  235.            << "position must be 16 bit, truncating." << endl;
  236.   x = (int)nx;
  237. }
  240. void Point::SetY(long ny)
  241. {
  242.   if (ny < -32767 || ny > 32767)
  243.     PError << StdError(Warning)
  244.            << "position must be 16 bit, truncating." << endl;
  245.   y = (int)ny;
  246. }
  249. Point & Point::operator=(const Point & pt)
  250. {
  251.   x = pt.x;
  252.   y = pt.y;
  253.   return *this;
  254. }
  257. /////////////////////////////////////////
  258. //
  259. //  a resource item which has an id and a string
  260. //
  262. ResourceObject::ResourceObject(ResourceID * newId, PString * newText)
  263. {
  264.   SetID(newId);
  265.   SetText(newText);
  266. }
  269. void ResourceObject::SetText(PString * newText)
  271. {
  272.   if (newText != NULL) {
  273.     textLiteral = *newText;
  274.     delete newText;
  275.     textConverted = PString(PString::Literal, textLiteral);
  276.     if (textConverted.GetLength() > 255) {
  277.       textLiteral = textLiteral(0,254);
  278.       PError << StdError(Warning)
  279.              << "string too long, may be truncated to 255 characters." << endl;
  280.     }
  281.   }
  282. }
  285. void ResourceObject::SetID(ResourceID * newId)
  286. {
  287.   if (newId == NULL)
  288.     id = -1;
  289.   else {
  290.     long num = newId->GetNum();
  291.     if (num < -32767 || num > 65535)
  292.        PError << StdError(Warning)
  293.              << "resource ID must be 16 bit, truncating." << endl;
  294.     id = (int)num;
  295.     identifier = newId->GetIdent();
  296.     delete newId;
  297.   }
  298. }
  301. PString ResourceObject::GetIDString() const
  302. {
  303.   if (identifier.IsEmpty())
  304.     return PString(PString::Unsigned, id);
  306.   return identifier;
  307. }
  310. PObject::Comparison ResourceObject::Compare (const PObject & obj) const
  311. {
  312.   int otherId = ((const ResourceObject &)obj).id;
  313.   if (id < otherId)
  314.     return LessThan;
  315.   if (id > otherId)
  316.     return GreaterThan;
  317.   return EqualTo;
  318. }
  320. PINDEX ResourceObject::HashFunction() const
  321. {
  322.   return PABSINDEX(id)%23;
  323. }
  326. /////////////////////////////////////////
  327. //
  328. //  A resource with a class specification
  329. //
  331. ClassedResource::ClassedResource(const char * className)
  332.   : resourceClass(className)
  333. {
  334. }
  337. ClassedResource::ClassedResource(PString * className)
  338.   : resourceClass(*className)
  339. {
  340.   delete className;
  341. }
  344. ClassedResource::ClassedResource(PString * className, PString * ancestorName)
  345.   : resourceClass(*className),
  346.     ancestorClass(*ancestorName)
  347. {
  348.   delete className;
  349.   delete ancestorName;
  350. }
  353. void ClassedResource::SetResClass(const PString & newClassname)
  354. {
  355.   resourceClass = newClassname;
  356.   classLine.Set();
  357. }
  360. /////////////////////////////////////////
  361. //
  362. //  menu items
  363. //
  365. void MenuItem::SetFieldName(PString * newFieldName)
  366. {
  367.   fieldName = *newFieldName;
  368.   delete newFieldName;
  369.   fieldLine.Set();
  370. }
  373. void MenuItem::SetNotify(PString * newNotify)
  374. {
  375.   notifyName = *newNotify;
  376.   if (notifyName(0,1) == "::")
  377.     PError << StdError(Fatal)
  378.            << "menu item notify cannot be non-member function." << endl;
  379.   delete newNotify;
  380.   notifyLine.Set();
  381. }
  384. void MenuItem::SetAccelerators(PStringList * newAcc)
  385. {
  386.   if (newAcc != NULL) {
  387.     for (PINDEX i = 0; i < newAcc->GetSize(); i++) {
  388.       AccelCode key((*newAcc)[i]);
  389.       if (key.GetValue() != PKeyCode::NullValue)
  390.         accel.Append(new PKeyCode(key));
  391.     }
  392.     delete newAcc;
  393.   }
  394. }
  397. BOOL MenuItem::NeedsWindowParameter() const
  398. {
  399.   return !notifyName.IsEmpty() && notifyName[0] != '"';
  400. }
  403. void MenuItem::OutputCode(ostream & hdr_stream,
  404.                                           ostream & src_stream, MenuBar & mbar)
  405. {
  406.   hdr_stream << hdr_before;
  407.   src_stream << src_before;
  409.   if (!notifyName.IsEmpty()) {
  410.     PINDEX i;
  411.     for (i = 0; i < mbar.itemDict.GetSize(); i++)
  412.       if (notifyName == mbar.itemDict.GetDataAt(i).notifyName)
  413.         break;
  414.     if (this == &mbar.itemDict.GetDataAt(i)) {
  415.       src_stream << notifyLine << "  PNotifier notifier_";
  416.       if (notifyName[0] == '"')
  417.         src_stream << notifyName(1, notifyName.GetLength()-2)
  418.                    << " = PCREATE_COMMAND(";
  419.       else {
  420.         src_stream << notifyName << " = PCREATE_NOTIFIER2(wnd, ";
  421.         if (notifyName.Find("::") == P_MAX_INDEX)
  422.           src_stream << mbar.window << "::";
  423.       }
  424.       src_stream << notifyName << ");n";
  425.     }
  427.     src_stream << "  keyedItems[" << id << "].SetNotifier(notifier_";
  428.     if (notifyName[0] == '"')
  429.       src_stream << notifyName(1, notifyName.GetLength()-2) << ", TRUE";
  430.     else
  431.       src_stream << notifyName;
  432.     src_stream << ");n";
  433.   }
  435.   if (!fieldName.IsEmpty()) {
  436.     hdr_stream << fieldLine
  437.                << "    PMenuItem * " << fieldName << ";n";
  438.     src_stream << fieldLine
  439.                << "  " << fieldName << " = GetItemFromKey(" << id << ");n";
  440.   }
  442.   hdr_stream << hdr_after;
  443.   src_stream << src_after;
  444. }
  447. /////////////////////////////////////////
  448. //
  449. //  sub-menus
  450. //
  452. Menu::Menu(PString * title, MenuItemList * newItems)
  453.   : MenuItem(NULL),
  454.     items(*newItems)
  455. {
  456.   delete newItems;
  457.   SetText(title);
  458. }
  461. void Menu::SetUniqueItemIDs(MenuItemDict & itemDict)
  462. {
  463.   for (PINDEX i = 0; i < items.GetSize(); i++) {
  464.     if (items[i].IsClass(Menu::Class()))
  465.       ((Menu&)items[i]).SetUniqueItemIDs(itemDict);
  466.     else {
  467.       if (items[i].GetID() == -1) {
  468.         items[i].SetID(current_file->GetUniqueIdentifierValue(itemDict));
  469.         itemDict.SetAt(items[i].GetID(), &items[i]);
  470.       }
  471.     }
  472.   }
  473. }
  476. /////////////////////////////////////////
  477. //
  478. //  menubar
  479. //
  481. MenuBar::MenuBar(ResourceID * newID)
  482. {
  483.   ancestorClass = "PRootMenu";
  484.   SetID(newID);
  485.   itemDict.DisallowDeleteObjects();
  486. }
  489. void MenuBar::SetWindow(PString * newWindow)
  490. {
  491.   window = *newWindow;
  492.   delete newWindow;
  493.   windowLine.Set();
  494. }
  497. void MenuBar::SetMenuList(MenuList * newMenus)
  498. {
  499.   menus = *newMenus;
  500.   delete newMenus;
  502.   for (PINDEX i = 0; i < menus.GetSize(); i++)
  503.     menus[i].SetUniqueItemIDs(itemDict);
  504. }
  507. void MenuBar::OutputCode(ostream & hdr_stream, ostream & src_stream)
  508. {
  509.   // if the class definition does not contain a class name or window
  510.   // the the generation of any output is supressed
  512.   if (resourceClass.IsEmpty()) {
  513.     PError << StdError(Info, firstLine)
  514.            << "code generation supressed due to omission of class namen";
  515.     return;
  516.   }
  518.   BOOL needsWindowParameter = FALSE;
  519.   PINDEX i;
  520.   for (i = 0; i < itemDict.GetSize(); i++)
  521.     if (itemDict.GetDataAt(i).NeedsWindowParameter()) {
  522.       needsWindowParameter = TRUE;
  523.       break;
  524.     }
  526.   if (needsWindowParameter && window.IsEmpty()) {
  527.     PError << StdError(Info, firstLine)
  528.            << "code generation supressed due to omission of window namen";
  529.     return;
  530.   }
  532.   hdr_stream << hdr_before
  533.              << classLine
  534.              << "PDECLARE_CLASS(" << resourceClass
  535.              << ", " << ancestorClass << ")n"
  536.              << "  public:"
  537.              << windowLine
  538.              << "    " << resourceClass << '(';
  539.   if (needsWindowParameter)
  540.     hdr_stream << window << " * wnd";
  541.   hdr_stream << ");n";
  543.   src_stream << "nnn// " << resourceClass << "n"
  544.              << src_before
  545.              << classLine
  546.              << resourceClass << "::" << resourceClass << '(';
  547.   if (needsWindowParameter)
  548.     src_stream << windowLine << window << " * wnd";
  549.   src_stream << ")n  : " << ancestorClass << '(' << id << ")n{n";
  551.   for (i = 0; i < itemDict.GetSize(); i++)
  552.     itemDict.GetDataAt(i).OutputCode(hdr_stream, src_stream, *this);
  554.   hdr_stream << hdr_after << "};n";
  555.   src_stream << src_after << "}n";
  556. }
  559. /////////////////////////////////////////
  560. //
  561. //  A resource with a class specification and a position
  562. //
  564. ComplexResource::ComplexResource(const char * className)
  565.   : ClassedResource(className),
  566.     dim(0, 0)
  567. {
  568.   dim_set = FALSE;
  569. }
  572. void ComplexResource::SetDim(Point * newDim)
  573. {
  574.   dim = *newDim;
  575.   delete newDim;
  576.   dim_set = TRUE;
  577. }
  580. void ComplexResource::SetPos(Point * newPos)
  581. {
  582.   pos = *newPos;
  583.   delete newPos;
  584. }
  587. /////////////////////////////////////////
  588. //
  589. //  Control
  590. //    The base control type
  591. //
  593. Control::Control(const char * className, const char * valType)
  594.   : ComplexResource(className), valueType(valType)
  595. {
  596.   options = 0;
  597.   iconID = -1;
  598. }
  601. void Control::SetValueName(PString * newValuename, PString * newInitialiser)
  602. {
  603.   if (valueType.IsEmpty()) 
  604.     PError << StdError(Fatal)
  605.            << "control class " << resourceClass
  606.            << " cannot have a Value attribute." << endl;
  607.   else {
  608.     valueName = *newValuename;
  609.     initialiser = *newInitialiser;
  610.     valueLine.Set();
  611.   }
  612.   delete newValuename;
  613.   delete newInitialiser;
  614. }
  617. void Control::SetFieldName(PString * newFieldName)
  618. {
  619.   fieldName = *newFieldName;
  620.   delete newFieldName;
  621.   fieldLine.Set();
  622. }
  625. void Control::SetNotify(PString * newNotify)
  626. {
  627.   notifyName = *newNotify;
  628.   delete newNotify;
  629.   notifyLine.Set();
  630. }
  633. void Control::SetOptions(long)
  634. {
  635.   PError << StdError(Fatal)
  636.          << "control class " << resourceClass
  637.          << " cannot have an Options attribute." << endl;
  638. }
  641. void Control::SetLimits(long, long, long, long)
  642. {
  643.   PError << StdError(Fatal)
  644.          << "control class " << resourceClass
  645.          << " cannot have a Limits attribute." << endl;
  646. }
  649. void Control::SetIcon(long)
  650. {
  651.   PError << StdError(Fatal)
  652.          << "control class " << resourceClass
  653.          << " cannot have an icon attribute." << endl;
  654. }
  657. void Control::SetHelp(PString * newHelp)
  658. {
  659.   balloonHelp = *newHelp;
  660.   delete newHelp;
  661. }
  664. void Control::SetStringList(PStringList *)
  665. {
  666.   PError << StdError(Fatal)
  667.          << "control class " << resourceClass
  668.          << " does not have an attached string list." << endl;
  669. }
  672. void Control::OutputCode(ostream & hdr_stream, ostream & src_stream,
  673.                          ostream & save, ostream & restore,
  674.                          PString & ok_button, PString & cancel_button,
  675.                          PString & help_button, Layout & layout)
  676. {
  677.   hdr_stream << hdr_before;
  678.   src_stream << src_before;
  680.   // calculate the name and type of the "field" attribute
  681.   // if the field attribute is local, then declare it 
  682.   // if it is global or static, then do NOT declare it
  683.   // in any case, add the command to the constructor
  684.   if (fieldName.IsEmpty()) {
  685.     if ((options & OkButtonOption) != 0) {
  686.       fieldName = "ok";
  687.       fieldLine = layout.firstLine;
  688.     }
  689.     else if ((options & CancelButtonOption) != 0) {
  690.       fieldName = "cancel";
  691.       fieldLine = layout.firstLine;
  692.     }
  693.     else if ((options & HelpButtonOption) != 0) {
  694.       fieldName = "help";
  695.       fieldLine = layout.firstLine;
  696.     }
  697.   }
  698.   else if (fieldName.Find("::") == P_MAX_INDEX)
  699.     hdr_stream << fieldLine
  700.                << "  public: " << resourceClass << " * " << fieldName << ";n";
  702.   PString idstr(PString::Unsigned, (long)id);
  704.   // add the constructor for the control to the layout constructor string
  705.   src_stream << classLine << "  ";
  706.   if (!fieldName.IsEmpty())
  707.     src_stream << fieldName << " = ";
  708.   src_stream << "PNEW " << resourceClass << "(this, " << idstr << ", ";
  710.   // declare and implement the notify function
  711.   if (notifyName.IsEmpty())
  712.     src_stream << "PNotifier(), ";
  713.   else if (notifyName[0] == '"')
  714.     src_stream << "PCREATE_COMMAND(" << notifyName << "), ";
  715.   else {
  716.     src_stream << "PCREATE_NOTIFIER(";
  717.     if (notifyName.Find("::") != P_MAX_INDEX) {
  718.       PString local_notify = "_pnotify_" + idstr;
  719.       hdr_stream << notifyLine
  720.                  <<  "  private: PDECLARE_NOTIFIER(" << resourceClass << ", "
  721.                  << layout.resourceClass << ", " << local_notify << ")n"
  722.                     "      { " << notifyName << "(note, extra); }n";
  723.       src_stream << local_notify;
  724.     }
  725.     else {
  726.       PINDEX i;
  727.       for (i = 0; i < layout.itemDict.GetSize(); i++)
  728.         if (notifyName == layout.itemDict.GetDataAt(i).notifyName)
  729.           break;
  730.       if (this == &layout.itemDict.GetDataAt(i))
  731.         hdr_stream << notifyLine
  732.                    << "  public: PDECLARE_NOTIFIER(" << resourceClass << ", "
  733.                    << layout.resourceClass << ", " << notifyName << ");n";
  734.       src_stream << notifyName;
  735.     }
  736.     src_stream << "), ";
  737.   }
  739.   // if there is a value field, output the declaration and
  740.   // add the command to the constructor
  741.   if (valueName.IsEmpty())
  742.     src_stream << "NULL);n";
  743.   else {
  744.     if (valueName.Find("::") == P_MAX_INDEX)
  745.       hdr_stream << valueLine
  746.                  << "  public: " << valueType << ' ' << valueName << ";n";
  748.     // declare the "undo" buffer
  749.     PString undo_name = "_psave_" + idstr;
  750.     hdr_stream << "  protected: " << valueType << ' ' << undo_name << ";n";
  751.     src_stream << '&' << valueName << ");n";
  752.     if (!initialiser.IsEmpty())
  753.       src_stream << "  " << valueName << " = " << initialiser << ";n";
  754.     save << "  " << undo_name << " = " << valueName << ";n";
  755.     restore << "  " << valueName << " = " << undo_name << ";n";
  756.   }
  758.   // grab ok, cancel and help buttons
  759.   if ((options & OkButtonOption) != 0)
  760.     ok_button = fieldName;
  761.   else if ((options & CancelButtonOption) != 0)
  762.     cancel_button = fieldName;
  763.   else if ((options & HelpButtonOption) != 0)
  764.     help_button = fieldName;
  766.   hdr_stream << hdr_after;
  767.   src_stream << src_after;
  768. }
  771. /////////////////////////////////////////
  772. //
  773. //  ListControl
  774. //    The base control type for list controls. This class exists because
  775. //    the AddString and SetOptions functions are overrided from Control
  776. //
  778. ListControl::ListControl(const char * className, const char * valueType)
  779.   : Control(className, valueType)
  780. {
  781. }
  784. void ListControl::SetOptions(long new_option)
  785. {
  786.   if (new_option & ~(SortedOption|MultiSelectOption|MultiColumnOption|Special))
  787.     PError << StdError(Fatal)
  788.            << "invalid option for " << resourceClass << " control." << endl;
  789.   else
  790.     options |= new_option;
  791. }
  794. void ListControl::SetStringList(PStringList * newStringList)
  795. {
  796.   strList = *newStringList; delete newStringList;
  797. }
  800. /////////////////////////////////////////
  801. //
  802. //  LimitControl
  803. //    The base control type for controls that support limits. This class exists
  804. //    because the SetLimits functions is overrided from Control
  805. //
  807. LimitControl::LimitControl (const char * className, const char * valueType)
  808.   : Control(className, valueType)
  809. {
  810.   minimum = 0;
  811.   maximum = 100;
  812.   smallNudge = 1;
  813.   largeNudge = 10;
  814. }
  817. void LimitControl::SetLimits(long min, long max, long sml, long lge)
  818. {
  819.   minimum = min;
  820.   maximum = max;
  821.   smallNudge = sml;
  822.   largeNudge = lge;
  823. }
  826. /////////////////////////////////////////
  827. //
  828. //  control types
  829. //
  831. void PushButton::SetOptions(long new_option)
  832. {
  833.   if (new_option & ~(OkButtonOption|CancelButtonOption|HelpButtonOption|DefaultButtonOption))
  834.     PError << StdError(Fatal)
  835.            << "invalid option for " << resourceClass << " control." << endl;
  836.   else
  837.     options |= new_option;
  838. }
  841. BOOL PushButton::Validate()
  842. {
  843.   if ((options & OkButtonOption) != 0) {
  844.     if (id != -1)
  845.       PError << StdError(Warning)
  846.              << "OK button should be ID 1." << endl;
  847.     else
  848.       id = 1;
  849.   }
  850.   else if ((options & CancelButtonOption) != 0) {
  851.     if (id != -1)
  852.       PError << StdError(Warning)
  853.              << "Cancel button should be ID 2." << endl;
  854.     else
  855.       id = 2;
  856.   }
  857.   else if ((options & HelpButtonOption) != 0) {
  858.     if (id != -1)
  859.       PError << StdError(Warning)
  860.              << "Help button should be ID 3." << endl;
  861.     else
  862.       id = 3;
  863.   }
  864.   return TRUE;
  865. }
  868. void StaticIcon::SetIcon(long icon)
  869. {
  870.   if (icon < -32767 || icon > 65535)
  871.     PError << StdError(Warning)
  872.            << "icon ID must be 16 bit, truncating." << endl;
  873.   iconID = (int)icon;
  874. }
  876. BOOL UserControl::Validate()
  877. {
  878.   if (resourceClass.IsEmpty()) {
  879.     PError << StdError(Fatal)
  880.            << "User controls must have class defined." << endl;
  881.     return FALSE;
  882.   }
  884.   return TRUE;
  885. }
  888. /////////////////////////////////////////
  889. //
  890. //  add a control to a layout
  891. //
  893. Layout::Layout(const PString & ancestorName, int type)
  894. {
  895.   subtype = type;
  896.   fontSize = -1;
  897.   itemDict.DisallowDeleteObjects();
  898.   SetAncestorClass(ancestorName);
  899. }
  902. void Layout::SetFontInfo(PString * newFontname, int nsize)
  903. {
  904.   fontName = *newFontname;
  905.   delete newFontname;
  906.   fontSize = nsize; 
  907. }
  910. void Layout::SetHeader(PString * newHeader)
  911. {
  912.   header = *newHeader;
  913.   delete newHeader;
  914. }
  917. void Layout::AddControl(Control * newControl)
  918. {
  919.   if (!newControl->Validate())
  920.     return;
  922.   if (itemDict.GetAt(newControl->GetID()) != NULL) {
  923.     PError << StdError(Warning)
  924.            << "ignoring multiple definition of dialog item "
  925.            << newControl->GetID() << '.' << endl;
  926.     return;
  927.   }
  929.   if (newControl->GetID() != -1)
  930.     itemDict.SetAt(newControl->GetID(), newControl);
  931.   itemList.Append(newControl);
  933.   if (!dim_set) {
  934.     Point ctl_pos = newControl->GetPos();
  935.     Point ctl_dim = newControl->GetDim();
  936.     int tmp = ctl_pos.X()+ctl_dim.X()+10;
  937.     if (dim.X() < tmp)
  938.       dim.SetX(tmp);
  939.     tmp = ctl_pos.Y()+ctl_dim.Y()+10;
  940.     if (dim.Y() < tmp)
  941.       dim.SetY(tmp);
  942.   }
  943. }
  946. void Layout::SetUniqueItemIDs()
  947. {
  948.   for (PINDEX i = 0; i < itemList.GetSize(); i++)
  949.     if (itemList[i].GetID() == -1) {
  950.       itemList[i].SetID(current_file->GetUniqueIdentifierValue(itemDict));
  951.       itemDict.SetAt(itemList[i].GetID(), &itemList[i]);
  952.     }
  953. }
  956. void Layout::OutputCode(ostream & hdr_stream, ostream & src_stream)
  957. {
  958.   // if the class definition does not contain a class name,
  959.   // the the generation of any output is supressed
  960.   if (resourceClass.IsEmpty()) {
  961.     PError << StdError(Info, firstLine) 
  962.            << "code generation supressed due to omission of class namen";
  963.     return;
  964.   }
  966.   src_stream << "nnn// " << resourceClass << "nn";
  968.   // output class declaration and constructor code or Construct body
  969.   if (header.IsEmpty()) {
  970.     hdr_stream << classLine
  971.                << "PDECLARE_CLASS(" << resourceClass << ", "
  972.                << ancestorClass << ")n"
  973.                << hdr_before
  974.                << "  public:n"
  975.                << "    " << resourceClass
  976.                << "(PInteractor *, PRESOURCE_ID id = " << id << ");n";
  977.     src_stream << classLine << resourceClass << "::" << resourceClass
  978.                << "(PInteractor * parent, PRESOURCE_ID id)n"
  979.                   "  : " << ancestorClass << "(parent, id)n"
  980.                   "{n";
  981.   }
  982.   else {
  983.     hdr_stream << "#include " << header << "nn"
  984.                << hdr_before
  985.                << "  public:n"
  986.                   "    void Construct(PRESOURCE_ID id = " << id << ");n";
  987.     src_stream << "void " << resourceClass << "::Construct(PRESOURCE_ID id)n"
  988.                   "{n";
  989.   }
  991.   src_stream << src_before;
  993.   PStringStream layout_save, layout_restore;
  994.   PString ok_button, cancel_button, help_button;
  996.   for (PINDEX i = 0; i < itemList.GetSize(); i++)
  997.     itemList[i].OutputCode(hdr_stream, src_stream,
  998.                            layout_save, layout_restore,
  999.                            ok_button, cancel_button, help_button,
  1000.                            *this);
  1002.   // output public declarations and constructor declaration
  1003.   if (!layout_save.IsEmpty())
  1004.     hdr_stream << "  public:n"
  1005.                   "    void Restore();n"
  1006.                   "    void Save();n";
  1008.   // finish class declaration
  1009.   hdr_stream << hdr_after << "n};nn";
  1011.   if (subtype == 0) {
  1012.     if (!ok_button.IsEmpty() || !cancel_button.IsEmpty())
  1013.       PError << StdError(Info, firstLine)
  1014.              << "layout defined with "Ok" or "Cancel" buttonn";
  1015.   }
  1016.   else {
  1017.     if (subtype == 2 && ok_button.IsEmpty() && cancel_button.IsEmpty())
  1018.       PError << StdError(Warning, firstLine)
  1019.              << "modal dialog defined without "Ok" or "Cancel" buttonn";
  1021.     src_stream << "  SetStdButtons(";
  1022.     if (ok_button.IsEmpty())
  1023.       src_stream << "NULL";
  1024.     else
  1025.       src_stream << ok_button;
  1026.     src_stream << ", ";
  1027.     if (cancel_button.IsEmpty())
  1028.       src_stream << "NULL";
  1029.     else
  1030.       src_stream << cancel_button;
  1031.     src_stream << ", ";
  1032.     if (help_button.IsEmpty()) 
  1033.       src_stream << "NULL";
  1034.     else
  1035.       src_stream << help_button;
  1036.     src_stream << ");n";
  1037.   }
  1039.   src_stream << "  ConstructEnd(id);n"
  1040.              << src_after
  1041.              << "}nn";
  1043.   // output the save and restore functions if there is something in them
  1044.   if (!layout_save.IsEmpty()) 
  1045.     src_stream << "void "
  1046.                << resourceClass
  1047.                << "::Save()n{n"
  1048.                << layout_save
  1049.                << "n}nnvoid "
  1050.                << resourceClass
  1051.                << "::Restore()n{n"
  1052.                << layout_restore
  1053.                << "n}nnn";
  1054. }
  1057. /////////////////////////////////////////
  1058. //
  1059. //  holder for assorted binary data items
  1060. //
  1062. BinaryData::BinaryData()
  1063.   : PAbstractArray(sizeof(BYTE), 512),
  1064.     realSize(0)
  1065. {
  1066. }
  1069. BinaryData::BinaryData(const BinaryData & array)
  1070.   : PAbstractArray(array),
  1071.     realSize(array.realSize)
  1072. {
  1073. }
  1076. BinaryData & BinaryData::operator=(const BinaryData & array)
  1077. {
  1078.   PAbstractArray::operator=(array);
  1079.   realSize = array.realSize;
  1080.   return *this;
  1081. }
  1084. void BinaryData::Append (int newSize, const BYTE * newData)
  1085. {
  1086.   if (realSize + newSize > PAbstractArray::GetSize())
  1087.     SetSize((PAbstractArray::GetSize() + newSize+511)&~511);
  1088.   memcpy (theArray + realSize, newData, newSize);
  1089.   realSize += newSize;
  1090. }
  1093. /////////////////////////////////////////
  1094. //
  1095. //  pixel resource objects
  1096. //
  1098. PixelContents::PixelContents()
  1099. {
  1100.   haveDimensions = FALSE;
  1101.   haveHotSpot = FALSE;
  1102.   depth = 1;
  1103. }
  1106. void PixelContents::SetDimensions(long w, long h, long d)
  1107. {
  1108.   if (w < -32767 || w > 32767 || h < -32767 || h > 32767)
  1109.       PError << StdError(Warning)
  1110.              << "image dimensions must be 16 bit, truncating." << endl;
  1111.   if (d < 0 || d > 32767)
  1112.       PError << StdError(Warning)
  1113.              << "image depth must be 16 bit, truncating." << endl;
  1114.   width = (int)w;
  1115.   height = (int)h;
  1116.   depth = (int)d;
  1117.   haveDimensions = TRUE;
  1118. }
  1119.       
  1121. void PixelContents::SetHotSpot(long hx, long hy)
  1122. {
  1123.   if (hx < -32767 || hx > 32767 || hy < -32767 || hy > 32767)
  1124.       PError << StdError(Warning)
  1125.              << "image position must be 16 bit, truncating." << endl;
  1126.   x = (int)hx;
  1127.   y = (int)hy;
  1128.   haveHotSpot = TRUE;
  1129. }
  1132. void PixelContents::SetClut(BinaryData * data)
  1133. {
  1134.   clut = *data;
  1135.   delete data;
  1136. }
  1138. void PixelContents::SetAndMask(PixData * data)
  1139. {
  1140.   andMask = *data;
  1141.   delete data;
  1142. }
  1144. void PixelContents::SetXorMask(PixData * data)
  1145. {
  1146.   xorMask = *data;
  1147.   delete data;
  1148. }
  1150. void PixelContents::SetPixels(PixData * data)
  1151. {
  1152.   pixels = *data;
  1153.   delete data;
  1154. }
  1157. void PixelContents::Verify(int dfltWidth, int dfltHeight, const char * resname,
  1158.                            BOOL masks, BOOL allowScaling)
  1159. {
  1160.   if (haveDimensions) {
  1161.     if ((dfltWidth  != 0 && width  != dfltWidth  && (!allowScaling || (width  != dfltWidth*2  && width  != dfltWidth/2))) ||
  1162.         (dfltHeight != 0 && height != dfltHeight && (!allowScaling || (height != dfltHeight*2 && height != dfltHeight/2))))
  1163.       PError << StdError(Warning)
  1164.              << resname << " dimensions should be "
  1165.              << dfltWidth << 'x' << dfltHeight << '.' << endl;
  1166.   }
  1167.   else {
  1168.     if (dfltWidth != 0) { // Is Pixmap
  1169.       width = dfltWidth;
  1170.       height = dfltHeight;
  1171.     }
  1172.     else {
  1173.       PError << StdError(Fatal)
  1174.              << resname << " must have a dimension." << endl;
  1175.       return;
  1176.     }
  1177.   }
  1179.   if (depth != 1 && depth != 4 && depth != 8 && depth != 24) {
  1180.     PError << StdError(Fatal)
  1181.            << resname << " should have depth of 1, 4, 8 or 24 bits." << endl;
  1182.     return;
  1183.   }
  1185.   if (clut.GetSize() != 0 || (depth != 1 && depth != 24)) {
  1186.     int clutSize = (1 << depth)*3;
  1187.     if (clut.GetSize() != (PINDEX)clutSize) {
  1188.       PError << StdError(Warning)
  1189.              << resname << " should have "
  1190.              << clutSize << " bytes of colour data ("
  1191.              << clut.GetSize() << " found)." << endl;
  1192.       clut.SetSize((PINDEX)clutSize);
  1193.     }
  1194.   }
  1196.   if (clut.GetSize() == 0) {
  1197.     int numColours = 1 << depth;
  1198.     int inc = (256+numColours-1)/numColours;
  1199.     int val = 0;
  1200.     for (int col = 0; col < numColours-1; col++) {
  1201.       clut.Append((BYTE)val);
  1202.       clut.Append((BYTE)val);
  1203.       clut.Append((BYTE)val);
  1204.       val += inc;
  1205.     }
  1206.     clut.Append(0xff);
  1207.     clut.Append(0xff);
  1208.     clut.Append(0xff);
  1209.   }
  1211.   if (!masks || depth != 1) { // Is Pixmap or colour icon/cursor
  1212.     long pixSize = width*height;
  1213.     if (depth == 24)
  1214.       pixSize *= 3;
  1215.     if (pixels.GetSize() != (PINDEX)pixSize) {
  1216.       PError << StdError(Warning)
  1217.              << resname << " should have "
  1218.              << pixSize << " pixels ("
  1219.              << pixels.GetSize() << " found)." << endl;
  1220.       pixels.SetSize((PINDEX)pixSize);
  1221.     }
  1222.   }
  1224.   if (masks) { // Is Icon or Cursor
  1225.     long maskSize = width*height;
  1226.     if (andMask.GetSize() != (PINDEX)maskSize) {
  1227.       PError << StdError(Warning)
  1228.              << resname << " should have "
  1229.              << maskSize << " pixels of AND mask data ("
  1230.              << andMask.GetSize() << " found)." << endl;
  1231.       andMask.SetSize((PINDEX)maskSize);
  1232.     }
  1233.     if (depth == 1 && xorMask.GetSize() != (PINDEX)maskSize) {
  1234.       PError << StdError(Warning)
  1235.              << resname << " should have "
  1236.              << maskSize << " pixels of XOR mask data ("
  1237.              << xorMask.GetSize() << " found)." << endl;
  1238.       xorMask.SetSize((PINDEX)maskSize);
  1239.     }
  1240.   }
  1241. }
  1244. /////////////////////////////////////////
  1245. //
  1246. //  pixel based resources
  1247. //
  1249. PixelResource::PixelResource(ResourceID * newId, PixelContents * newContents)
  1250.   : ResourceObject(newId, NULL),
  1251.     contents(*newContents)
  1252. {
  1253.   delete newContents;
  1254. }
  1257. /////////////////////////////////////////
  1258. //
  1259. //  icon resources
  1260. //
  1262. Icon::Icon(ResourceID * id, PixelContents * newContents)
  1263.   : PixelResource(id, newContents)
  1264. {
  1265.   contents.Verify(32, 32, "icon", TRUE, TRUE);
  1266. }
  1269. /////////////////////////////////////////
  1270. //
  1271. //  cursor resources
  1272. //
  1274. CursorResource::CursorResource(ResourceID * id, PixelContents * newContents)
  1275.   : PixelResource(id, newContents)
  1276. {
  1277.   contents.Verify(16, 16, "cursor", TRUE, FALSE);
  1278.   if (!contents.haveHotSpot) {
  1279.     PError << StdError(Info)
  1280.          << "cursor should have a HOTSPOT, assuming 1,1." << endl;
  1281.     contents.x = contents.y = 1;
  1282.   }
  1283. }
  1286. /////////////////////////////////////////
  1287. //
  1288. //  pattern resources
  1289. //
  1291. Pattern::Pattern(ResourceID * id, PixelContents * newContents)
  1292.   : PixelResource(id, newContents)
  1293. {
  1294.   contents.Verify(8, 8, "pattern", FALSE, FALSE);
  1295. }
  1298. /////////////////////////////////////////
  1299. //
  1300. //  image resources
  1301. //
  1303. Image::Image(ResourceID * id, PixelContents * newContents)
  1304.   : PixelResource(id, newContents)
  1305. {
  1306.   contents.Verify(0, 0, "image", FALSE, FALSE);
  1307. }
  1310. /////////////////////////////////////////
  1311. //
  1312. //  arbitrary data resources
  1313. //
  1315. DataResource::DataResource(ResourceID * id,
  1316.                                        PString * newText, BinaryData * newData)
  1317.   : ResourceObject(id, NULL), data(*newData)
  1318. {
  1319.   delete newData;
  1321.   if (newText != NULL) {
  1322.     textLiteral = *newText;
  1323.     delete newText;
  1324.     textConverted = PString(PString::Literal, textLiteral);
  1325.     if (textConverted.GetLength() < 4) {
  1326.       textConverted += "    ";
  1327.       textConverted = textConverted(0,3);
  1328.       PError << StdError(Info)
  1329.              << "resource type name too short, spaced out to 4 characters."
  1330.              << endl;
  1331.     }
  1332.     else if (textConverted.GetLength() > 4) {
  1333.       textConverted = textConverted(0,3);
  1334.       PError << StdError(Warning)
  1335.              << "resource type name too long, truncated to 4 characters."
  1336.              << endl;
  1337.     }
  1338.   }
  1339. }
  1342. /////////////////////////////////////////
  1343. //
  1344. //  resource file data
  1345. //
  1347. void ResourceFile::OutputCode(const PFilePath & hdrname,
  1348.                  ostream & hdr_stream, ostream & src_stream, BOOL suppressFlag)
  1349. {
  1350.   src_stream << "//n// Source file generated by PWRCn//nn";
  1351.   if (!suppressFlag) 
  1352.     src_stream << "#include <pwlib.h>n"
  1353.                   "#include "" << hdrname.GetFileName() << ""nn";
  1355.   hdr_stream << "//n// Header file generated by PWRCn//nn"
  1356.              << "#ifndef _PWRC_GENERATED_HEADERn"
  1357.              << "#define _PWRC_GENERATED_HEADERnn"
  1358.              << hdr_inline;
  1359.   src_stream << src_inline;
  1361.   PINDEX i;
  1362.   for (i = 0; i < menubarDict.GetSize(); i++)
  1363.     menubarDict.GetDataAt(i).OutputCode(hdr_stream, src_stream);
  1365.   for (i = 0; i < dialogDict.GetSize(); i++)
  1366.     dialogDict.GetDataAt(i).OutputCode(hdr_stream, src_stream);
  1368.   hdr_stream << "n#endifnn";
  1369. }
  1372. ResourceID * ResourceFile::GetAutoIdentifier(PString * identifier,
  1373.                                               const PAbstractDictionary & dict)
  1374. {
  1375.   PString ident = *identifier;
  1376.   if (defineDict.GetAt(ident) != NULL)
  1377.     return PNEW ResourceID(GetIdentifierValue(identifier), ident);
  1379.   while (dict.GetAt(nextResourceId) != NULL)
  1380.     nextResourceId++;
  1382.   hdr_inline << LineNumber()
  1383.              << "#define " << ident << ' ' << nextResourceId << 'n';
  1385.   AddDefineIdentifier(identifier, new DefineValue(nextResourceId, TRUE));
  1386.   return PNEW ResourceID(nextResourceId, ident);
  1387. }
  1390. ResourceID * 
  1391.        ResourceFile::GetUniqueIdentifierValue(const PAbstractDictionary & dict)
  1392. {
  1393.   while (dict.GetAt(nextResourceId) != NULL)
  1394.     nextResourceId++;
  1395.   return PNEW ResourceID(nextResourceId++);
  1396. }
  1399. void ResourceFile::AddDefineIdentifier(PString * identifer,DefineValue * value)
  1400. {
  1401.   if (defineDict.GetAt(*identifer) == NULL)
  1402.     defineDict.SetAt(*identifer, value);
  1403.   else {
  1404.     PError << StdError(Warning) 
  1405.          << "ignoring redefinition of macro "" << *identifer << ""." << endl;
  1406.     delete value;
  1407.   }
  1408.   delete identifer;
  1409. }
  1412. int ResourceFile::GetIdentifierValue(PString * identifier)
  1413. {
  1414.   PString id = *identifier;
  1415.   delete identifier;
  1417.   if (defineDict.GetAt(id) == NULL) {
  1418.     PError << StdError(Fatal)
  1419.            << "reference to undefined macro "" << id << ""." << endl;
  1420.     return 1;
  1421.   }
  1423.   if (defineDict[id].IsString()) {
  1424.     PError << StdError(Fatal)
  1425.            << "macro "" << id << "" of incorrect type." << endl;
  1426.     return 1;
  1427.   }
  1429.   return (int)defineDict[id];
  1430. }
  1433. void ResourceFile::AddResource(ResourceList::ResTypes res,
  1434.                                     ResourceObject * obj, const char * resname)
  1435. {
  1436.   if (obj->GetID() == -1)
  1437.     obj->SetID(GetUniqueIdentifierValue(*resourceDict[res]));
  1439.   if (resourceDict[res]->GetAt(obj->GetID()) == NULL) {
  1440.     resourceDict[res]->SetAt(obj->GetID(), obj);
  1441.     resources[res].Append(obj);
  1442.   }
  1443.   else {
  1444.     PError << StdError(Warning)
  1445.            << "ignoring redefinition of " << resname << " resource number "
  1446.            << obj->GetID() << '.' << endl;
  1447.     delete obj;
  1448.   }
  1449. }
  1452. // End CODEGEN.CXX ////////////////////////////////////////////////////////////