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

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

IP电话/视频会议

开发平台：

Visual C++

httpform.cxx：源码内容
  1. /*
  2.  * httpform.cxx
  3.  *
  4.  * Forms using HTTP user interface.
  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: httpform.cxx,v $
  30.  * Revision 1.31  2000/06/19 11:35:01  robertj
  31.  * Fixed bug in setting current value of options in select form fields.
  32.  *
  33.  * Revision 1.30  1999/02/10 13:19:45  robertj
  34.  * Fixed PConfig update problem when POSTing to the form. Especiall with arrays.
  35.  *
  36.  * Revision 1.29  1998/11/30 04:51:57  robertj
  37.  * New directory structure
  38.  *
  39.  * Revision 1.28  1998/11/14 11:11:06  robertj
  40.  * PPC GNU compiler compatibility.
  41.  *
  42.  * Revision 1.27  1998/10/01 09:05:11  robertj
  43.  * Fixed bug in nested composite field names, array indexes not being set correctly.
  44.  *
  45.  * Revision 1.26  1998/09/23 06:22:11  robertj
  46.  * Added open source copyright license.
  47.  *
  48.  * Revision 1.25  1998/08/20 05:51:06  robertj
  49.  * Fixed bug where substitutions did not always occur if near end of macro block.
  50.  * Improved internationalisation. Allow HTML override of strings in macros.
  51.  *
  52.  * Revision 1.24  1998/08/09 11:25:51  robertj
  53.  * GNU C++ warning removal.
  54.  *
  55.  * Revision 1.23  1998/08/09 10:35:11  robertj
  56.  * Changed array control so can have language override.
  57.  *
  58.  * Revision 1.22  1998/07/24 06:56:05  robertj
  59.  * Fixed case significance problem in HTTP forms.
  60.  * Improved detection of VALUE= fields with and without quotes.
  61.  *
  62.  * Revision 1.21  1998/03/20 03:16:43  robertj
  63.  * Fixed bug in beaing able to reset a check box field.
  64.  *
  65.  * Revision 1.20  1998/02/03 06:26:09  robertj
  66.  * Fixed propagation of inital values in arrays subfields.
  67.  * Fixed problem where hidden fields were being relaced with default values from PHTTPForm.
  68.  *
  69.  * Revision 1.19  1998/01/26 02:49:17  robertj
  70.  * GNU support.
  71.  *
  72.  * Revision 1.18  1998/01/26 01:51:37  robertj
  73.  * Fixed uninitialised variable.
  74.  *
  75.  * Revision 1.17  1998/01/26 00:25:25  robertj
  76.  * Major rewrite of HTTP forms management.
  77.  *
  78.  * Revision 1.16  1997/12/18 05:06:51  robertj
  79.  * Added missing braces to kill GNU compiler warning.
  80.  *
  81.  * Revision 1.15  1997/10/10 10:43:43  robertj
  82.  * Fixed bug in password encryption, missing string terminator.
  83.  *
  84.  * Revision 1.14  1997/08/28 12:48:29  robertj
  85.  * Changed array fields to allow for reordering.
  86.  *
  87.  * Revision 1.13  1997/08/21 12:44:10  robertj
  88.  * Fixed bug in HTTP form array size field.
  89.  * Fixed bug where section list was only replacing first instance of macro.
  90.  *
  91.  * Revision 1.12  1997/08/09 07:46:52  robertj
  92.  * Fixed problems with value of SELECT fields in form
  93.  *
  94.  * Revision 1.11  1997/08/04 10:41:13  robertj
  95.  * Fixed bug in new section list page for names with special characters in them.
  96.  *
  97.  * Revision 1.10  1997/07/26 11:38:20  robertj
  98.  * Support for overridable pages in HTTP service applications.
  99.  *
  100.  * Revision 1.9  1997/07/14 11:49:51  robertj
  101.  * Put "Add" and "Keep" on check boxes in array fields.
  102.  *
  103.  * Revision 1.8  1997/07/08 13:12:29  robertj
  104.  * Major HTTP form enhancements for lists and arrays of fields.
  105.  *
  106.  * Revision 1.7  1997/06/08 04:47:27  robertj
  107.  * Adding new llist based form field.
  108.  *
  109.  * Revision 1.6  1997/04/12 02:07:26  robertj
  110.  * Fixed boolean check boxes being more flexible on string values.
  111.  *
  112.  * Revision 1.5  1997/04/01 06:00:53  robertj
  113.  * Changed PHTTPConfig so if section empty string, does not write PConfig parameters.
  114.  *
  115.  * Revision 1.4  1996/10/08 13:10:34  robertj
  116.  * Fixed bug in boolean (checkbox) html forms, cannot be reset.
  117.  *
  118.  * Revision 1.3  1996/09/14 13:09:31  robertj
  119.  * Major upgrade:
  120.  *   rearranged sockets to help support IPX.
  121.  *   added indirect channel class and moved all protocols to descend from it,
  122.  *   separating the protocol from the low level byte transport.
  123.  *
  124.  * Revision 1.2  1996/08/08 13:34:10  robertj
  125.  * Removed redundent call.
  126.  *
  127.  * Revision 1.1  1996/06/28 12:56:20  robertj
  128.  * Initial revision
  129.  *
  130.  */
  132. #ifdef __GNUC__
  133. #pragma implementation "httpform.h"
  134. #endif
  136. #include <ptlib.h>
  137. #include <ptclib/httpform.h>
  138. #include <ptclib/cypher.h>
  141. //////////////////////////////////////////////////////////////////////////////
  142. // PHTTPField
  144. PHTTPField::PHTTPField(const char * nam, const char * titl, const char * hlp)
  145.   : baseName(nam), fullName(nam),
  146.     title(titl != NULL ? titl : nam),
  147.     help(hlp != NULL ? hlp : "")
  148. {
  149.   notInHTML = TRUE;
  150. }
  153. PObject::Comparison PHTTPField::Compare(const PObject & obj) const
  154. {
  155.   PAssert(obj.IsDescendant(PHTTPField::Class()), PInvalidCast);
  156.   return fullName.Compare(((const PHTTPField &)obj).fullName);
  157. }
  160. void PHTTPField::SetName(const PString & newName)
  161. {
  162.   fullName = newName;
  163. }
  166. const PHTTPField * PHTTPField::LocateName(const PString & name) const
  167. {
  168.   if (fullName == name)
  169.     return this;
  171.   return NULL;
  172. }
  175. void PHTTPField::SetHelp(const PString & hotLinkURL,
  176.                          const PString & linkText)
  177. {
  178.   help = "<A HREF="" + hotLinkURL + "">" + linkText + "</A>rn";
  179. }
  182. void PHTTPField::SetHelp(const PString & hotLinkURL,
  183.                          const PString & imageURL,
  184.                          const PString & imageText)
  185. {
  186.   help = "<A HREF="" + hotLinkURL + ""><IMG SRC="" +
  187.              imageURL + "" ALT="" + imageText + "" ALIGN=absmiddle></A>rn";
  188. }
  191. static BOOL FindSpliceBlock(const PRegularExpression & startExpr,
  192.                             const PRegularExpression & endExpr,
  193.                             const PString & text,
  194.                             PINDEX offset,
  195.                             PINDEX & pos,
  196.                             PINDEX & len,
  197.                             PINDEX & start,
  198.                             PINDEX & finish)
  199. {
  200.   start = finish = P_MAX_INDEX;
  202.   if (!text.FindRegEx(startExpr, pos, len, offset))
  203.     return FALSE;
  205.   PINDEX endpos, endlen;
  206.   if (!text.FindRegEx(endExpr, endpos, endlen, pos+len))
  207.     return TRUE;
  209.   start = pos + len;
  210.   finish = endpos - 1;
  211.   len = endpos - pos + endlen;
  212.   return TRUE;
  213. }
  216. static BOOL FindSpliceBlock(const PRegularExpression & startExpr,
  217.                             const PString & text,
  218.                             PINDEX offset,
  219.                             PINDEX & pos,
  220.                             PINDEX & len,
  221.                             PINDEX & start,
  222.                             PINDEX & finish)
  223. {
  224.   static PRegularExpression EndBlock("<?!--#form[ trn]+end[ trn]*-->?",
  225.                                      PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  226.   return FindSpliceBlock(startExpr, EndBlock, text, offset, pos, len, start, finish);
  227. }
  230. static BOOL FindSpliceName(const PCaselessString & text,
  231.                            PINDEX start,
  232.                            PINDEX finish,
  233.                            PINDEX & pos,
  234.                            PINDEX & end)
  235. {
  236.   if (text[start+1] != '!') {
  237.     static PRegularExpression NameExpr("name[ trn]*=[ trn]*"[^"]*"",
  238.                                        PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  239.     if ((pos = text.FindRegEx(NameExpr, start)) == P_MAX_INDEX)
  240.       return FALSE;
  242.     if (pos >= finish)
  243.       return FALSE;
  245.     pos = text.Find('"', pos) + 1;
  246.     end = text.Find('"', pos) - 1;
  247.   }
  248.   else {
  249.     pos = start + 9;            // Skip over the <!--#form
  250.     while (isspace(text[pos]))  // Skip over blanks
  251.       pos++;
  252.     while (pos < finish && !isspace(text[pos])) // Skip over keyword
  253.       pos++;
  254.     while (isspace(text[pos]))  // Skip over more blanks
  255.       pos++;
  256.     
  257.     end = text.Find("--", pos) - 1;
  258.   }
  260.   return end < finish;
  261. }
  264. static BOOL FindSpliceFieldName(const PString & text,
  265.                             PINDEX offset,
  266.                             PINDEX & pos,
  267.                             PINDEX & len,
  268.                             PString & name)
  269. {
  270.   static PRegularExpression FieldName("<?!--#form[ trn]+[a-z0-9]+[ trn]+[^-]+[ trn]*-->?"
  271.                                       "|"
  272.                                       "<[a-z]+[ trn][^>]*name[ trn]*=[ trn]*"[^"]*"[^>]*>",
  273.                                       PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  274.   if (!text.FindRegEx(FieldName, pos, len, offset))
  275.     return FALSE;
  277.   PINDEX nameStart, nameEnd;
  278.   if (!FindSpliceName(text, pos, pos+len-1, nameStart, nameEnd))
  279.     return FALSE;
  281.   name = text(nameStart, nameEnd);
  282.   pos = nameStart;
  283.   len = nameEnd - nameStart + 1;
  284.   return TRUE;
  285. }
  288. static void SpliceAdjust(const PString & str,
  289.                          PString & text,
  290.                          PINDEX pos,
  291.                          PINDEX & len,
  292.                          PINDEX & finish)
  293. {
  294.   text.Splice(str, pos, len);
  295.   PINDEX newLen = str.GetLength();
  296.   if (finish != P_MAX_INDEX)
  297.     finish += newLen - len;
  298.   len = newLen;
  299. }
  302. void PHTTPField::ExpandFieldNames(PString & text, PINDEX start, PINDEX & finish) const
  303. {
  304.   PString name;
  305.   PINDEX pos, len;
  306.   while (start < finish && FindSpliceFieldName(text, start, pos, len, name)) {
  307.     if (pos > finish)
  308.       break;
  309.     if (baseName == name)
  310.       SpliceAdjust(fullName, text, pos, len, finish);
  311.     start = pos + len;
  312.   }
  313. }
  316. static BOOL FindInputValue(const PString & text, PINDEX & before, PINDEX & after)
  317. {
  318.   static PRegularExpression Value("value[ trn]*=[ trn]*("[^"]*"|[^> trn]+)",
  319.                                   PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  320.   PINDEX pos = text.FindRegEx(Value);
  321.   if (pos == P_MAX_INDEX)
  322.     return FALSE;
  324.   before = text.Find('"', pos);
  325.   if (before != P_MAX_INDEX)
  326.     after = text.Find('"', before+1);
  327.   else {
  328.     before = text.Find('=', pos);
  329.     while (isspace(text[before+1]))
  330.       before++;
  331.     after = before + 1;
  332.     while (text[after] != '' && text[after] != '>' && !isspace(text[after]))
  333.       after++;
  334.   }
  335.   return TRUE;
  336. }
  339. PString PHTTPField::GetHTMLInput(const PString & input) const
  340. {
  341.   PINDEX before, after;
  342.   if (FindInputValue(input, before, after))
  343.     return input(0, before) + GetValue(FALSE) + input.Mid(after);
  345.   return "<input value="" + GetValue(FALSE) + """ + input.Mid(6);
  346. }
  349. static void AdjustSelectOptions(PString & text, PINDEX begin, PINDEX end,
  350.                                 const PString & myValue, PStringList & validValues,
  351.                                 PINDEX & finishAdjust)
  352. {
  353.   PINDEX start, finish;
  354.   PINDEX pos = begin;
  355.   PINDEX len = 0;
  356.   static PRegularExpression StartOption("<[ trn]*option[^>]*>",
  357.                                         PRegularExpression::IgnoreCase);
  358.   static PRegularExpression EndOption("<[ trn]*/?option[^>]*>",
  359.                                       PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  360.   while (FindSpliceBlock(StartOption, EndOption, text, pos+len, pos, len, start, finish) && pos < end) {
  361.     PCaselessString option = text(pos, start-1);
  362.     PINDEX before, after;
  363.     if (FindInputValue(option, before, after)) {
  364.       start = pos + before + 1;
  365.       finish = pos + after - 1;
  366.     }
  367.     PINDEX selpos = option.Find("selected");
  368.     PString thisValue = text(start, finish);
  369.     if (thisValue == myValue) {
  370.       if (selpos == P_MAX_INDEX) {
  371.         text.Splice(" selected", pos+7, 0);
  372.         if (finishAdjust != P_MAX_INDEX)
  373.           finishAdjust += 9;
  374.         if (end != P_MAX_INDEX)
  375.           end += 9;
  376.         len += 9;
  377.       }
  378.     }
  379.     else {
  380.       if (validValues.GetSize() > 0) {
  381.         PINDEX valid;
  382.         for (valid = 0; valid < validValues.GetSize(); valid++) {
  383.           if (thisValue == validValues[valid])
  384.             break;
  385.         }
  386.         if (valid >= validValues.GetSize()) {
  387.           text.Delete(pos, len);
  388.           selpos = P_MAX_INDEX;
  389.           if (finishAdjust != P_MAX_INDEX)
  390.             finishAdjust -= len;
  391.           if (end != P_MAX_INDEX)
  392.             end -= len;
  393.           len = 0;
  394.         }
  395.       }
  396.       if (selpos != P_MAX_INDEX) {
  397.         selpos += pos;
  398.         PINDEX sellen = 8;
  399.         if (text[selpos-1] == ' ') {
  400.           selpos--;
  401.           sellen++;
  402.         }
  403.         text.Delete(selpos, sellen);
  404.         if (finishAdjust != P_MAX_INDEX)
  405.           finishAdjust -= sellen;
  406.         if (end != P_MAX_INDEX)
  407.           end -= sellen;
  408.         len -= sellen;
  409.       }
  410.     }
  411.   }
  412. }
  414. PString PHTTPField::GetHTMLSelect(const PString & selection) const
  415. {
  416.   PString text = selection;
  417.   PStringList dummy1;
  418.   PINDEX dummy2 = P_MAX_INDEX;
  419.   AdjustSelectOptions(text, 0, P_MAX_INDEX, GetValue(FALSE), dummy1, dummy2);
  420.   return text;
  421. }
  424. void PHTTPField::GetHTMLHeading(PHTML &) const
  425. {
  426. }
  429. static int SplitConfigKey(const PString & fullName,
  430.                           PString & section, PString & key)
  431. {
  432.   if (fullName.IsEmpty())
  433.     return 0;
  435.   PINDEX slash = fullName.FindLast('\');
  436.   if (slash == 0 || slash >= fullName.GetLength()-1) {
  437.     key = fullName;
  438.     return 1;
  439.   }
  441.   section = fullName.Left(slash);
  442.   key = fullName.Mid(slash+1);
  443.   if (section.IsEmpty() || key.IsEmpty())
  444.     return 0;
  446.   return 2;
  447. }
  450. void PHTTPField::LoadFromConfig(PConfig & cfg)
  451. {
  452.   PString section, key;
  453.   switch (SplitConfigKey(fullName, section, key)) {
  454.     case 1 :
  455.       SetValue(cfg.GetString(key, GetValue(TRUE)));
  456.       break;
  457.     case 2 :
  458.       SetValue(cfg.GetString(section, key, GetValue(TRUE)));
  459.   }
  460. }
  463. void PHTTPField::SaveToConfig(PConfig & cfg) const
  464. {
  465.   PString section, key;
  466.   switch (SplitConfigKey(fullName, section, key)) {
  467.     case 1 :
  468.       cfg.SetString(key, GetValue());
  469.       break;
  470.     case 2 :
  471.       cfg.SetString(section, key, GetValue());
  472.   }
  473. }
  476. BOOL PHTTPField::Validated(const PString &, PStringStream &) const
  477. {
  478.   return TRUE;
  479. }
  482. PStringList PHTTPField::GetAllNames() const
  483. {
  484.   PStringList list;
  485.   list.DisallowDeleteObjects();
  486.   list.AppendString(fullName);
  487.   return list;
  488. }
  491. void PHTTPField::SetAllValues(const PStringToString & data)
  492. {
  493.   if (!baseName && data.Contains(fullName))
  494.     SetValue(data[fullName]);
  495. }
  498. BOOL PHTTPField::ValidateAll(const PStringToString & data, PStringStream & msg) const
  499. {
  500.   if (data.Contains(fullName))
  501.     return Validated(data[fullName], msg);
  502.   return TRUE;
  503. }
  506. //////////////////////////////////////////////////////////////////////////////
  507. // PHTTPCompositeField
  509. PHTTPCompositeField::PHTTPCompositeField(const char * nam,
  510.                                          const char * titl,
  511.                                          const char * hlp)
  512.   : PHTTPField(nam, titl, hlp)
  513. {
  514. }
  517. void PHTTPCompositeField::SetName(const PString & newName)
  518. {
  519.   for (PINDEX i = 0; i < fields.GetSize(); i++) {
  520.     PHTTPField & field = fields[i];
  522.     PString firstPartOfName = psprintf(fullName, i+1);
  523.     PString subFieldName;
  524.     if (field.GetName().Find(firstPartOfName) == 0)
  525.       subFieldName = field.GetName().Mid(firstPartOfName.GetLength());
  526.     else
  527.       subFieldName = field.GetName();
  529.     firstPartOfName = psprintf(newName, i+1);
  530.     if (subFieldName[0] == '\' || firstPartOfName[firstPartOfName.GetLength()-1] == '\')
  531.       field.SetName(firstPartOfName + subFieldName);
  532.     else
  533.       field.SetName(firstPartOfName & subFieldName);
  534.   }
  536.   PHTTPField::SetName(newName);
  537. }
  540. const PHTTPField * PHTTPCompositeField::LocateName(const PString & name) const
  541. {
  542.   if (fullName == name)
  543.     return this;
  545.   for (PINDEX i = 0; i < fields.GetSize(); i++) {
  546.     const PHTTPField * field = fields[i].LocateName(name);
  547.     if (field != NULL)
  548.       return field;
  549.   }
  551.   return NULL;
  552. }
  555. PHTTPField * PHTTPCompositeField::NewField() const
  556. {
  557.   PHTTPCompositeField * fld = new PHTTPCompositeField(baseName, title, help);
  558.   for (PINDEX i = 0; i < fields.GetSize(); i++)
  559.     fld->Append(fields[i].NewField());
  560.   return fld;
  561. }
  564. void PHTTPCompositeField::GetHTMLTag(PHTML & html) const
  565. {
  566.   for (PINDEX i = 0; i < fields.GetSize(); i++) {
  567.     if (i != 0)
  568.       html << PHTML::TableData("NOWRAP");
  569.     fields[i].GetHTMLTag(html);
  570.   }
  571. }
  574. PString PHTTPCompositeField::GetHTMLInput(const PString & input) const
  575. {
  576.   return input;
  577. }
  580. void PHTTPCompositeField::ExpandFieldNames(PString & text, PINDEX start, PINDEX & finish) const
  581. {
  582.   static PRegularExpression FieldName( "!--#form[ trn]+[^-]*[ trn]+[^-]*[ trn]*)?--"
  583.                                        "|"
  584.                                        "<[a-z]*[ trn][^>]*name[ trn]*=[ trn]*"[^"]*"[^>]*>",
  585.                                        PRegularExpression::IgnoreCase);
  587.   PString name;
  588.   PINDEX pos, len;
  589.   while (start < finish && FindSpliceFieldName(text, start, pos, len, name)) {
  590.     if (pos > finish)
  591.       break;
  592.     for (PINDEX fld = 0; fld < fields.GetSize(); fld++) {
  593.       if (fields[fld].GetBaseName() == name) {
  594.         SpliceAdjust(fields[fld].GetName(), text, pos, len, finish);
  595.         break;
  596.       }
  597.     }
  598.     start = pos + len;
  599.   }
  600. }
  603. void PHTTPCompositeField::GetHTMLHeading(PHTML & html) const
  604. {
  605.   html << PHTML::TableRow();
  606.   for (PINDEX i = 0; i < fields.GetSize(); i++)
  607.     html << PHTML::TableData() << fields[i].GetTitle();
  608. }
  611. PString PHTTPCompositeField::GetValue(BOOL dflt) const
  612. {
  613.   PStringStream value;
  614.   for (PINDEX i = 0; i < fields.GetSize(); i++)
  615.     value << fields[i].GetValue(dflt) << 'n';
  616.   return value;
  617. }
  620. void PHTTPCompositeField::SetValue(const PString &)
  621. {
  622.   PAssertAlways(PLogicError);
  623. }
  626. void PHTTPCompositeField::LoadFromConfig(PConfig & cfg)
  627. {
  628.   for (PINDEX i = 0; i < GetSize(); i++)
  629.     fields[i].LoadFromConfig(cfg);
  630. }
  633. void PHTTPCompositeField::SaveToConfig(PConfig & cfg) const
  634. {
  635.   for (PINDEX i = 0; i < GetSize(); i++)
  636.     fields[i].SaveToConfig(cfg);
  637. }
  640. PStringList PHTTPCompositeField::GetAllNames() const
  641. {
  642.   PStringList list;
  643.   list.DisallowDeleteObjects();
  644.   for (PINDEX i = 0; i < GetSize(); i++) {
  645.     PStringList sublist = fields[i].GetAllNames();
  646.     for (PINDEX j = 0; j < sublist.GetSize(); j++)
  647.       list.AppendString(sublist[j]);
  648.   }
  649.   return list;
  650. }
  653. void PHTTPCompositeField::SetAllValues(const PStringToString & data)
  654. {
  655.   for (PINDEX i = 0; i < fields.GetSize(); i++)
  656.     fields[i].SetAllValues(data);
  657. }
  660. BOOL PHTTPCompositeField::ValidateAll(const PStringToString & data,
  661.                                       PStringStream & msg) const
  662. {
  663.   for (PINDEX i = 0; i < fields.GetSize(); i++)
  664.     if (!fields[i].ValidateAll(data, msg))
  665.       return FALSE;
  667.   return TRUE;
  668. }
  671. PINDEX PHTTPCompositeField::GetSize() const
  672. {
  673.   return fields.GetSize();
  674. }
  677. void PHTTPCompositeField::Append(PHTTPField * fld)
  678. {
  679.   fields.Append(fld);
  680. }
  683. //////////////////////////////////////////////////////////////////////////////
  684. // PHTTPSubForm
  686. PHTTPSubForm::PHTTPSubForm(const PString & subForm,
  687.                            const char * name,
  688.                            const char * title,
  689.                            PINDEX prim,
  690.                            PINDEX sec)
  691.   : PHTTPCompositeField(name, title, NULL),
  692.     subFormName(subForm)
  693. {
  694.   primary = prim;
  695.   secondary = sec;
  696. }
  699. PHTTPField * PHTTPSubForm::NewField() const
  700. {
  701.   PHTTPCompositeField * fld = new PHTTPSubForm(subFormName, baseName, title, primary, secondary);
  702.   for (PINDEX i = 0; i < fields.GetSize(); i++)
  703.     fld->Append(fields[i].NewField());
  704.   return fld;
  705. }
  708. void PHTTPSubForm::GetHTMLTag(PHTML & html) const
  709. {
  710.   PString value = fields[primary].GetValue();
  711.   if (value.IsEmpty())
  712.     value = "New";
  713.   html << PHTML::HotLink(subFormName +
  714.             "?subformprefix=" + PURL::TranslateString(fullName, PURL::QueryTranslation))
  715.        << value << PHTML::HotLink();
  717.   if (secondary != P_MAX_INDEX)
  718.     html << PHTML::TableData("NOWRAP") << fields[secondary].GetValue();
  719. }
  722. void PHTTPSubForm::GetHTMLHeading(PHTML &) const
  723. {
  724. }
  727. //////////////////////////////////////////////////////////////////////////////
  728. // PHTTPFieldArray
  730. PHTTPFieldArray::PHTTPFieldArray(PHTTPField * fld, BOOL ordered)
  731.   : PHTTPCompositeField(fld->GetName(), fld->GetTitle(), fld->GetHelp()),
  732.     baseField(fld)
  733. {
  734.   orderedArray = ordered;
  735.   AddBlankField();
  736. }
  739. PHTTPFieldArray::~PHTTPFieldArray()
  740. {
  741.   delete baseField;
  742. }
  745. void PHTTPFieldArray::SetSize(PINDEX newSize)
  746. {
  747.   while (fields.GetSize() > newSize)
  748.     fields.RemoveAt(fields.GetSize()-1);
  749.   while (fields.GetSize() <= newSize)
  750.     AddBlankField();
  751. }
  754. PHTTPField * PHTTPFieldArray::NewField() const
  755. {
  756.   return new PHTTPFieldArray(baseField->NewField(), orderedArray);
  757. }
  760. static const char ArrayControlBox[] = " Array Control";
  761. static const char ArrayControlKeep[] = "Keep";
  762. static const char ArrayControlRemove[] = "Remove";
  763. static const char ArrayControlMoveUp[] = "Move Up";
  764. static const char ArrayControlMoveDown[] = "Move Down";
  765. static const char ArrayControlToTop[] = "To Top";
  766. static const char ArrayControlToBottom[] = "To Bottom";
  767. static const char ArrayControlIgnore[] = "Ignore";
  768. static const char ArrayControlAddTop[] = "Add Top";
  769. static const char ArrayControlAddBottom[] = "Add Bottom";
  770. static const char ArrayControlAdd[] = "Add";
  773. static PStringList GetArrayControlOptions(PINDEX fld, PINDEX size, BOOL orderedArray)
  774. {
  775.   PStringList options;
  777.   if (fld >= size) {
  778.     options.AppendString(ArrayControlIgnore);
  779.     if (size == 0 || !orderedArray)
  780.       options.AppendString(ArrayControlAdd);
  781.     else {
  782.       options.AppendString(ArrayControlAddTop);
  783.       options.AppendString(ArrayControlAddBottom);
  784.     }
  785.   }
  786.   else {
  787.     options.AppendString(ArrayControlKeep);
  788.     options.AppendString(ArrayControlRemove);
  789.     if (orderedArray) {
  790.       if (fld > 0)
  791.         options.AppendString(ArrayControlMoveUp);
  792.       if (fld < size-1)
  793.         options.AppendString(ArrayControlMoveDown);
  794.       if (fld > 0)
  795.         options.AppendString(ArrayControlToTop);
  796.       if (fld < size-1)
  797.         options.AppendString(ArrayControlToBottom);
  798.     }
  799.   }
  801.   return options;
  802. }
  804. void PHTTPFieldArray::AddArrayControlBox(PHTML & html, PINDEX fld) const
  805. {
  806.   PStringList options = GetArrayControlOptions(fld, fields.GetSize()-1, orderedArray);
  807.   html << PHTML::Select(fields[fld].GetName() + ArrayControlBox);
  808.   for (PINDEX i = 0; i < options.GetSize(); i++)
  809.     html << PHTML::Option(i == 0 ? PHTML::Selected : PHTML::NotSelected) << options[i];
  810.   html << PHTML::Select();
  811. }
  814. void PHTTPFieldArray::GetHTMLTag(PHTML & html) const
  815. {
  816.   html << PHTML::TableStart();
  817.   baseField->GetHTMLHeading(html);
  818.   for (PINDEX i = 0; i < fields.GetSize(); i++) {
  819.     html << PHTML::TableRow() << PHTML::TableData("NOWRAP");
  820.     fields[i].GetHTMLTag(html);
  821.     html << PHTML::TableData("NOWRAP");
  822.     AddArrayControlBox(html, i);
  823.   }
  824.   html << PHTML::TableEnd();
  825. }
  828. void PHTTPFieldArray::ExpandFieldNames(PString & text, PINDEX start, PINDEX & finish) const
  829. {
  830.   PString original = text(start, finish);
  831.   PINDEX origFinish = finish;
  832.   PINDEX finalFinish = finish;
  834.   PINDEX fld = fields.GetSize();
  835.   while (fld > 0) {
  836.     fields[--fld].ExpandFieldNames(text, start, finish);
  838.     PINDEX pos,len;
  839.     static PRegularExpression RowNum("<?!--#form[ trn]+rownum[ trn]*-->?",
  840.                                      PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  841.     while (text.FindRegEx(RowNum, pos, len, start, finish))
  842.       SpliceAdjust(psprintf("%u", fld+1), text, pos, len, finish);
  844.     static PRegularExpression SubForm("<?!--#form[ trn]+subform[ trn]*-->?",
  845.                                       PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  846.     while (text.FindRegEx(SubForm, pos, len, start, finish)) {
  847.       PString fmt = fullName;
  848.       if (fmt.Find("%u") == P_MAX_INDEX)
  849.         fmt += " %u";
  850.       SpliceAdjust("subformprefix=" + PURL::TranslateString(psprintf(fmt, fld+1), PURL::QueryTranslation),
  851.                    text, pos, len, finish);
  852.     }
  854.     static PRegularExpression RowControl("<?!--#form[ trn]+rowcontrol[ trn]*-->?",
  855.                                          PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  856.     while (text.FindRegEx(RowControl, pos, len, start, finish)) {
  857.       PHTML html(PHTML::InForm);
  858.       AddArrayControlBox(html, fld);
  859.       SpliceAdjust(html, text, pos, len, finish);
  860.     }
  862.     static PRegularExpression SelectRow("<select[ trn][^>]*name[ trn]*=[ trn]*"!--#form[ trn]+rowselect[ trn]*--"[^>]*>",
  863.                                         PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  864.     static PRegularExpression SelEndRegEx("</select[^>]*>",
  865.                                           PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  866.     PINDEX begin, end;
  867.     while (FindSpliceBlock(SelectRow, SelEndRegEx, text, 0, pos, len, begin, end)) {
  868.       PStringList options = GetArrayControlOptions(fld, fields.GetSize()-1, orderedArray);
  869.       AdjustSelectOptions(text, begin, end, options[0], options, finish);
  870.       static PRegularExpression RowSelect("!--#form[ trn]+rowselect[ trn]*--",
  871.                                           PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  872.       if (text.FindRegEx(RowSelect, pos, len, pos, begin))
  873.         SpliceAdjust(fields[fld].GetName() + ArrayControlBox, text, pos, len, finish);
  874.     }
  876.     finalFinish += finish - origFinish;
  878.     if (fld > 0) {
  879.       text.Splice(original, start, 0);
  880.       finish = origFinish;
  881.       finalFinish += finish - start;
  882.     }
  883.   }
  885.   finish = finalFinish;
  886. }
  889. static int SplitArraySizeKey(const PString & fullName,
  890.                              PString & section, PString & key)
  891. {
  892.   static const char ArraySize[] = "Array Size";
  893.   PINDEX pos = fullName.Find("%u");
  894.   if (pos == P_MAX_INDEX)
  895.     return SplitConfigKey(fullName & ArraySize, section, key);
  897.   PINDEX endPos = fullName.GetLength() - 1;
  898.   if (fullName[endPos] == '\')
  899.     endPos--;
  900.   return SplitConfigKey(fullName.Left(pos) & ArraySize & fullName(pos+2, endPos), section, key);
  901. }
  904. void PHTTPFieldArray::LoadFromConfig(PConfig & cfg)
  905. {
  906.   PString section, key;
  907.   switch (SplitArraySizeKey(fullName, section, key)) {
  908.     case 1 :
  909.       SetSize(cfg.GetInteger(key, GetSize()));
  910.       break;
  911.     case 2 :
  912.       SetSize(cfg.GetInteger(section, key, GetSize()));
  913.   }
  915.   PHTTPCompositeField::LoadFromConfig(cfg);
  916. }
  919. void PHTTPFieldArray::SaveToConfig(PConfig & cfg) const
  920. {
  921.   PString section, key;
  922.   switch (SplitArraySizeKey(fullName, section, key)) {
  923.     case 1 :
  924.       cfg.SetInteger(key, GetSize());
  925.       break;
  926.     case 2 :
  927.       cfg.SetInteger(section, key, GetSize());
  928.   }
  930.   PHTTPCompositeField::SaveToConfig(cfg);
  931. }
  934. void PHTTPFieldArray::SetArrayFieldName(PINDEX idx) const
  935. {
  936.   PString fmt = fullName;
  937.   if (fmt.Find("%u") == P_MAX_INDEX)
  938.     fmt += " %u";
  939.   fields[idx].SetName(psprintf(fmt, idx+1));
  940. }
  943. void PHTTPFieldArray::SetAllValues(const PStringToString & data)
  944. {
  945.   PHTTPFieldList newFields;
  946.   newFields.DisallowDeleteObjects();
  947.   PINDEX i;
  948.   for (i = 0; i < fields.GetSize(); i++)
  949.     newFields.Append(fields.GetAt(i));
  951.   BOOL lastFieldIsSet = FALSE;
  952.   PINDEX size = fields.GetSize();
  953.   for (i = 0; i < size; i++) {
  954.     PHTTPField * fieldPtr = &fields[i];
  955.     PINDEX pos = newFields.GetObjectsIndex(fieldPtr);
  956.     fieldPtr->SetAllValues(data);
  958.     PString control = data(fieldPtr->GetName() + ArrayControlBox);
  959.     if (control == ArrayControlMoveUp) {
  960.       if (pos > 0) {
  961.         newFields.SetAt(pos, newFields.GetAt(pos-1));
  962.         newFields.SetAt(pos-1, fieldPtr);
  963.       }
  964.     }
  965.     else if (control == ArrayControlMoveDown) {
  966.       if (size > 2 && pos < size-2) {
  967.         newFields.SetAt(pos, newFields.GetAt(pos+1));
  968.         newFields.SetAt(pos+1, fieldPtr);
  969.       }
  970.     }
  971.     else if (control == ArrayControlToTop) {
  972.       newFields.RemoveAt(pos);
  973.       newFields.InsertAt(0, fieldPtr);
  974.     }
  975.     else if (control == ArrayControlToBottom) {
  976.       newFields.RemoveAt(pos);
  977.       newFields.Append(fieldPtr);
  978.     }
  979.     else if (control == ArrayControlAddTop) {
  980.       if (i == size-1) {
  981.         newFields.RemoveAt(pos);
  982.         newFields.InsertAt(0, fieldPtr);
  983.         lastFieldIsSet = TRUE;
  984.       }
  985.     }
  986.     else if (control == ArrayControlAddBottom || control == ArrayControlAdd) {
  987.       if (i == size-1) {
  988.         newFields.RemoveAt(pos);
  989.         newFields.Append(fieldPtr);
  990.         lastFieldIsSet = TRUE;
  991.       }
  992.     }
  993.     else if (control == ArrayControlIgnore) {
  994.       newFields.RemoveAt(pos);
  995.       newFields.Append(fieldPtr);
  996.     }
  997.     else if (control == ArrayControlRemove)
  998.       newFields.RemoveAt(pos);
  999.   }
  1001.   fields.DisallowDeleteObjects();
  1002.   for (i = 0; i < newFields.GetSize(); i++)
  1003.     fields.Remove(newFields.GetAt(i));
  1004.   fields.AllowDeleteObjects();
  1005.   fields.RemoveAll();
  1007.   for (i = 0; i < newFields.GetSize(); i++) {
  1008.     fields.Append(newFields.GetAt(i));
  1009.     SetArrayFieldName(i);
  1010.   }
  1012.   if (lastFieldIsSet)
  1013.     AddBlankField();
  1014. }
  1017. PINDEX PHTTPFieldArray::GetSize() const
  1018. {
  1019.   PAssert(fields.GetSize() > 0, PLogicError);
  1020.   return fields.GetSize()-1;
  1021. }
  1024. void PHTTPFieldArray::AddBlankField()
  1025. {
  1026.   fields.Append(baseField->NewField());
  1027.   SetArrayFieldName(fields.GetSize()-1);
  1028. }
  1031. //////////////////////////////////////////////////////////////////////////////
  1032. // PHTTPStringField
  1034. PHTTPStringField::PHTTPStringField(const char * name,
  1035.                                    PINDEX siz,
  1036.                                    const char * initVal,
  1037.                                    const char * help)
  1038.   : PHTTPField(name, NULL, help),
  1039.     value(initVal != NULL ? initVal : ""),
  1040.     initialValue(value)
  1041. {
  1042.   size = siz;
  1043. }
  1046. PHTTPStringField::PHTTPStringField(const char * name,
  1047.                                    const char * title,
  1048.                                    PINDEX siz,
  1049.                                    const char * initVal,
  1050.                                    const char * help)
  1051.   : PHTTPField(name, title, help),
  1052.     value(initVal != NULL ? initVal : ""),
  1053.     initialValue(value)
  1054. {
  1055.   size = siz;
  1056. }
  1059. PHTTPField * PHTTPStringField::NewField() const
  1060. {
  1061.   return new PHTTPStringField(baseName, title, size, initialValue, help);
  1062. }
  1065. void PHTTPStringField::GetHTMLTag(PHTML & html) const
  1066. {
  1067.   html << PHTML::InputText(fullName, size, value);
  1068. }
  1071. void PHTTPStringField::SetValue(const PString & newVal)
  1072. {
  1073.   value = newVal;
  1074. }
  1077. PString PHTTPStringField::GetValue(BOOL dflt) const
  1078. {
  1079.   if (dflt)
  1080.     return initialValue;
  1081.   else
  1082.     return value;
  1083. }
  1086. //////////////////////////////////////////////////////////////////////////////
  1087. // PHTTPPasswordField
  1089. PHTTPPasswordField::PHTTPPasswordField(const char * name,
  1090.                                        PINDEX siz,
  1091.                                        const char * initVal,
  1092.                                        const char * help)
  1093.   : PHTTPStringField(name, siz, initVal, help)
  1094. {
  1095. }
  1098. PHTTPPasswordField::PHTTPPasswordField(const char * name,
  1099.                                        const char * title,
  1100.                                        PINDEX siz,
  1101.                                        const char * initVal,
  1102.                                        const char * help)
  1103.   : PHTTPStringField(name, title, siz, initVal, help)
  1104. {
  1105. }
  1108. PHTTPField * PHTTPPasswordField::NewField() const
  1109. {
  1110.   return new PHTTPPasswordField(baseName, title, size, initialValue, help);
  1111. }
  1114. void PHTTPPasswordField::GetHTMLTag(PHTML & html) const
  1115. {
  1116.   html << PHTML::InputPassword(fullName, size, value);
  1117. }
  1120. static const PTEACypher::Key PasswordKey = {
  1121.   {
  1122.     103,  60, 222,  17, 128, 157,  31, 137,
  1123.     133,  64,  82, 148,  94, 136,   4, 209
  1124.   }
  1125. };
  1127. void PHTTPPasswordField::SetValue(const PString & newVal)
  1128. {
  1129.   value = Decrypt(newVal);
  1130. }
  1133. PString PHTTPPasswordField::GetValue(BOOL dflt) const
  1134. {
  1135.   if (dflt)
  1136.     return initialValue;
  1138.   PTEACypher crypt(PasswordKey);
  1139.   return crypt.Encode(value);
  1140. }
  1143. PString PHTTPPasswordField::Decrypt(const PString & pword)
  1144. {
  1145.   PString clear;
  1146.   PTEACypher crypt(PasswordKey);
  1147.   return crypt.Decode(pword, clear) ? clear : pword;
  1148. }
  1151. //////////////////////////////////////////////////////////////////////////////
  1152. // PHTTPIntegerField
  1154. PHTTPIntegerField::PHTTPIntegerField(const char * nam,
  1155.                                      int lo, int hig,
  1156.                                      int initVal,
  1157.                                      const char * unit,
  1158.                                      const char * help)
  1159.   : PHTTPField(nam, NULL, help), units(unit != NULL ? unit : "")
  1160. {
  1161.   low = lo;
  1162.   high = hig;
  1163.   value = initialValue = initVal;
  1164. }
  1166. PHTTPIntegerField::PHTTPIntegerField(const char * nam,
  1167.                                      const char * titl,
  1168.                                      int lo, int hig,
  1169.                                      int initVal,
  1170.                                      const char * unit,
  1171.                                      const char * help)
  1172.   : PHTTPField(nam, titl, help), units(unit != NULL ? unit : "")
  1173. {
  1174.   low = lo;
  1175.   high = hig;
  1176.   value = initialValue = initVal;
  1177. }
  1180. PHTTPField * PHTTPIntegerField::NewField() const
  1181. {
  1182.   return new PHTTPIntegerField(baseName, title, low, high, initialValue, units, help);
  1183. }
  1186. void PHTTPIntegerField::GetHTMLTag(PHTML & html) const
  1187. {
  1188.   html << PHTML::InputRange(fullName, low, high, value) << "  " << units;
  1189. }
  1192. void PHTTPIntegerField::SetValue(const PString & newVal)
  1193. {
  1194.   value = newVal.AsInteger();
  1195. }
  1198. PString PHTTPIntegerField::GetValue(BOOL dflt) const
  1199. {
  1200.   return PString(PString::Signed, dflt ? initialValue : value);
  1201. }
  1204. void PHTTPIntegerField::LoadFromConfig(PConfig & cfg)
  1205. {
  1206.   PString section, key;
  1207.   switch (SplitConfigKey(fullName, section, key)) {
  1208.     case 1 :
  1209.       value = cfg.GetInteger(key, initialValue);
  1210.       break;
  1211.     case 2 :
  1212.       value = cfg.GetInteger(section, key, initialValue);
  1213.   }
  1214. }
  1217. void PHTTPIntegerField::SaveToConfig(PConfig & cfg) const
  1218. {
  1219.   PString section, key;
  1220.   switch (SplitConfigKey(fullName, section, key)) {
  1221.     case 1 :
  1222.       cfg.SetInteger(key, value);
  1223.       break;
  1224.     case 2 :
  1225.       cfg.SetInteger(section, key, value);
  1226.   }
  1227. }
  1230. BOOL PHTTPIntegerField::Validated(const PString & newVal, PStringStream & msg) const
  1231. {
  1232.   int val = newVal.AsInteger();
  1233.   if (val >= low && val <= high)
  1234.     return TRUE;
  1236.   msg << "The field "" << GetName() << "" should be between "
  1237.       << low << " and " << high << ".<BR>";
  1238.   return FALSE;
  1239. }
  1242. //////////////////////////////////////////////////////////////////////////////
  1243. // PHTTPBooleanField
  1245. PHTTPBooleanField::PHTTPBooleanField(const char * name,
  1246.                                      BOOL initVal,
  1247.                                    const char * help)
  1248.   : PHTTPField(name, NULL, help)
  1249. {
  1250.   value = initialValue = initVal;
  1251. }
  1254. PHTTPBooleanField::PHTTPBooleanField(const char * name,
  1255.                                      const char * title,
  1256.                                      BOOL initVal,
  1257.                                      const char * help)
  1258.   : PHTTPField(name, title, help)
  1259. {
  1260.   value = initialValue = initVal;
  1261. }
  1264. PHTTPField * PHTTPBooleanField::NewField() const
  1265. {
  1266.   return new PHTTPBooleanField(baseName, title, initialValue, help);
  1267. }
  1270. void PHTTPBooleanField::GetHTMLTag(PHTML & html) const
  1271. {
  1272.   html << PHTML::HiddenField(fullName, "FALSE")
  1273.        << PHTML::CheckBox(fullName, value ? PHTML::Checked : PHTML::UnChecked);
  1274. }
  1277. static void SpliceChecked(PString & text, BOOL value)
  1278. {
  1279.   PINDEX pos = text.Find("checked");
  1280.   if (value) {
  1281.     if (pos == P_MAX_INDEX)
  1282.       text.Splice(" checked", 6, 0);
  1283.   }
  1284.   else {
  1285.     if (pos != P_MAX_INDEX) {
  1286.       PINDEX len = 7;
  1287.       if (text[pos-1] == ' ') {
  1288.         pos--;
  1289.         len++;
  1290.       }
  1291.       text.Delete(pos, len);
  1292.     }
  1293.   }
  1294. }
  1297. PString PHTTPBooleanField::GetHTMLInput(const PString & input) const
  1298. {
  1299.   static PRegularExpression checkboxRegEx("type[ trn]*=[ trn]*"?checkbox"?",
  1300.                                           PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  1301.   if (input.FindRegEx(checkboxRegEx) != P_MAX_INDEX) {
  1302.     PCaselessString text;
  1303.     PINDEX before, after;
  1304.     if (FindInputValue(input, before, after)) 
  1305.       text = input(0, before) + "TRUE" + input.Mid(after);
  1306.     else
  1307.       text = "<input value="TRUE"" + input.Mid(6);
  1308.     SpliceChecked(text, value);
  1309.     return "<input type=hidden name="" + fullName + "">" + text;
  1310.   }
  1312.   static PRegularExpression radioRegEx("type[ trn]*=[ trn]*"?radio"?",
  1313.                                        PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  1314.   if (input.FindRegEx(radioRegEx) != P_MAX_INDEX) {
  1315.     PINDEX before, after;
  1316.     if (FindInputValue(input, before, after)) {
  1317.       PCaselessString text = input;
  1318.       PString val = input(before+1, after-1);
  1319.       SpliceChecked(text, (value && (val *= "TRUE")) || (!value && (val *= "FALSE")));
  1320.       return text;
  1321.     }
  1322.     return input;
  1323.   }
  1325.   return PHTTPField::GetHTMLInput(input);
  1326. }
  1329. void PHTTPBooleanField::SetValue(const PString & val)
  1330. {
  1331.   value = toupper(val[0]) == 'T' || toupper(val[0]) == 'y' ||
  1332.           val.AsInteger() != 0 || val.Find("TRUE") != P_MAX_INDEX;
  1333. }
  1336. PString PHTTPBooleanField::GetValue(BOOL dflt) const
  1337. {
  1338.   return ((dflt ? initialValue : value) ? "True" : "False");
  1339. }
  1342. void PHTTPBooleanField::LoadFromConfig(PConfig & cfg)
  1343. {
  1344.   PString section, key;
  1345.   switch (SplitConfigKey(fullName, section, key)) {
  1346.     case 1 :
  1347.       value = cfg.GetBoolean(key, initialValue);
  1348.       break;
  1349.     case 2 :
  1350.       value = cfg.GetBoolean(section, key, initialValue);
  1351.   }
  1352. }
  1355. void PHTTPBooleanField::SaveToConfig(PConfig & cfg) const
  1356. {
  1357.   PString section, key;
  1358.   switch (SplitConfigKey(fullName, section, key)) {
  1359.     case 1 :
  1360.       cfg.SetBoolean(key, value);
  1361.       break;
  1362.     case 2 :
  1363.       cfg.SetBoolean(section, key, value);
  1364.   }
  1365. }
  1368. //////////////////////////////////////////////////////////////////////////////
  1369. // PHTTPRadioField
  1371. PHTTPRadioField::PHTTPRadioField(const char * name,
  1372.                                  const PStringArray & valueArray,
  1373.                                  PINDEX initVal,
  1374.                                  const char * help)
  1375.   : PHTTPField(name, NULL, help),
  1376.     values(valueArray),
  1377.     titles(valueArray),
  1378.     value(valueArray[initVal]),
  1379.     initialValue(value)
  1380. {
  1381. }
  1384. PHTTPRadioField::PHTTPRadioField(const char * name,
  1385.                                  const PStringArray & valueArray,
  1386.                                  const PStringArray & titleArray,
  1387.                                  PINDEX initVal,
  1388.                                  const char * help)
  1389.   : PHTTPField(name, NULL, help),
  1390.     values(valueArray),
  1391.     titles(titleArray),
  1392.     value(valueArray[initVal]),
  1393.     initialValue(value)
  1394. {
  1395. }
  1398. PHTTPRadioField::PHTTPRadioField(const char * name,
  1399.                                  PINDEX count,
  1400.                                  const char * const * valueStrings,
  1401.                                  PINDEX initVal,
  1402.                                  const char * help)
  1403.   : PHTTPField(name, NULL, help),
  1404.     values(count, valueStrings),
  1405.     titles(count, valueStrings),
  1406.     value(valueStrings[initVal]),
  1407.     initialValue(value)
  1408. {
  1409. }
  1412. PHTTPRadioField::PHTTPRadioField(const char * name,
  1413.                                  PINDEX count,
  1414.                                  const char * const * valueStrings,
  1415.                                  const char * const * titleStrings,
  1416.                                  PINDEX initVal,
  1417.                                  const char * help)
  1418.   : PHTTPField(name, NULL, help),
  1419.     values(count, valueStrings),
  1420.     titles(count, titleStrings),
  1421.     value(valueStrings[initVal]),
  1422.     initialValue(value)
  1423. {
  1424. }
  1427. PHTTPRadioField::PHTTPRadioField(const char * name,
  1428.                                  const char * groupTitle,
  1429.                                  const PStringArray & valueArray,
  1430.                                  PINDEX initVal,
  1431.                                  const char * help)
  1432.   : PHTTPField(name, groupTitle, help),
  1433.     values(valueArray),
  1434.     titles(valueArray),
  1435.     value(valueArray[initVal]),
  1436.     initialValue(value)
  1437. {
  1438. }
  1441. PHTTPRadioField::PHTTPRadioField(const char * name,
  1442.                                  const char * groupTitle,
  1443.                                  const PStringArray & valueArray,
  1444.                                  const PStringArray & titleArray,
  1445.                                  PINDEX initVal,
  1446.                                  const char * help)
  1447.   : PHTTPField(name, groupTitle, help),
  1448.     values(valueArray),
  1449.     titles(titleArray),
  1450.     value(valueArray[initVal]),
  1451.     initialValue(value)
  1452. {
  1453. }
  1456. PHTTPRadioField::PHTTPRadioField(const char * name,
  1457.                                  const char * groupTitle,
  1458.                                  PINDEX count,
  1459.                                  const char * const * valueStrings,
  1460.                                  PINDEX initVal,
  1461.                                  const char * help)
  1462.   : PHTTPField(name, groupTitle, help),
  1463.     values(count, valueStrings),
  1464.     titles(count, valueStrings),
  1465.     value(valueStrings[initVal]),
  1466.     initialValue(value)
  1467. {
  1468. }
  1471. PHTTPRadioField::PHTTPRadioField(const char * name,
  1472.                                  const char * groupTitle,
  1473.                                  PINDEX count,
  1474.                                  const char * const * valueStrings,
  1475.                                  const char * const * titleStrings,
  1476.                                  PINDEX initVal,
  1477.                                  const char * help)
  1478.   : PHTTPField(name, groupTitle, help),
  1479.     values(count, valueStrings),
  1480.     titles(count, titleStrings),
  1481.     value(valueStrings[initVal]),
  1482.     initialValue(value)
  1483. {
  1484. }
  1487. PHTTPField * PHTTPRadioField::NewField() const
  1488. {
  1489.   return new PHTTPRadioField(*this);
  1490. }
  1493. void PHTTPRadioField::GetHTMLTag(PHTML & html) const
  1494. {
  1495.   for (PINDEX i = 0; i < values.GetSize(); i++)
  1496.     html << PHTML::RadioButton(fullName, values[i],
  1497.                         values[i] == value ? PHTML::Checked : PHTML::UnChecked)
  1498.          << titles[i]
  1499.          << PHTML::BreakLine();
  1500. }
  1503. PString PHTTPRadioField::GetHTMLInput(const PString & input) const
  1504. {
  1505.   PString inval;
  1506.   PINDEX before, after;
  1507.   if (FindInputValue(input, before, after))
  1508.     inval = input(before+1, after-1);
  1509.   else
  1510.     inval = baseName;
  1512.   if (inval != value)
  1513.     return input;
  1515.   return "<input checked" + input.Mid(6);
  1516. }
  1519. PString PHTTPRadioField::GetValue(BOOL dflt) const
  1520. {
  1521.   if (dflt)
  1522.     return initialValue;
  1523.   else
  1524.     return value;
  1525. }
  1528. void PHTTPRadioField::SetValue(const PString & newVal)
  1529. {
  1530.   value = newVal;
  1531. }
  1534. //////////////////////////////////////////////////////////////////////////////
  1535. // PHTTPSelectField
  1537. PHTTPSelectField::PHTTPSelectField(const char * name,
  1538.                                    const PStringArray & valueArray,
  1539.                                    PINDEX initVal,
  1540.                                    const char * help)
  1541.   : PHTTPField(name, NULL, help),
  1542.     values(valueArray)
  1543. {
  1544.   initialValue = initVal;
  1545.   if (initVal < values.GetSize())
  1546.     value = values[initVal];
  1547. }
  1550. PHTTPSelectField::PHTTPSelectField(const char * name,
  1551.                                    PINDEX count,
  1552.                                    const char * const * valueStrings,
  1553.                                    PINDEX initVal,
  1554.                                    const char * help)
  1555.   : PHTTPField(name, NULL, help),
  1556.     values(count, valueStrings)
  1557. {
  1558.   initialValue = initVal;
  1559.   if (initVal < count)
  1560.     value = values[initVal];
  1561. }
  1564. PHTTPSelectField::PHTTPSelectField(const char * name,
  1565.                                    const char * title,
  1566.                                    const PStringArray & valueArray,
  1567.                                    PINDEX initVal,
  1568.                                    const char * help)
  1569.   : PHTTPField(name, title, help),
  1570.     values(valueArray)
  1571. {
  1572.   initialValue = initVal;
  1573.   if (initVal < values.GetSize())
  1574.     value = values[initVal];
  1575. }
  1578. PHTTPSelectField::PHTTPSelectField(const char * name,
  1579.                                    const char * title,
  1580.                                    PINDEX count,
  1581.                                    const char * const * valueStrings,
  1582.                                    PINDEX initVal,
  1583.                                    const char * help)
  1584.   : PHTTPField(name, title, help),
  1585.     values(count, valueStrings)
  1586. {
  1587.   initialValue = initVal;
  1588.   if (initVal < values.GetSize())
  1589.     value = values[initVal];
  1590. }
  1593. PHTTPField * PHTTPSelectField::NewField() const
  1594. {
  1595.   return new PHTTPSelectField(baseName, title, values, initialValue, help);
  1596. }
  1599. void PHTTPSelectField::GetHTMLTag(PHTML & html) const
  1600. {
  1601.   html << PHTML::Select(fullName);
  1602.   for (PINDEX i = 0; i < values.GetSize(); i++)
  1603.     html << PHTML::Option(values[i] == value ? PHTML::Selected : PHTML::NotSelected)
  1604.          << values[i];
  1605.   html << PHTML::Select();
  1606. }
  1609. PString PHTTPSelectField::GetValue(BOOL dflt) const
  1610. {
  1611.   if (dflt)
  1612.     if (initialValue < values.GetSize())
  1613.       return values[initialValue];
  1614.     else
  1615.       return PString();
  1616.   else
  1617.     return value;
  1618. }
  1621. void PHTTPSelectField::SetValue(const PString & newVal)
  1622. {
  1623.   value = newVal;
  1624. }
  1628. //////////////////////////////////////////////////////////////////////////////
  1629. // PHTTPForm
  1631. PHTTPForm::PHTTPForm(const PURL & url)
  1632.   : PHTTPString(url),
  1633.     fields("")
  1634. {
  1635. }
  1637. PHTTPForm::PHTTPForm(const PURL & url, const PHTTPAuthority & auth)
  1638.   : PHTTPString(url, auth),
  1639.     fields("")
  1640. {
  1641. }
  1643. PHTTPForm::PHTTPForm(const PURL & url, const PString & html)
  1644.   : PHTTPString(url, html),
  1645.     fields("")
  1646. {
  1647. }
  1649. PHTTPForm::PHTTPForm(const PURL & url,
  1650.                      const PString & html,
  1651.                      const PHTTPAuthority & auth)
  1652.   : PHTTPString(url, html, auth),
  1653.     fields("")
  1654. {
  1655. }
  1658. static BOOL FindSpliceAccepted(const PString & text,
  1659.                               PINDEX offset,
  1660.                               PINDEX & pos,
  1661.                               PINDEX & len,
  1662.                               PINDEX & start,
  1663.                               PINDEX & finish)
  1664. {
  1665.   static PRegularExpression Accepted("<?!--#form[ trn]+accepted[ trn]*-->?",
  1666.                                      PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  1667.   return FindSpliceBlock(Accepted, text, offset, pos, len, start, finish);
  1668. }
  1671. static BOOL FindSpliceErrors(const PString & text,
  1672.                             PINDEX offset,
  1673.                             PINDEX & pos,
  1674.                             PINDEX & len,
  1675.                             PINDEX & start,
  1676.                             PINDEX & finish)
  1677. {
  1678.   static PRegularExpression Errors("<?!--#form[ trn]+errors[ trn]*-->?",
  1679.                                      PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  1680.   return FindSpliceBlock(Errors, text, offset, pos, len, start, finish);
  1681. }
  1684. static BOOL FindSpliceField(const PRegularExpression & startExpr,
  1685.                             const PRegularExpression & endExpr,
  1686.                             const PString & text,
  1687.                             PINDEX offset,
  1688.                             const PHTTPField & rootField,
  1689.                             PINDEX & pos,
  1690.                             PINDEX & len,
  1691.                             PINDEX & start,
  1692.                             PINDEX & finish,
  1693.                             const PHTTPField * & field)
  1694. {
  1695.   field = NULL;
  1697.   if (!FindSpliceBlock(startExpr, endExpr, text, offset, pos, len, start, finish))
  1698.     return FALSE;
  1700.   PINDEX endBlock = start != finish ? (start-1) : (pos+len-1);
  1701.   PINDEX namePos, nameEnd;
  1702.   if (FindSpliceName(text, pos, endBlock, namePos, nameEnd))
  1703.     field = rootField.LocateName(text(namePos, nameEnd));
  1704.   return TRUE;
  1705. }
  1708. void PHTTPForm::OnLoadedText(PHTTPRequest & request, PString & text)
  1709. {
  1710.   PINDEX pos, len, start, finish;
  1711.   const PHTTPField * field;
  1713.   // Remove the subsections for POST command
  1714.   pos = 0;
  1715.   while (FindSpliceAccepted(text, pos, pos, len, start, finish))
  1716.     text.Delete(pos, len);
  1718.   pos = 0;
  1719.   while (FindSpliceErrors(text, pos, pos, len, start, finish))
  1720.     text.Delete(pos, len);
  1722.   // See if are a subform, set root composite field accordingly
  1723.   PString prefix = request.url.GetQueryVars()("subformprefix");
  1724.   if (!prefix) {
  1725.     static PRegularExpression SubFormPrefix("<?!--#form[ trn]+subformprefix[ trn]*-->?",
  1726.                                             PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  1727.     while (text.FindRegEx(SubFormPrefix, pos, len))
  1728.       text.Splice("subformprefix=" +
  1729.                   PURL::TranslateString(prefix, PURL::QueryTranslation),
  1730.                   pos, len);
  1731.     field = fields.LocateName(prefix);
  1732.     if (field != NULL) {
  1733.       finish = P_MAX_INDEX;
  1734.       field->ExpandFieldNames(text, 0, finish);
  1735.     }
  1736.   }
  1738.   // Locate <!--#form array name--> macros and expand them
  1739.   static PRegularExpression ArrayRegEx("<!--#form[ trn]+array[ trn]+[^-]+-->",
  1740.                                        PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  1741.   static PRegularExpression EndBlock("<?!--#form[ trn]+end[ trn]+[^-]+-->?",
  1742.                                      PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  1743.   pos = len = 0;
  1744.   while (FindSpliceField(ArrayRegEx, EndBlock, text, pos+len, fields, pos, len, start, finish, field)) {
  1745.     if (start != finish && field != NULL)
  1746.       field->ExpandFieldNames(text, start, finish);
  1747.   }
  1749.   // Have now expanded all field names to be fully qualified
  1751.   static PRegularExpression HTMLRegEx("<!--#form[ trn]+html[ trn]+[^-]+-->",
  1752.                                       PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  1753.   while (FindSpliceField(HTMLRegEx, "", text, 0, fields, pos, len, start, finish, field)) {
  1754.     if (field != NULL) {
  1755.       PHTML html(PHTML::InForm);
  1756.       field->GetHTMLTag(html);
  1757.       text.Splice(html, pos, len);
  1758.     }
  1759.   }
  1761.   pos = len = 0;
  1762.   static PRegularExpression ValueRegEx("<!--#form[ trn]+value[ trn]+[^-]+-->",
  1763.                                        PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  1764.   while (FindSpliceField(ValueRegEx, "", text, pos+len, fields, pos, len, start, finish, field)) {
  1765.     if (field != NULL)
  1766.       text.Splice(field->GetValue(), pos, len);
  1767.   }
  1769.   pos = len = 0;
  1770.   static PRegularExpression InputRegEx("<input[ trn][^>]*name[ trn]*=[ trn]*"[^"]*"[^>]*>",
  1771.                                        PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  1772.   while (FindSpliceField(InputRegEx, "", text, pos+len, fields, pos, len, start, finish, field)) {
  1773.     if (field != NULL) {
  1774.       static PRegularExpression HiddenRegEx("type[ trn]*=[ trn]*"?hidden"?",
  1775.                                             PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  1776.       PString substr = text.Mid(pos, len);
  1777.       if (substr.FindRegEx(HiddenRegEx) == P_MAX_INDEX)
  1778.         text.Splice(field->GetHTMLInput(substr), pos, len);
  1779.     }
  1780.   }
  1782.   pos = len = 0;
  1783.   static PRegularExpression SelectRegEx("<select[ trn][^>]*name[ trn]*=[ trn]*"[^"]*"[^>]*>",
  1784.                                         PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  1785.   static PRegularExpression SelEndRegEx("</select[^>]*>",
  1786.                                         PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  1787.   while (FindSpliceField(SelectRegEx, SelEndRegEx, text, pos+len, fields, pos, len, start, finish, field)) {
  1788.     if (field != NULL)
  1789.       text.Splice(field->GetHTMLSelect(text(start, finish)), start, finish-start+1);
  1790.   }
  1792.   pos = len = 0;
  1793.   static PRegularExpression TextRegEx("<textarea[ trn][^>]*name[ trn]*=[ trn]*"[^"]*"[^>]*>",
  1794.                                       PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  1795.   static PRegularExpression TextEndRegEx("</textarea[^>]*>", PRegularExpression::IgnoreCase);
  1796.   while (FindSpliceField(TextRegEx, TextEndRegEx, text, pos+len, fields, pos, len, start, finish, field)) {
  1797.     if (field != NULL)
  1798.       text.Splice(field->GetValue(), start, finish-start+1);
  1799.   }
  1800. }
  1803. PHTTPField * PHTTPForm::Add(PHTTPField * fld)
  1804. {
  1805.   PAssertNULL(fld);
  1806.   PAssert(!fieldNames[fld->GetName()], "Field already on form!");
  1807.   fieldNames += fld->GetName();
  1808.   fields.Append(fld);
  1809.   return fld;
  1810. }
  1813. void PHTTPForm::BuildHTML(const char * heading)
  1814. {
  1815.   PHTML html(heading);
  1816.   BuildHTML(html);
  1817. }
  1820. void PHTTPForm::BuildHTML(const PString & heading)
  1821. {
  1822.   PHTML html(heading);
  1823.   BuildHTML(html);
  1824. }
  1827. void PHTTPForm::BuildHTML(PHTML & html, BuildOptions option)
  1828. {
  1829.   if (!html.Is(PHTML::InForm))
  1830.     html << PHTML::Form("POST");
  1832.   html << PHTML::TableStart();
  1833.   for (PINDEX fld = 0; fld < fields.GetSize(); fld++) {
  1834.     PHTTPField & field = fields[fld];
  1835.     if (field.NotYetInHTML()) {
  1836.       html << PHTML::TableRow()
  1837.            << PHTML::TableData("align=right")
  1838.            << field.GetTitle()
  1839.            << PHTML::TableData("align=left")
  1840.            << "<!--#form html " << field.GetName() << "-->"
  1841.            << PHTML::TableData()
  1842.            << field.GetHelp();
  1843.       field.SetInHTML();
  1844.     }
  1845.   }
  1846.   html << PHTML::TableEnd();
  1847.   if (option != InsertIntoForm)
  1848.     html << PHTML::Paragraph()
  1849.          << ' ' << PHTML::SubmitButton("Accept")
  1850.          << ' ' << PHTML::ResetButton("Reset")
  1851.          << PHTML::Form();
  1853.   if (option == CompleteHTML) {
  1854.     html << PHTML::Body();
  1855.     string = html;
  1856.   }
  1857. }
  1860. BOOL PHTTPForm::Post(PHTTPRequest & request,
  1861.                      const PStringToString & data,
  1862.                      PHTML & msg)
  1863. {
  1864.   PString prefix = request.url.GetQueryVars()("subformprefix");
  1865.   const PHTTPField * field = NULL;
  1866.   if (!prefix)
  1867.     field = fields.LocateName(prefix);
  1868.   if (field == NULL)
  1869.     field = &fields;
  1871.   PStringStream errors;
  1872.   if (field->ValidateAll(data, errors)) {
  1873.     ((PHTTPField *)field)->SetAllValues(data);
  1875.     if (msg.IsEmpty())
  1876.       msg = "Accepted New Configuration";
  1877.     else {
  1878.       PString block;
  1879.       PINDEX pos = 0;
  1880.       PINDEX len, start, finish;
  1881.       while (FindSpliceAccepted(msg, pos, pos, len, start, finish))
  1882.         msg.Splice(msg(start, finish), pos, len);
  1883.       pos = 0;
  1884.       while (FindSpliceErrors(msg, pos, pos, len, start, finish))
  1885.         msg.Delete(pos, len);
  1886.     }
  1887.   }
  1888.   else {
  1889.     request.code = PHTTP::BadRequest;
  1891.     if (msg.IsEmpty()) {
  1892.       msg = "Validation Error in Request";
  1893.       msg << errors;
  1894.     }
  1895.     else {
  1896.       PINDEX pos = 0;
  1897.       PINDEX len, start, finish;
  1898.       while (FindSpliceAccepted(msg, pos, pos, len, start, finish))
  1899.         msg.Delete(pos, len);
  1901.       BOOL appendErrors = TRUE;
  1902.       pos = 0;
  1903.       while (FindSpliceErrors(msg, pos, pos, len, start, finish)) {
  1904.         PString block = msg(start, finish);
  1905.         PINDEX vPos, vLen;
  1906.         static PRegularExpression Validation("<?!--#form[ trn]+validation[ trn]*-->?",
  1907.                                              PRegularExpression::Extended|PRegularExpression::IgnoreCase);
  1908.         if (block.FindRegEx(Validation, vPos, vLen))
  1909.           block.Splice(errors, vPos, vLen);
  1910.         else
  1911.           block += errors;
  1912.         msg.Splice(block, pos, len);
  1913.         appendErrors = FALSE;
  1914.       }
  1916.       if (appendErrors)
  1917.         msg << errors;
  1918.     }
  1919.   }
  1921.   return TRUE;
  1922. }
  1925. //////////////////////////////////////////////////////////////////////////////
  1926. // PHTTPConfig
  1928. PHTTPConfig::PHTTPConfig(const PURL & url,
  1929.                          const PString & sect)
  1930.   : PHTTPForm(url), section(sect)
  1931. {
  1932.   Construct();
  1933. }
  1936. PHTTPConfig::PHTTPConfig(const PURL & url,
  1937.                          const PString & sect,
  1938.                          const PHTTPAuthority & auth)
  1939.   : PHTTPForm(url, auth), section(sect)
  1940. {
  1941.   Construct();
  1942. }
  1945. PHTTPConfig::PHTTPConfig(const PURL & url,
  1946.                          const PString & html,
  1947.                          const PString & sect)
  1948.   : PHTTPForm(url, html), section(sect)
  1949. {
  1950.   Construct();
  1951. }
  1954. PHTTPConfig::PHTTPConfig(const PURL & url,
  1955.                          const PString & html,
  1956.                          const PString & sect,
  1957.                          const PHTTPAuthority & auth)
  1958.   : PHTTPForm(url, html, auth), section(sect)
  1959. {
  1960.   Construct();
  1961. }
  1964. void PHTTPConfig::Construct()
  1965. {
  1966.   sectionField = NULL;
  1967.   keyField = NULL;
  1968.   valField = NULL;
  1969. }
  1972. void PHTTPConfig::LoadFromConfig()
  1973. {
  1974.   PConfig cfg(section);
  1975.   fields.LoadFromConfig(cfg);
  1976. }
  1979. void PHTTPConfig::OnLoadedText(PHTTPRequest & request, PString & text)
  1980. {
  1981.   if (sectionField == NULL) {
  1982.     PString sectionName = request.url.GetQueryVars()("section", section);
  1983.     if (!sectionName) {
  1984.       section = sectionName;
  1985.       LoadFromConfig();
  1986.     }
  1987.   }
  1989.   PHTTPForm::OnLoadedText(request, text);
  1990. }
  1993. BOOL PHTTPConfig::Post(PHTTPRequest & request,
  1994.                        const PStringToString & data,
  1995.                        PHTML & msg)
  1996. {
  1997.   // Make sure the internal structure is up to date before accepting new data
  1998.   if (!section)
  1999.     LoadFromConfig();
  2002.   PSortedStringList oldValues;
  2004.   // Remember fields that are here now, so can delete removed array fields
  2005.   PINDEX fld;
  2006.   for (fld = 0; fld < fields.GetSize(); fld++) {
  2007.     PHTTPField & field = fields[fld];
  2008.     if (&field != keyField && &field != valField && &field != sectionField) {
  2009.       PStringList names = field.GetAllNames();
  2010.       for (PINDEX i = 0; i < names.GetSize(); i++)
  2011.         oldValues.AppendString(names[i]);
  2012.     }
  2013.   }
  2015.   PHTTPForm::Post(request, data, msg);
  2016.   if (request.code != PHTTP::OK)
  2017.     return TRUE;
  2019.   if (sectionField != NULL)
  2020.     section = sectionPrefix + sectionField->GetValue() + sectionSuffix;
  2022.   PString sectionName = request.url.GetQueryVars()("section", section);
  2023.   if (sectionName.IsEmpty())
  2024.     return TRUE;
  2026.   PConfig cfg(sectionName);
  2028.   for (fld = 0; fld < fields.GetSize(); fld++) {
  2029.     PHTTPField & field = fields[fld];
  2030.     if (&field == keyField) {
  2031.       PString key = field.GetValue();
  2032.       if (!key)
  2033.         cfg.SetString(key, valField->GetValue());
  2034.     }
  2035.     else if (&field != valField && &field != sectionField)
  2036.       field.SaveToConfig(cfg);
  2037.   }
  2039.   // Find out which fields have been removed (arrays elements deleted)
  2040.   for (fld = 0; fld < fields.GetSize(); fld++) {
  2041.     PHTTPField & field = fields[fld];
  2042.     if (&field != keyField && &field != valField && &field != sectionField) {
  2043.       PStringList names = field.GetAllNames();
  2044.       for (PINDEX i = 0; i < names.GetSize(); i++) {
  2045.         PINDEX idx = oldValues.GetStringsIndex(names[i]);
  2046.         if (idx != P_MAX_INDEX)
  2047.           oldValues.RemoveAt(idx);
  2048.       }
  2049.     }
  2050.   }
  2052.   for (fld = 0; fld < oldValues.GetSize(); fld++) {
  2053.     PString section, key;
  2054.     switch (SplitConfigKey(oldValues[fld], section, key)) {
  2055.       case 1 :
  2056.         cfg.DeleteKey(key);
  2057.         break;
  2058.       case 2 :
  2059.         cfg.DeleteKey(section, key);
  2060.         if (cfg.GetKeys(section).IsEmpty())
  2061.           cfg.DeleteSection(section);
  2062.     }
  2063.   }
  2065.   section = sectionName;
  2066.   return TRUE;
  2067. }
  2070. PHTTPField * PHTTPConfig::AddSectionField(PHTTPField * sectionFld,
  2071.                                           const char * prefix,
  2072.                                           const char * suffix)
  2073. {
  2074.   sectionField = PAssertNULL(sectionFld);
  2075.   PAssert(!sectionField->IsDescendant(PHTTPCompositeField::Class()), "Section field is composite");
  2076.   Add(sectionField);
  2078.   if (prefix != NULL)
  2079.     sectionPrefix = prefix;
  2080.   if (suffix != NULL)
  2081.     sectionSuffix = suffix;
  2083.   return sectionField;
  2084. }
  2087. void PHTTPConfig::AddNewKeyFields(PHTTPField * keyFld,
  2088.                                   PHTTPField * valFld)
  2089. {
  2090.   keyField = PAssertNULL(keyFld);
  2091.   Add(keyFld);
  2092.   valField = PAssertNULL(valFld);
  2093.   Add(valFld);
  2094. }
  2097. //////////////////////////////////////////////////////////////////////////////
  2098. // PHTTPConfigSectionList
  2100. static const char FormListInclude[] = "<!--#form pagelist-->";
  2102. PHTTPConfigSectionList::PHTTPConfigSectionList(const PURL & url,
  2103.                                                const PHTTPAuthority & auth,
  2104.                                                const PString & prefix,
  2105.                                                const PString & valueName,
  2106.                                                const PURL & editSection,
  2107.                                                const PURL & newSection,
  2108.                                                const PString & newTitle,
  2109.                                                PHTML & heading)
  2110.   : PHTTPString(url, auth),
  2111.     sectionPrefix(prefix),
  2112.     additionalValueName(valueName),
  2113.     newSectionLink(newSection.AsString(PURL::URIOnly)),
  2114.     newSectionTitle(newTitle),
  2115.     editSectionLink(editSection.AsString(PURL::URIOnly) +
  2116.                       "?section=" + PURL::TranslateString(prefix, PURL::QueryTranslation))
  2117. {
  2118.   if (heading.Is(PHTML::InBody))
  2119.     heading << FormListInclude << PHTML::Body();
  2120.   SetString(heading);
  2121. }
  2124. void PHTTPConfigSectionList::OnLoadedText(PHTTPRequest &, PString & text)
  2125. {
  2126.   PConfig cfg;
  2127.   PStringList nameList = cfg.GetSections();
  2129.   PINDEX pos = text.Find(FormListInclude);
  2130.   if (pos != P_MAX_INDEX) {
  2131.     PINDEX endpos = text.Find(FormListInclude, pos + sizeof(FormListInclude)-1);
  2132.     if (endpos == P_MAX_INDEX) {
  2133.       PHTML html(PHTML::InBody);
  2134.       html << PHTML::Form("POST") << PHTML::TableStart();
  2136.       PINDEX i;
  2137.       for (i = 0; i < nameList.GetSize(); i++) {
  2138.         if (nameList[i].Find(sectionPrefix) == 0) {
  2139.           PString name = nameList[i].Mid(sectionPrefix.GetLength());
  2140.           html << PHTML::TableRow()
  2141.                << PHTML::TableData()
  2142.                << PHTML::HotLink(editSectionLink + PURL::TranslateString(name, PURL::QueryTranslation))
  2143.                << name
  2144.                << PHTML::HotLink();
  2145.           if (!additionalValueName)
  2146.             html << PHTML::TableData()
  2147.                  << PHTML::HotLink(editSectionLink + PURL::TranslateString(name, PURL::QueryTranslation))
  2148.                  << cfg.GetString(nameList[i], additionalValueName, "")
  2149.                  << PHTML::HotLink();
  2150.           html << PHTML::TableData() << PHTML::SubmitButton("Remove", name);
  2151.         }
  2152.       }
  2154.       html << PHTML::TableRow()
  2155.            << PHTML::TableData()
  2156.            << PHTML::HotLink(newSectionLink)
  2157.            << newSectionTitle
  2158.            << PHTML::HotLink()
  2159.            << PHTML::TableEnd()
  2160.            << PHTML::Form();
  2162.       text.Splice(html, pos, sizeof(FormListInclude)-1);
  2163.     }
  2164.     else {
  2165.       PString repeat = text(pos + sizeof(FormListInclude)-1, endpos-1);
  2166.       text.Delete(pos, endpos - pos);
  2168.       PINDEX i;
  2169.       for (i = 0; i < nameList.GetSize(); i++) {
  2170.         if (nameList[i].Find(sectionPrefix) == 0) {
  2171.           PString name = nameList[i].Mid(sectionPrefix.GetLength());
  2172.           text.Splice(repeat, pos, 0);
  2173.           text.Replace("<!--#form hotlink-->",
  2174.                        editSectionLink + PURL::TranslateString(name, PURL::QueryTranslation),
  2175.                        TRUE, pos);
  2176.           if (!additionalValueName)
  2177.             text.Replace("<!--#form additional-->",
  2178.                          cfg.GetString(nameList[i], additionalValueName, ""),
  2179.                          TRUE, pos);
  2180.           text.Replace("<!--#form section-->", name, TRUE, pos);
  2181.           pos = text.Find(FormListInclude, pos);
  2182.         }
  2183.       }
  2184.       text.Delete(text.Find(FormListInclude, pos), sizeof(FormListInclude)-1);
  2185.     }
  2186.   }
  2187. }
  2190. BOOL PHTTPConfigSectionList::Post(PHTTPRequest &,
  2191.                                   const PStringToString & data,
  2192.                                   PHTML & replyMessage)
  2193. {
  2194.   PConfig cfg;
  2195.   PStringList nameList = cfg.GetSections();
  2196.   PINDEX i; 
  2197.   for (i = 0; i < nameList.GetSize(); i++) {
  2198.     if (nameList[i].Find(sectionPrefix) == 0) {
  2199.       PString name = nameList[i].Mid(sectionPrefix.GetLength());
  2200.       if (data.Contains(name)) {
  2201.         cfg.DeleteSection(nameList[i]);
  2202.         replyMessage << name << " removed.";
  2203.       }
  2204.     }
  2205.   }
  2207.   return TRUE;
  2208. }
  2212. // End Of File ///////////////////////////////////////////////////////////////