PageRenderTime 54ms CodeModel.GetById 16ms RepoModel.GetById 1ms app.codeStats 0ms

/mem_form/mem_form.php

https://bitbucket.org/Manfre/txp-plugins
PHP | 1825 lines | 1495 code | 295 blank | 35 comment | 195 complexity | e9f889d0dc8ae9e60355313614287058 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

    

  1. <?php

    2. 

  2. 

    3. 

  3. // This is a PLUGIN TEMPLATE.

    4. 

  4. 

    5. 

  5. // Copy this file to a new name like abc_myplugin.php.  Edit the code, then

    6. 

  6. // run this file at the command line to produce a plugin for distribution:

    7. 

  7. // $ php abc_myplugin.php > abc_myplugin-0.1.txt

    8. 

  8. 

    9. 

  9. // Plugin name is optional.  If unset, it will be extracted from the current

    10. 

  10. // file name. Uncomment and edit this line to override:

    11. 

  11. # $plugin['name'] = 'abc_plugin';

    12. 

  12. 

    13. 

  13. // 0 = Plugin help is in Textile format, no raw HTML allowed (default).

    14. 

  14. // 1 = Plugin help is in raw HTML.  Not recommended.

    15. 

  15. # $plugin['allow_html_help'] = 1;

    16. 

  16. // $Rev$ $LastChangedDate$

    17. 

  17. $plugin['version'] = '0.8.5';

    18. 

  18. $plugin['author'] = 'Michael Manfre';

    19. 

  19. $plugin['author_uri'] = 'http://manfre.net/';

    20. 

  20. $plugin['description'] = 'A library plugin that provides support for html forms.';

    21. 

  21. 

    22. 

  22. // Plugin types:

    23. 

  23. // 0 = regular plugin; loaded on the public web side only

    24. 

  24. // 1 = admin plugin; loaded on both the public and admin side

    25. 

  25. // 2 = library; loaded only when include_plugin() or require_plugin() is called

    26. 

  26. $plugin['type'] = 2; 

    27. 

  27. 

    28. 

  28. if (!defined('txpinterface'))

    29. 

  29. 	@include_once('../zem_tpl.php');

    30. 

  30. 

    31. 

  31. if (0) {

    32. 

  32. ?>

    33. 

  33. # --- BEGIN PLUGIN HELP ---

    34. 

  34. 

    35. 

  35. h1(title). mem_form plugin

    36. 

  36. 

    37. 

  37. h2(section summary). Summary

    38. 

  38. 

    39. 

  39. p. This plugin provides HTML form capabilities for other plugins. This allows for consistent form tags and behaviors, while reducing overall plugin size and development time.

    40. 

  40. 

    41. 

  41. h2(section contact). Author Contact

    42. 

  42. 

    43. 

  43. "Michael Manfre":mailto:mmanfre@gmail.com?subject=Textpattern%20mem_form%20plugin

    44. 

  44. "http://manfre.net":http://manfre.net

    45. 

  45. 

    46. 

  46. h2(section license). License

    47. 

  47. 

    48. 

  48. p. This plugin is licensed under the "GPLv2":http://www.fsf.org/licensing/licenses/info/GPLv2.html.

    49. 

  49. 

    50. 

  50. h2(section tags). Tags

    51. 

  51. 

    52. 

  52. * "mem_form":#mem_form

    53. 

  53. * "mem_form_checkbox":#mem_form_checkbox

    54. 

  54. * "mem_form_email":#mem_form_email

    55. 

  55. * "mem_form_file":#mem_form_file

    56. 

  56. * "mem_form_hidden":#mem_form_hidden

    57. 

  57. * "mem_form_radio":#mem_form_radio

    58. 

  58. * "mem_form_secret":#mem_form_secret

    59. 

  59. * "mem_form_select":#mem_form_select

    60. 

  60. * "mem_form_select_category":#mem_form_select_category

    61. 

  61. * "mem_form_select_range":#mem_form_select_range

    62. 

  62. * "mem_form_select_section":#mem_form_select_section

    63. 

  63. * "mem_form_serverinfo":#mem_form_serverinfo

    64. 

  64. * "mem_form_submit":#mem_form_submit

    65. 

  65. * "mem_form_text":#mem_form_text

    66. 

  66. * "mem_form_textarea":#mem_form_textarea

    67. 

  67. * "mem_form_value":#mem_form_value

    68. 

  68. 

    69. 

  69. 

    70. 

  70. h3(tag#mem_form). mem_form

    71. 

  71. 

    72. 

  72. p(tag-summary). This tag will create an HTML form and contains all of the processing and validation.

    73. 

  73. 

    74. 

  74. *(atts) %(atts-name)form% %(atts-type)string% Name of a form that will be parsed to display the form.

    75. 

  75. * %(atts-name)thanks_form% %(atts-type)string% Name of a form that will be parsed upon successful form submission.

    76. 

  76. * %(atts-name)label% %(atts-type)string% Accessible name for the form.

    77. 

  77. * %(atts-name required)type% %(atts-type)string% Name of the form to identify itself to bound plugin.

    78. 

  78. * %(atts-name)thanks% %(atts-type)string% Message to display to user upon successful form submission.

    79. 

  79. * %(atts-name)redirect% %(atts-type)url% URL to redirect upon successful form submission. Overrides "thanks" and "thanks_form".

    80. 

  80. * %(atts-name)redirect_form% %(atts-type)string% Name of a form that will be parsed as displayed to the user on a redirect. The string "_{uri}_" will be replaced with the redirect url.

    81. 

  81. * %(atts-name)enctype% %(atts-type)string% HTML encoding type used when the form is submitted. @enctype="multipart/form-data"@ is required when using mem_form_file.

    82. 

  82. * %(atts-name)default_break% %(atts-type)string% Separator between label tag and input tag to be used as the default for every mem_form compatible field contained in the form. Default is <br>

    83. 

  83. 

    84. 

  84. 

    85. 

  85. h3(tag#mem_form_checkbox). mem_form_checkbox

    86. 

  86. 

    87. 

  87. p(tag-summary). This will output an HTML checkbox field.

    88. 

  88. 

    89. 

  89. *(atts) %(atts-name)break% %(atts-type)string% Separator between label tag and input tag.

    90. 

  90. * %(atts-name)checked% %(atts-type)int% Is this box checked. Default "0".

    91. 

  91. * %(atts-name)label% %(atts-type)string% Friendly name for the input field. If set, this will output an HTML ==<label>== tag linked to the input field.

    92. 

  92. * %(atts-name)name% %(atts-type)string% Input field name.

    93. 

  93. * %(atts-name)required% %(atts-type)int% Specifies if input is required.

    94. 

  94. * %(atts-name)class% %(atts-type)string% CSS class name.

    95. 

  95. 

    96. 

  96. h3(tag#mem_form_email). mem_form_email

    97. 

  97. 

    98. 

  98. p(tag-summary). This will output an HTML text input field and validates the submitted value as an email address.

    99. 

  99. 

    100. 

  100. *(atts) %(atts-name)break% %(atts-type)string% Separator between label tag and input tag.

    101. 

  101. * %(atts-name)label% %(atts-type)string% Friendly name for the input field. If set, this will output an HTML ==<label>== tag linked to the input field.

    102. 

  102. * %(atts-name)name% %(atts-type)string% Input field name.

    103. 

  103. * %(atts-name)required% %(atts-type)int% Specifies if input is required.

    104. 

  104. * %(atts-name)class% %(atts-type)string% CSS class name.

    105. 

  105. * %(atts-name)default% %(atts-type)string% The default value.

    106. 

  106. * %(atts-name)max% %(atts-type)int% Max character length.

    107. 

  107. * %(atts-name)min% %(atts-type)int% Min character length.

    108. 

  108. * %(atts-name)size% %(atts-type)int% Size of input field.

    109. 

  109. 

    110. 

  110. h3(tag#mem_form_file). mem_form_file

    111. 

  111. 

    112. 

  112. +p(tag-summary). This will output an HTML file input field. You must add the @enctype="multipart/form-data"@ attribute to your enclosing mem_form for this to work.

    113. 

  113. 

    114. 

  114. *(atts) %(atts-name)label% %(atts-type)string% Friendly name for the input field. If set, this will output an HTML ==<label>== tag linked to the input field.

    115. 

  115. * %(atts-name)name% %(atts-type)string% Input field name.

    116. 

  116. * %(atts-name)class% %(atts-type)string% CSS class name.

    117. 

  117. * %(atts-name)break% %(atts-type)string% Separator between label tag and input tag.

    118. 

  118. * %(atts-name)no_replace% %(atts-type)int% Specifies whether a user can upload another file and replace the existing file that will be submitted on successful completion of the form. If "1", the file input field will be replaced with details about the already uploaded file.

    119. 

  119. * %(atts-name)required% %(atts-type)int% Specifies if input is required.

    120. 

  120. * %(atts-name)size% %(atts-type)int% Size of input field.

    121. 

  121. * %(atts-name)max_file_size% %(atts-type)int% Maximum size for the uploaded file. Checked server-side.

    122. 

  122. * %(atts-name)accept% %(atts-type)string% The HTML file input field's "accept" argument that specifies which file types the field should permit.

    123. 

  123. 

    124. 

  124. h3(tag#mem_form_hidden). mem_form_hidden

    125. 

  125. 

    126. 

  126. p(tag-summary). This will output an HTML hidden text input field.

    127. 

  127. 

    128. 

  128. *(atts) %(atts-name)label% %(atts-type)string% Friendly name for the input field. If set, this will output an HTML ==<label>== tag linked to the input field.

    129. 

  129. * %(atts-name)name% %(atts-type)string% Input field name.

    130. 

  130. * %(atts-name)value% %(atts-type)string% The input value.

    131. 

  131. * %(atts-name)required% %(atts-type)int% Specifies if input is required.

    132. 

  132. * %(atts-name)class% %(atts-type)string% CSS class name.

    133. 

  133. * %(atts-name)escape_value% %(atts-type)int% Set to "0" to prevent html escaping the value. Default "1".

    134. 

  134. 

    135. 

  135. 

    136. 

  136. h3(tag#mem_form_radio). mem_form_radio

    137. 

  137. 

    138. 

  138. p(tag-summary). This will output an HTML radio button.

    139. 

  139. 

    140. 

  140. *(atts) %(atts-name)break% %(atts-type)string% Separator between label tag and input tag.

    141. 

  141. * %(atts-name)label% %(atts-type)string% Friendly name for the input field. If set, this will output an HTML ==<label>== tag linked to the input field.

    142. 

  142. * %(atts-name)name% %(atts-type)string% Input field name.

    143. 

  143. * %(atts-name)class% %(atts-type)string% CSS class name.

    144. 

  144. * %(atts-name)group% %(atts-type)string% A name that identifies a group of radio buttons.

    145. 

  145. * %(atts-name)value% %(atts-type)string% The value of the radio button. If not set, a unique value is generated.

    146. 

  146. * %(atts-name)checked% %(atts-type)int% Is this box checked. Default "0".

    147. 

  147. 

    148. 

  148. h3(tag#mem_form_secret). mem_form_secret

    149. 

  149. 

    150. 

  150. p(tag-summary). This will output nothing in HTML and is meant to pass information to the sumbit handler plugins.

    151. 

  151. 

    152. 

  152. *(atts) %(atts-name)label% %(atts-type)string% Friendly name for the input field. If set, this will output an HTML ==<label>== tag linked to the input field.

    153. 

  153. * %(atts-name)name% %(atts-type)string% Input field name.

    154. 

  154. * %(atts-name)value% %(atts-type)string% The input value.

    155. 

  155. 

    156. 

  156. h3(tag#mem_form_select). mem_form_select

    157. 

  157. 

    158. 

  158. p(tag-summary). This will output an HTML select field.

    159. 

  159. 

    160. 

  160. *(atts) %(atts-name)label% %(atts-type)string% Friendly name for the input field. If set, this will output an HTML ==<label>== tag linked to the input field.

    161. 

  161. * %(atts-name)name% %(atts-type)string% Input field name.

    162. 

  162. * %(atts-name)break% %(atts-type)string% Separator between label tag and input tag.

    163. 

  163. * %(atts-name)delimiter% %(atts-type)string% List separator. Default ","

    164. 

  164. * %(atts-name)items% %(atts-type)string% Delimited list containing a select list display values.

    165. 

  165. * %(atts-name)values% %(atts-type)string% Delimited list containing a select list item values.

    166. 

  166. * %(atts-name)required% %(atts-type)int% Specifies if input is required.

    167. 

  167. * %(atts-name)selected% %(atts-type)string% The value of the selected item.

    168. 

  168. * %(atts-name)first% %(atts-type)string% Display value of the first item in the list. E.g. "Select a Section" or "" for a blank option.

    169. 

  169. * %(atts-name)class% %(atts-type)string% CSS class name.

    170. 

  170. * %(atts-name)select_limit% %(atts-type)int% Specifies the maximum number of items that may be selected. If set to a value greater than 1, a multiselect will be used. The stored value will be an array.

    171. 

  171. * %(atts-name)as_csv% %(atts-type)int% If set to 1, the value will be stored as a delimited string of values instead of an array. This does nothing when select_limit is less than 2.

    172. 

  172. 

    173. 

  173. 

    174. 

  174. h3(tag#mem_form_category). mem_form_select_category

    175. 

  175. 

    176. 

  176. p(tag-summary). This will output an HTML select field populated with the specified Textpattern categories.

    177. 

  177. 

    178. 

  178. *(atts) %(atts-name)label% %(atts-type)string% Friendly name for the input field. If set, this will output an HTML ==<label>== tag linked to the input field.

    179. 

  179. * %(atts-name)name% %(atts-type)string% Input field name.

    180. 

  180. * %(atts-name)break% %(atts-type)string% Separator between label tag and input tag.

    181. 

  181. * %(atts-name)delimiter% %(atts-type)string% List separator. Default ","

    182. 

  182. * %(atts-name)items% %(atts-type)string% Delimited list containing a select list display values.

    183. 

  183. * %(atts-name)values% %(atts-type)string% Delimited list containing a select list item values.

    184. 

  184. * %(atts-name)required% %(atts-type)int% Specifies if input is required.

    185. 

  185. * %(atts-name)selected% %(atts-type)string% The value of the selected item.

    186. 

  186. * %(atts-name)first% %(atts-type)string% Display value of the first item in the list. E.g. "Select a Section" or "" for a blank option.

    187. 

  187. * %(atts-name)class% %(atts-type)string% CSS class name.

    188. 

  188. * %(atts-name)exclude% %(atts-type)string% List of item values that will not be included.

    189. 

  189. * %(atts-name)sort% %(atts-type)string%  How will the list values be sorted.

    190. 

  190. * %(atts-name)type% %(atts-type)string% Category type name. E.g. "article"

    191. 

  191. 

    192. 

  192. h3(tag#mem_form_select_range) . mem_form_select_range

    193. 

  193. 

    194. 

  194. p(tag-summary). This will output an HTML select field populated with a range of numbers.

    195. 

  195. 

    196. 

  196. *(atts) %(atts-name)start% %(atts-type)int% The initial number to include. Default is 0.

    197. 

  197. * %(atts-name)stop% %(atts-type)int% The largest/smallest number to include.

    198. 

  198. * %(atts-name)step% %(atts-type)int% The increment between numbers in the range. Default is 1.

    199. 

  199. * %(atts-name)label% %(atts-type)string% Friendly name for the input field. If set, this will output an HTML ==<label>== tag linked to the input field.

    200. 

  200. * %(atts-name)name% %(atts-type)string% Input field name.

    201. 

  201. * %(atts-name)break% %(atts-type)string% Separator between label tag and input tag.

    202. 

  202. * %(atts-name)delimiter% %(atts-type)string% List separator. Default ","

    203. 

  203. * %(atts-name)items% %(atts-type)string% Delimited list containing a select list display values.

    204. 

  204. * %(atts-name)values% %(atts-type)string% Delimited list containing a select list item values.

    205. 

  205. * %(atts-name)required% %(atts-type)int% Specifies if input is required.

    206. 

  206. * %(atts-name)selected% %(atts-type)string% The value of the selected item.

    207. 

  207. * %(atts-name)first% %(atts-type)string% Display value of the first item in the list. E.g. "Select a Section" or "" for a blank option.

    208. 

  208. * %(atts-name)class% %(atts-type)string% CSS class name.

    209. 

  209. * %(atts-name)exclude% %(atts-type)string% List of item values that will not be included.

    210. 

  210. * %(atts-name)sort% %(atts-type)string%  How will the list values be sorted.

    211. 

  211. * %(atts-name)type% %(atts-type)string% Category type name. E.g. "article"

    212. 

  212. 

    213. 

  213. 

    214. 

  214. h3(tag#mem_form_section). mem_form_select_section

    215. 

  215. 

    216. 

  216. p(tag-summary). This will output an HTML select field populated with the specified Textpattern sections.

    217. 

  217. 

    218. 

  218. *(atts) %(atts-name)label% %(atts-type)string% Friendly name for the input field. If set, this will output an HTML ==<label>== tag linked to the input field.

    219. 

  219. * %(atts-name)name% %(atts-type)string% Input field name.

    220. 

  220. * %(atts-name)break% %(atts-type)string% Separator between label tag and input tag.

    221. 

  221. * %(atts-name)delimiter% %(atts-type)string% List separator. Default ","

    222. 

  222. * %(atts-name)items% %(atts-type)string% Delimited list containing a select list display values.

    223. 

  223. * %(atts-name)values% %(atts-type)string% Delimited list containing a select list item values.

    224. 

  224. * %(atts-name)required% %(atts-type)int% Specifies if input is required.

    225. 

  225. * %(atts-name)selected% %(atts-type)string% The value of the selected item.

    226. 

  226. * %(atts-name)first% %(atts-type)string% Display value of the first item in the list. E.g. "Select a Section" or "" for a blank option.

    227. 

  227. * %(atts-name)class% %(atts-type)string% CSS class name.

    228. 

  228. * %(atts-name)exclude% %(atts-type)string% List of item values that will not be included.

    229. 

  229. * %(atts-name)sort% %(atts-type)string%  How will the list values be sorted.

    230. 

  230. 

    231. 

  231. h3(tag#mem_form_serverinfo). mem_form_serverinfo

    232. 

  232. 

    233. 

  233. p(tag-summary). This will output no HTML and is used to pass server information to the plugin handling the form submission.

    234. 

  234. 

    235. 

  235. *(atts) %(atts-name)label% %(atts-type)string% Friendly name for the input field. If set, this will output an HTML ==<label>== tag linked to the input field.

    236. 

  236. * %(atts-name)name% %(atts-type)string% Input field name.

    237. 

  237. 

    238. 

  238. h3(tag#mem_form_submit). mem_form_submit

    239. 

  239. 

    240. 

  240. p(tag-summary). This will output either an HTML submit input field or an HTML button.

    241. 

  241. 

    242. 

  242. *(atts) %(atts-name)label% %(atts-type)string% Friendly name for the input field. If set, this will output an HTML ==<label>== tag linked to the input field.

    243. 

  243. * %(atts-name)name% %(atts-type)string% Input field name.

    244. 

  244. * %(atts-name)class% %(atts-type)string% CSS class name.

    245. 

  245. * %(atts-name)button% %(atts-type)int% If "1", an html button tag will be used instead of an input tag. 

    246. 

  246. 

    247. 

  247. h3(tag#mem_form_text). mem_form_text

    248. 

  248. 

    249. 

  249. p(tag-summary). This will output an HTML text input field.

    250. 

  250. 

    251. 

  251. *(atts) %(atts-name)label% %(atts-type)string% Friendly name for the input field. If set, this will output an HTML ==<label>== tag linked to the input field.

    252. 

  252. * %(atts-name)name% %(atts-type)string% Input field name.

    253. 

  253. * %(atts-name)class% %(atts-type)string% CSS class name.

    254. 

  254. * %(atts-name)break% %(atts-type)string% Separator between label tag and input tag.

    255. 

  255. * %(atts-name)default% %(atts-type)string% The default value.

    256. 

  256. * %(atts-name)format% %(atts-type)string% A regex pattern that will be matched against the input value. You must escape all backslashes '\'. E.g "/\\d/" is a single digit.

    257. 

  257. * %(atts-name)example% %(atts-type)string% An example of a correctly formatted input value.

    258. 

  258. * %(atts-name)password% %(atts-type)int% Specifies if the input field is a password field.

    259. 

  259. * %(atts-name)required% %(atts-type)int% Specifies if input is required.

    260. 

  260. * %(atts-name)max% %(atts-type)int% Max character length.

    261. 

  261. * %(atts-name)min% %(atts-type)int% Min character length.

    262. 

  262. * %(atts-name)size% %(atts-type)int% Size of input field.

    263. 

  263. * %(atts-name)escape_value% %(atts-type)int% Set to "0" to prevent html escaping the value. Default "1".

    264. 

  264. 

    265. 

  265. h3(tag#mem_form_textarea). mem_form_textarea

    266. 

  266. 

    267. 

  267. p(tag-summary). This will output an HTML textarea.

    268. 

  268. 

    269. 

  269. *(atts) %(atts-name)label% %(atts-type)string% Friendly name for the input field. If set, this will output an HTML ==<label>== tag linked to the input field.

    270. 

  270. * %(atts-name)name% %(atts-type)string% Input field name.

    271. 

  271. * %(atts-name)class% %(atts-type)string% CSS class name.

    272. 

  272. * %(atts-name)break% %(atts-type)string% Separator between label tag and input tag.

    273. 

  273. * %(atts-name)default% %(atts-type)string% The default value.

    274. 

  274. * %(atts-name)max% %(atts-type)int% Max character length.

    275. 

  275. * %(atts-name)min% %(atts-type)int% Min character length.

    276. 

  276. * %(atts-name)required% %(atts-type)int% Specifies if input is required.

    277. 

  277. * %(atts-name)rows% %(atts-type)int% Number of rows in the textarea.

    278. 

  278. * %(atts-name)cols% %(atts-type)int% Number of columns in the textarea.

    279. 

  279. * %(atts-name)escape_value% %(atts-type)int% Set to "0" to prevent html escaping the value. Default "1".

    280. 

  280. 

    281. 

  281. h3(tag#mem_form_value). mem_form_value

    282. 

  282. 

    283. 

  283. p(tag-summary). This will output the value associated with a form field. Useful to mix HTML input fields with mem_form.

    284. 

  284. 

    285. 

  285. *(atts) %(atts-name)id% %(atts-type)string% ID for output wrap tag.

    286. 

  286. * %(atts-name)class% %(atts-type)string% CSS class name.

    287. 

  287. * %(atts-name)class% %(atts-type)string% CSS class.

    288. 

  288. * %(atts-name)wraptag% %(atts-type)string% HTML tag to wrap around the value.

    289. 

  289. * %(atts-name)attributes% %(atts-type)string% Additional HTML tag attributes that should be passed to the output tag.

    290. 

  290. 

    291. 

  291. h2(section). Exposed Functions

    292. 

  292. 

    293. 

  293. h3(tag). mem_form_mail

    294. 

  294. 

    295. 

  295. p(tag-summary). This will send an email message.

    296. 

  296. 

    297. 

  297. *(atts) %(atts-name)Return Value% %(atts-type)bool% Returns true or false, indicating whether the email was successfully given to the mail system. This does not indicate the validity of the email address or that the recipient actually received the email.

    298. 

  298. * %(atts-name)from% %(atts-type)string% The From email address.

    299. 

  299. * %(atts-name)reply% %(atts-type)string% The Reply To email address.

    300. 

  300. * %(atts-name)to% %(atts-type)string% The To email address(es).

    301. 

  301. * %(atts-name)subject% %(atts-type)string% The email's Subject.

    302. 

  302. * %(atts-name)msg% %(atts-type)string% The email message.

    303. 

  303. 

    304. 

  304. 

    305. 

  305. h3(tag). mem_form_error

    306. 

  306. 

    307. 

  307. p(tag-summary). This will set or get errors associated with the form.

    308. 

  308. 

    309. 

  309. *(atts) %(atts-name)Return Value% %(atts-type)mixed% If err is NULL, then it will return an array of errors that have been set.

    310. 

  310. * %(atts-name optional)err% %(atts-type)string% An error that will be added to the list of form errors that will be displayed to the form user.

    311. 

  311. 

    312. 

  312. h3(tag). mem_form_default

    313. 

  313. 

    314. 

  314. p(tag-summary). This will get or set a default value for a form.

    315. 

  315. 

    316. 

  316. *(atts) %(atts-name)Return Value% %(atts-type)mixed% If %(atts-name)val is NULL, then it will return the default value set for the input field matching %(atts-name)key%. If %(atts-name)key% does not exist, then it will return FALSE.

    317. 

  317. * %(atts-name)key% %(atts-type%)string% The name of the input field.

    318. 

  318. * %(atts-name optional)val% %(atts-type)string% If specified, this will be specified as the default value for the input field named "key".

    319. 

  319. 

    320. 

  320. h3(tag). mem_form_store

    321. 

  321. 

    322. 

  322. p(tag-summary). This will store the name, label and value for a field in to the appropriate global variables.

    323. 

  323. 

    324. 

  324. *(atts) %(atts-name)name% %(atts-type)string% The name of the field.

    325. 

  325. * %(atts-name)label% %(atts-type%)string% The label of the field.

    326. 

  326. * %(atts-name)value% %(atts-type)mixed% The value of the field.

    327. 

  327. 

    328. 

  328. h3(tag). mem_form_remove

    329. 

  329. 

    330. 

  330. p(tag-summary). This will remove the information associated with a field that has been stored.

    331. 

  331. 

    332. 

  332. *(atts) %(atts-name)name% %(atts-type)string% The name of the field.

    333. 

  333. 

    334. 

  334. h2(section). Global Variables

    335. 

  335. 

    336. 

  336. p. This library allows other plugins to hook in to events with the @register_callback@ function.

    337. 

  337. 

    338. 

  338. *(atts) %(atts-name)$mem_form_type% %(atts-type)string% A text value that allows a plugin determine if it should process the current form.

    339. 

  339. * %(atts-name)$mem_form_submit% %(atts-type)bool% This specifies if the form is doing a postback.

    340. 

  340. * %(atts-name)$mem_form_default% %(atts-type)array% An array containing the default values to use when displaying the form.

    341. 

  341. * %(atts-name)$mem_form% %(atts-type)array% An array mapping all input labels to their values.

    342. 

  342. * %(atts-name)$mem_form_labels% %(atts-type)array% An array mapping all input names to their labels.

    343. 

  343. * %(atts-name)$mem_form_values% %(atts-type)array% An array mapping all input names to their values.

    344. 

  344. * %(atts-name)$mem_form_thanks_form% %(atts-type)string% Contains the message that will be shown to the user after a successful submission. Either the "thanks_form" or the "thanks" attribute. A plugin can modify this value or return a string to over

    345. 

  345. 

    346. 

  346. h2(section). Plugin Events

    347. 

  347. 

    348. 

  348. h3(event). mem_form.defaults

    349. 

  349. 

    350. 

  350. p(event-summary). Allows a plugin to alter the default values for a form prior to being displayed.

    351. 

  351. 

    352. 

  352. h3(event). mem_form.display

    353. 

  353. 

    354. 

  354. p(event-summary). Allows a plugin to insert additional html in the rendered html form tag.

    355. 

  355. 

    356. 

  356. h3(event). mem_form.submit

    357. 

  357. 

    358. 

  358. p(event-summary). Allows a plugin to act upon a successful form submission.

    359. 

  359. 

    360. 

  360. h3(event). mem_form.spam

    361. 

  361. 

    362. 

  362. p(event-summary). Allows a plugin to test a submission as spam. The function get_mem_form_evaluator() returns the evaluator.

    363. 

  363. 

    364. 

  364. h3(event). mem_form.store_value

    365. 

  365. 

    366. 

  366. p(event-summary). On submit, this event is called for each field that passed the builtin checks and was just stored in to the global variables. The callback step is the field name. This callback can be used for custom field validation. If the value is invalid, return FALSE. Warning: This event is called for each field even if a previously checked field has failed.

    367. 

  367. 

    368. 

  368. h3(event). mem_form.validate

    369. 

  369. 

    370. 

  370. p(event-summary). This event is called on form submit, after the individual fields are parsed and validated. This event is not called if there are any errors after the fields are validated. Any multi-field or form specific validation should happen here. Use mem_form_error() to set any validation error messages to prevent a successful post.

    371. 

  371. 

    372. 

  372. # --- END PLUGIN HELP ---

    373. 

  373. <?php

    374. 

  374. }

    375. 

  375. 

    376. 

  376. # --- BEGIN PLUGIN CODE ---

    377. 

  377. 

    378. 

  378. 

    379. 

  379. $mem_glz_custom_fields_plugin = load_plugin('glz_custom_fields');

    380. 

  380. 

    381. 

  381. // needed for MLP

    382. 

  382. define( 'MEM_FORM_PREFIX' , 'mem_form' );

    383. 

  383. 

    384. 

  384. global $mem_form_lang;

    385. 

  385. 

    386. 

  386. if (!is_array($mem_form_lang))

    387. 

  387. {

    388. 

  388. 	$mem_form_lang = array(

    389. 

  389. 		'error_file_extension'	=> 'File upload failed for field {label}.',

    390. 

  390. 		'error_file_failed'	=> 'Failed to upload file for field {label}.',

    391. 

  391. 		'error_file_size'	=> 'Failed to upload File for field {label}. File is too large.',

    392. 

  392. 		'field_missing'	=> 'The field {label} is required.',

    393. 

  393. 		'form_expired'	=>	'The form has expired.',

    394. 

  394. 		'form_misconfigured'	=> 'The mem_form is misconfigured. You must specify the "form" attribute.',

    395. 

  395. 		'form_sorry'	=> 'The form is currently unavailable.',

    396. 

  396. 		'form_used'	=>	'This form has already been used to submit.',

    397. 

  397. 		'general_inquiry'	=> '',

    398. 

  398. 		'invalid_email'	=> 'The email address {email} is invalid.',

    399. 

  399. 		'invalid_host'	=> 'The host {domain} is invalid.',

    400. 

  400. 		'invalid_utf8'	=> 'Invalid UTF8 string for field {label}.',

    401. 

  401. 		'invalid_value'	=> 'The value "{value}" is invalid for the input field {label}.',

    402. 

  402. 		'invalid_format'	=>	'The input field {label} must match the format "{example}".',

    403. 

  403. 		'invalid_too_many_selected'	=> 'The input field {label} only allows {count} selected {plural}.',

    404. 

  404. 		'item'	=> 'item',

    405. 

  405. 		'items'	=> 'items',

    406. 

  406. 		'max_warning'	=> 'The input field {label} must be smaller than {max} characters long.',

    407. 

  407. 		'min_warning'	=> 'The input field {label} must be at least {min} characters long.',

    408. 

  408. 		'refresh'	=> 'Refresh',

    409. 

  409. 		'spam'	=> 'Your submission was blocked by a spam filter.',

    410. 

  410. 		'submitted_thanks'	=>	'You have successfully submitted the form. Thank you.',

    411. 

  411. 	);

    412. 

  412. }

    413. 

  413. 

    414. 

  414. register_callback( 'mem_form_enumerate_strings' , 'l10n.enumerate_strings' );

    415. 

  415. function mem_form_enumerate_strings($event , $step='' , $pre=0)

    416. 

  416. {

    417. 

  417. 	global $mem_form_lang;

    418. 

  418. 	$r = array	(

    419. 

  419. 				'owner'		=> 'mem_form',			#	Change to your plugin's name

    420. 

  420. 				'prefix'	=> MEM_FORM_PREFIX,		#	Its unique string prefix

    421. 

  421. 				'lang'		=> 'en-gb',				#	The language of the initial strings.

    422. 

  422. 				'event'		=> 'public',			#	public/admin/common = which interface the strings will be loaded into

    423. 

  423. 				'strings'	=> $mem_form_lang,		#	The strings themselves.

    424. 

  424. 				);

    425. 

  425. 	return $r;

    426. 

  426. }

    427. 

  427. 

    428. 

  428. 

    429. 

  429. function mem_form_gTxt($what,$args = array())

    430. 

  430. {

    431. 

  431. 	global $mem_form_lang, $textarray;

    432. 

  432. 

    433. 

  433. 	$key = strtolower( MEM_FORM_PREFIX . '-' . $what );

    434. 

  434. 	

    435. 

  435. 	if (isset($textarray[$key]))

    436. 

  436. 	{

    437. 

  437. 		$str = $textarray[$key];

    438. 

  438. 	}

    439. 

  439. 	else

    440. 

  440. 	{

    441. 

  441. 		$key = strtolower($what);

    442. 

  442. 		

    443. 

  443. 		if (isset($mem_form_lang[$key]))

    444. 

  444. 			$str = $mem_form_lang[$key];

    445. 

  445. 		elseif (isset($textarray[$key]))

    446. 

  446. 			$str = $textarray[$key];

    447. 

  447. 		else

    448. 

  448. 			$str = $what;

    449. 

  449. 	}

    450. 

  450. 

    451. 

  451. 	if( !empty($args) )

    452. 

  452. 		$str = strtr( $str , $args );

    453. 

  453. 

    454. 

  454. 	return $str;

    455. 

  455. }

    456. 

  456. 

    457. 

  457. 

    458. 

  458. function mem_form($atts, $thing='', $default=false)

    459. 

  459. {

    460. 

  460. 	global $sitename, $prefs, $file_max_upload_size, $mem_form_error, $mem_form_submit,

    461. 

  461. 		$mem_form, $mem_form_labels, $mem_form_values, $mem_form_default_break,

    462. 

  462. 		$mem_form_default, $mem_form_type, $mem_form_thanks_form,

    463. 

  463. 		$mem_glz_custom_fields_plugin;

    464. 

  464. 

    465. 

  465. 	extract(mem_form_lAtts(array(

    466. 

  466. 		'form'		=> '',

    467. 

  467. 		'thanks_form'	=> '',

    468. 

  468. 		'thanks'	=> graf(mem_form_gTxt('submitted_thanks')),

    469. 

  469. 		'label'		=> '',

    470. 

  470. 		'type'		=> '',

    471. 

  471. 		'redirect'	=> '',

    472. 

  472. 		'redirect_form'	=> '',

    473. 

  473. 		'class'		=> 'memForm',

    474. 

  474. 		'enctype'	=> '',

    475. 

  475. 		'file_accept'	=> '',

    476. 

  476. 		'max_file_size'	=> $file_max_upload_size,

    477. 

  477. 		'form_expired_msg' => mem_form_gTxt('form_expired'),

    478. 

  478. 		'show_error'	=> 1,

    479. 

  479. 		'show_input'	=> 1,

    480. 

  480. 		'default_break'	=> br,

    481. 

  481. 	), $atts));

    482. 

  482. 	

    483. 

  483. 	if (empty($type) or (empty($form) && empty($thing))) {

    484. 

  484. 		trigger_error('Argument not specified for mem_form tag', E_USER_WARNING);

    485. 

  485. 		

    486. 

  486. 		return '';

    487. 

  487. 	}

    488. 

  488. 	$out = '';

    489. 

  489. 

    490. 

  490. 	// init error structure

    491. 

  491. 	mem_form_error();

    492. 

  492. 

    493. 

  493. 	$mem_form_type = $type;

    494. 

  494. 	

    495. 

  495. 	$mem_form_default = is_array($default) ? $default : array();

    496. 

  496. 	callback_event('mem_form.defaults');

    497. 

  497. 	

    498. 

  498. 	unset($atts['show_error'], $atts['show_input']);

    499. 

  499. 	$mem_form_id = md5(serialize($atts).preg_replace('/[\t\s\r\n]/','',$thing));

    500. 

  500. 	$mem_form_submit = (ps('mem_form_id') == $mem_form_id);

    501. 

  501. 	

    502. 

  502. 	$nonce   = doSlash(ps('mem_form_nonce'));

    503. 

  503. 	$renonce = false;

    504. 

  504. 

    505. 

  505. 	if ($mem_form_submit) {

    506. 

  506. 		safe_delete('txp_discuss_nonce', 'issue_time < date_sub(now(), interval 10 minute)');

    507. 

  507. 		if ($rs = safe_row('used', 'txp_discuss_nonce', "nonce = '$nonce'"))

    508. 

  508. 		{

    509. 

  509. 			if ($rs['used'])

    510. 

  510. 			{

    511. 

  511. 				unset($mem_form_error);

    512. 

  512. 				mem_form_error(mem_form_gTxt('form_used'));

    513. 

  513. 				$renonce = true;

    514. 

  514. 				

    515. 

  515. 				$_POST['mem_form_submit'] = TRUE;

    516. 

  516. 				$_POST['mem_form_id'] = $mem_form_id;

    517. 

  517. 				$_POST['mem_form_nonce'] = $nonce;

    518. 

  518. 			}

    519. 

  519. 		}

    520. 

  520. 		else

    521. 

  521. 		{

    522. 

  522. 			mem_form_error($form_expired_msg);

    523. 

  523. 			$renonce = true;

    524. 

  524. 		}

    525. 

  525. 	}

    526. 

  526. 	

    527. 

  527. 	if ($mem_form_submit and $nonce and !$renonce)

    528. 

  528. 	{

    529. 

  529. 		$mem_form_nonce = $nonce;

    530. 

  530. 	}

    531. 

  531. 

    532. 

  532. 	elseif (!$show_error or $show_input)

    533. 

  533. 	{

    534. 

  534. 		$mem_form_nonce = md5(uniqid(rand(), true));

    535. 

  535. 		safe_insert('txp_discuss_nonce', "issue_time = now(), nonce = '$mem_form_nonce'");

    536. 

  536. 	}

    537. 

  537. 

    538. 

  538. 	$form = ($form) ? fetch_form($form) : $thing;

    539. 

  539. 	$form = parse($form);

    540. 

  540. 	

    541. 

  541. 	if ($mem_form_submit && empty($mem_form_error))

    542. 

  542. 	{

    543. 

  543. 		// let plugins validate after individual fields are validated

    544. 

  544. 		callback_event('mem_form.validate');

    545. 

  545. 	}

    546. 

  546. 	

    547. 

  547. 	if (!$mem_form_submit) {

    548. 

  548. 	  # don't show errors or send mail

    549. 

  549. 	}

    550. 

  550. 	elseif (mem_form_error())

    551. 

  551. 	{

    552. 

  552. 		if ($show_error or !$show_input)

    553. 

  553. 		{

    554. 

  554. 			$out .= mem_form_display_error();

    555. 

  555. 

    556. 

  556. 			if (!$show_input) return $out;

    557. 

  557. 		}

    558. 

  558. 	}

    559. 

  559. 	elseif ($show_input and is_array($mem_form))

    560. 

  560. 	{

    561. 

  561. 		if ($mem_glz_custom_fields_plugin) {

    562. 

  562. 			// prep the values

    563. 

  563. 			glz_custom_fields_before_save();

    564. 

  564. 		}

    565. 

  565. 		

    566. 

  566. 		callback_event('mem_form.spam');

    567. 

  567. 

    568. 

  568. 		/// load and check spam plugins/

    569. 

  569. 		$evaluator =& get_mem_form_evaluator();

    570. 

  570. 		$is_spam = $evaluator->is_spam();

    571. 

  571. 

    572. 

  572. 		if ($is_spam) {

    573. 

  573. 			return mem_form_gTxt('spam');

    574. 

  574. 		}

    575. 

  575. 

    576. 

  576. 		$mem_form_thanks_form = ($thanks_form ? fetch_form($thanks_form) : $thanks);

    577. 

  577. 

    578. 

  578. 		safe_update('txp_discuss_nonce', "used = '1', issue_time = now()", "nonce = '$nonce'");

    579. 

  579. 		

    580. 

  580. 		$result = callback_event('mem_form.submit');

    581. 

  581. 

    582. 

  582. 		if (mem_form_error()) {

    583. 

  583. 			$out .= mem_form_display_error();

    584. 

  584. 			$redirect = false;

    585. 

  585. 		}

    586. 

  586. 

    587. 

  587. 		$thanks_form = $mem_form_thanks_form;

    588. 

  588. 		unset($mem_form_thanks_form);

    589. 

  589. 

    590. 

  590. 		if (!empty($result))

    591. 

  591. 			return $result;

    592. 

  592. 		

    593. 

  593. 		if (mem_form_error() and $show_input) 

    594. 

  594. 		{

    595. 

  595. 			// no-op, reshow form with errors

    596. 

  596. 		}

    597. 

  597. 		else if ($redirect)

    598. 

  598. 		{

    599. 

  599. 			$_POST = array();

    600. 

  600. 

    601. 

  601. 			while (@ob_end_clean());

    602. 

  602. 			$uri = hu.ltrim($redirect,'/');

    603. 

  603. 			if (empty($_SERVER['FCGI_ROLE']) and empty($_ENV['FCGI_ROLE']))

    604. 

  604. 			{

    605. 

  605. 				txp_status_header('303 See Other');

    606. 

  606. 				header('Location: '.$uri);

    607. 

  607. 				header('Connection: close');

    608. 

  608. 				header('Content-Length: 0');

    609. 

  609. 			}

    610. 

  610. 			else

    611. 

  611. 			{

    612. 

  612. 				$uri = htmlspecialchars($uri);

    613. 

  613. 				$refresh = mem_form_gTxt('refresh');

    614. 

  614. 				

    615. 

  615. 				if (!empty($redirect_form))

    616. 

  616. 				{

    617. 

  617. 					$redirect_form = fetch_form($redirect_form);

    618. 

  618. 					

    619. 

  619. 					echo str_replace('{uri}', $uri, $redirect_form);					

    620. 

  620. 				}

    621. 

  621. 				

    622. 

  622. 				if (empty($redirect_form))

    623. 

  623. 				{

    624. 

  624. 					echo <<<END

    625. 

  625. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

    626. 

  626. <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">

    627. 

  627. <head>

    628. 

  628. 	<title>$sitename</title>

    629. 

  629. 	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

    630. 

  630. 	<meta http-equiv="refresh" content="0;url=$uri" />

    631. 

  631. </head>

    632. 

  632. <body>

    633. 

  633. <a href="$uri">$refresh</a>

    634. 

  634. </body>

    635. 

  635. </html>

    636. 

  636. END;

    637. 

  637. 				}

    638. 

  638. 			}

    639. 

  639. 			exit;

    640. 

  640. 		}

    641. 

  641. 		else {

    642. 

  642. 			return '<div class="memThanks" id="mem'.$mem_form_id.'">' .

    643. 

  643. 				$thanks_form . '</div>';			

    644. 

  644. 		}

    645. 

  645. 	}

    646. 

  646. 

    647. 

  647. 	if ($show_input)

    648. 

  648. 	{

    649. 

  649. 		$file_accept = (!empty($file_accept) ? ' accept="'.$file_accept.'"' : '');

    650. 

  650. 		

    651. 

  651. 		$class = htmlspecialchars($class);

    652. 

  652. 		

    653. 

  653. 		$enctype = !empty($enctype) ? ' enctype="'.$enctype.'"' : '';

    654. 

  654. 		

    655. 

  655. 		return '<form method="post"'.((!$show_error and $mem_form_error) ? '' : ' id="mem'.$mem_form_id.'"').' class="'.$class.'" action="'.htmlspecialchars(serverSet('REQUEST_URI')).'#mem'.$mem_form_id.'"'.$file_accept.$enctype.'>'.

    656. 

  656. 			( $label ? n.'<fieldset>' : n.'<div>' ).

    657. 

  657. 			( $label ? n.'<legend>'.htmlspecialchars($label).'</legend>' : '' ).

    658. 

  658. 			$out.

    659. 

  659. 			n.'<input type="hidden" name="mem_form_nonce" value="'.$mem_form_nonce.'" />'.

    660. 

  660. 			n.'<input type="hidden" name="mem_form_id" value="'.$mem_form_id.'" />'.

    661. 

  661. 			(!empty($max_file_size) ? n.'<input type="hidden" name="MAX_FILE_SIZE" value="'.$max_file_size.'" />' : '' ).

    662. 

  662. 			callback_event('mem_form.display','',1).

    663. 

  663. 			$form.

    664. 

  664. 			callback_event('mem_form.display').

    665. 

  665. 			( $label ? (n.'</fieldset>') : (n.'</div>') ).

    666. 

  666. 			n.'</form>';

    667. 

  667. 	}

    668. 

  668. 

    669. 

  669. 	return '';

    670. 

  670. }

    671. 

  671. 

    672. 

  672. function mem_form_text($atts)

    673. 

  673. {

    674. 

  674. 	global $mem_form_error, $mem_form_submit, $mem_form_default, $mem_form_default_break;

    675. 

  675. 

    676. 

  676. 	extract(mem_form_lAtts(array(

    677. 

  677. 		'break'		=> $mem_form_default_break,

    678. 

  678. 		'default'	=> '',

    679. 

  679. 		'isError'	=> '',

    680. 

  680. 		'label'		=> mem_form_gTxt('text'),

    681. 

  681. 		'max'		=> 100,

    682. 

  682. 		'min'		=> 0,

    683. 

  683. 		'name'		=> '',

    684. 

  684. 		'class'		=> 'memText',

    685. 

  685. 		'required'	=> 1,

    686. 

  686. 		'size'		=> '',

    687. 

  687. 		'password'	=> 0,

    688. 

  688. 		'format'	=> '',

    689. 

  689. 		'example'	=> '',

    690. 

  690. 		'escape_value'	=> 1

    691. 

  691. 	), $atts));

    692. 

  692. 

    693. 

  693. 	$min = intval($min);

    694. 

  694. 	$max = intval($max);

    695. 

  695. 	$size = intval($size);

    696. 

  696. 

    697. 

  697. 	if (empty($name)) $name = mem_form_label2name($label);

    698. 

  698. 

    699. 

  699. 	if ($mem_form_submit)

    700. 

  700. 	{

    701. 

  701. 		$value = trim(ps($name));

    702. 

  702. 		$utf8len = preg_match_all("/./su", $value, $utf8ar);

    703. 

  703. 		$hlabel = empty($label) ? htmlspecialchars($name) : htmlspecialchars($label);

    704. 

  704. 		

    705. 

  705. 

    706. 

  706. 		if (strlen($value) == 0 && $required)

    707. 

  707. 		{

    708. 

  708. 			$mem_form_error[] = mem_form_gTxt('field_missing', array('{label}'=>$hlabel));

    709. 

  709. 			$isError = true;

    710. 

  710. 		}

    711. 

  711. 		elseif ($required && !empty($format) && !preg_match($format, $value))

    712. 

  712. 		{

    713. 

  713. 			//echo "format=$format<br />value=$value<br />";

    714. 

  714. 			$mem_form_error[] = mem_form_gTxt('invalid_format', array('{label}'=>$hlabel, '{example}'=> htmlspecialchars($example)));

    715. 

  715. 			$isError = true;

    716. 

  716. 		}

    717. 

  717. 		elseif (strlen($value))

    718. 

  718. 		{

    719. 

  719. 			if (!$utf8len)

    720. 

  720. 			{

    721. 

  721. 				$mem_form_error[] = mem_form_gTxt('invalid_utf8', array('{label}'=>$hlabel));

    722. 

  722. 				$isError = true;

    723. 

  723. 			}

    724. 

  724. 

    725. 

  725. 			elseif ($min and $utf8len < $min)

    726. 

  726. 			{

    727. 

  727. 				$mem_form_error[] = mem_form_gTxt('min_warning', array('{label}'=>$hlabel, '{min}'=>$min));

    728. 

  728. 				$isError = true;

    729. 

  729. 			}

    730. 

  730. 

    731. 

  731. 			elseif ($max and $utf8len > $max)

    732. 

  732. 			{

    733. 

  733. 				$mem_form_error[] = mem_form_gTxt('max_warning', array('{label}'=>$hlabel, '{max}'=>$max));

    734. 

  734. 				$isError = true;

    735. 

  735. 			}

    736. 

  736. 

    737. 

  737. 			else

    738. 

  738. 			{

    739. 

  739. 				$isError = false === mem_form_store($name, $label, $value);

    740. 

  740. 			}

    741. 

  741. 		}

    742. 

  742. 	}

    743. 

  743. 

    744. 

  744. 	else

    745. 

  745. 	{

    746. 

  746. 		if (isset($mem_form_default[$name]))

    747. 

  747. 			$value = $mem_form_default[$name];

    748. 

  748. 		else

    749. 

  749. 			$value = $default;

    750. 

  750. 	}

    751. 

  751. 

    752. 

  752. 	$size = ($size) ? ' size="'.$size.'"' : '';

    753. 

  753. 	$maxlength = ($max) ? ' maxlength="'.$max.'"' : '';

    754. 

  754. 

    755. 

  755. 	$isError = $isError ? "errorElement" : '';

    756. 

  756. 

    757. 

  757. 	$memRequired = $required ? 'memRequired' : '';

    758. 

  758. 	$class = htmlspecialchars($class);

    759. 

  759. 	

    760. 

  760. 	if ($escape_value)

    761. 

  761. 	{

    762. 

  762. 		$value = htmlspecialchars($value);

    763. 

  763. 	}

    764. 

  764. 	

    765. 

  765.     return '<label for="'.$name.'" class="'.$class.' '.$memRequired.$isError.' '.$name.'">'.htmlspecialchars($label).'</label>'.$break.

    766. 

  766. 		'<input type="'.($password ? 'password' : 'text').'" id="'.$name.'" class="'.$class.' '.$memRequired.$isError.'" name="'.$name.'" value="'.$value.'"'.$size.$maxlength.' />';

    767. 

  767. }

    768. 

  768. 

    769. 

  769. 

    770. 

  770. function mem_form_file($atts)

    771. 

  771. {

    772. 

  772. 	global $mem_form_submit, $mem_form_error, $mem_form_default, $file_max_upload_size, $tempdir, $mem_form_default_break;

    773. 

  773. 	

    774. 

  774. 	extract(mem_form_lAtts(array(

    775. 

  775. 		'break'		=> $mem_form_default_break,

    776. 

  776. 		'isError'	=> '',

    777. 

  777. 		'label'		=> mem_form_gTxt('file'),

    778. 

  778. 		'name'		=> '',

    779. 

  779. 		'class'		=> 'memFile',

    780. 

  780. 		'size'		=> '',

    781. 

  781. 		'accept'	=> '',

    782. 

  782. 		'no_replace' => 1,

    783. 

  783. 		'max_file_size'	=> $file_max_upload_size,

    784. 

  784. 		'required'	=> 1,

    785. 

  785. 		'default'	=> FALSE,

    786. 

  786. 	), $atts));

    787. 

  787. 

    788. 

  788. 	$fname = ps('file_'.$name);

    789. 

  789. 	$frealname = ps('file_info_'.$name.'_name');

    790. 

  790. 	$ftype = ps('file_info_'.$name.'_type');

    791. 

  791. 	

    792. 

  792. 	if (empty($name)) $name = mem_form_label2name($label);

    793. 

  793. 

    794. 

  794. 	$out = '';

    795. 

  795. 

    796. 

  796. 	if ($mem_form_submit)

    797. 

  797. 	{		

    798. 

  798. 		if (!empty($fname))

    799. 

  799. 		{

    800. 

  800. 			// see if user uploaded a different file to replace already uploaded

    801. 

  801. 			if (isset($_FILES[$name]) && !empty($_FILES[$name]['tmp_name']))

    802. 

  802. 			{

    803. 

  803. 				// unlink last temp file

    804. 

  804. 				if (file_exists($fname) && substr_compare($fname, $tempdir, 0, strlen($tempdir), 1)==0)

    805. 

  805. 					unlink($fname);

    806. 

  806. 				

    807. 

  807. 				$fname = '';

    808. 

  808. 			}

    809. 

  809. 			else

    810. 

  810. 			{

    811. 

  811. 				// pass through already uploaded filename

    812. 

  812. 				mem_form_store($name, $label, array('tmp_name'=>$fname, 'name' => $frealname, 'type' => $ftype));

    813. 

  813. 				$out .= "<input type='hidden' name='file_".$name."' value='".htmlspecialchars($fname)."' />"

    814. 

  814. 						. "<input type='hidden' name='file_info_".$name."_name' value='".htmlspecialchars($frealname)."' />"

    815. 

  815. 						. "<input type='hidden' name='file_info_".$name."_type' value='".htmlspecialchars($ftype)."' />";

    816. 

  816. 			}

    817. 

  817. 		}

    818. 

  818. 

    819. 

  819. 		if (empty($fname))

    820. 

  820. 		{

    821. 

  821. 			$hlabel = empty($label) ? htmlspecialchars($name) : htmlspecialchars($label);

    822. 

  822. 	

    823. 

  823. 			$fname = $_FILES[$name]['tmp_name'];

    824. 

  824. 			$frealname = $_FILES[$name]['name'];

    825. 

  825. 			$ftype = $_FILES[$name]['type'];

    826. 

  826. 			$err = 0;

    827. 

  827. 

    828. 

  828. 			switch ($_FILES[$name]['error']) {

    829. 

  829. 				case UPLOAD_ERR_OK:

    830. 

  830. 					if (is_uploaded_file($fname) and $max_file_size >= filesize($fname))

    831. 

  831. 						mem_form_store($name, $label, $_FILES[$name]);

    832. 

  832. 					elseif (!is_uploaded_file($fname)) {

    833. 

  833. 						if ($required) {

    834. 

  834. 							$mem_form_error[] = mem_form_gTxt('error_file_failed', array('{label}'=>$hlabel));

    835. 

  835. 							$err = 1;

    836. 

  836. 						}

    837. 

  837. 					}

    838. 

  838. 					else {

    839. 

  839. 						$mem_form_error[] = mem_form_gTxt('error_file_size', array('{label}'=>$hlabel));

    840. 

  840. 						$err = 1;

    841. 

  841. 					}

    842. 

  842. 					break;

    843. 

  843. 	

    844. 

  844. 				case UPLOAD_ERR_NO_FILE:

    845. 

  845. 					if ($required) {

    846. 

  846. 						$mem_form_error[] = mem_form_gTxt('field_missing', array('{label}'=>$hlabel));

    847. 

  847. 						$err = 1;

    848. 

  848. 					}

    849. 

  849. 					break;

    850. 

  850. 	

    851. 

  851. 				case UPLOAD_ERR_EXTENSION:

    852. 

  852. 					$mem_form_error[] = mem_form_gTxt('error_file_extension', array('{label}'=>$hlabel));

    853. 

  853. 					$err = 1;

    854. 

  854. 					break;

    855. 

  855. 	

    856. 

  856. 				case UPLOAD_ERR_INI_SIZE:

    857. 

  857. 				case UPLOAD_ERR_FORM_SIZE:

    858. 

  858. 					$mem_form_error[] = mem_form_gTxt('error_file_size', array('{label}'=>$hlabel));

    859. 

  859. 					$err = 1;

    860. 

  860. 					break;

    861. 

  861. 					

    862. 

  862. 				default:

    863. 

  863. 					$mem_form_error[] = mem_form_gTxt('error_file_failed', array('{label}'=>$hlabel));

    864. 

  864. 					$err = 1;

    865. 

  865. 					break;

    866. 

  866. 			}

    867. 

  867. 

    868. 

  868. 			if (!$err)

    869. 

  869. 			{

    870. 

  870. 				// store as a txp tmp file to be used later

    871. 

  871. 				$fname = get_uploaded_file($fname);

    872. 

  872. 				$err = false === mem_form_store($name, $label, array('tmp_name'=>$fname, 'name' => $frealname, 'type' => $ftype));

    873. 

  873. 				if ($err)

    874. 

  874. 				{

    875. 

  875. 					// clean up file

    876. 

  876. 					@unlink($fname);

    877. 

  877. 				}

    878. 

  878. 				else

    879. 

  879. 				{

    880. 

  880. 					$out .= "<input type='hidden' name='file_".$name."' value='".htmlspecialchars($fname)."' />"

    881. 

  881. 							. "<input type='hidden' name='file_info_".$name."_name' value='".htmlspecialchars($_FILES[$name]['name'])."' />"

    882. 

  882. 							. "<input type='hidden' name='file_info_".$name."_type' value='".htmlspecialchars($_FILES[$name]['type'])."' />";

    883. 

  883. 				}

    884. 

  884. 			}

    885. 

  885. 			

    886. 

  886. 			$isError = $err ? 'errorElement' : '';

    887. 

  887. 		}

    888. 

  888. 	}

    889. 

  889. 	else

    890. 

  890. 	{

    891. 

  891. 		if (isset($mem_form_default[$name]))

    892. 

  892. 			$value = $mem_form_default[$name];

    893. 

  893. 		else if (is_array($default))

    894. 

  894. 			$value = $default;

    895. 

  895. 

    896. 

  896. 		if (is_array(@$value))

    897. 

  897. 		{

    898. 

  898. 			$fname = @$value['tmp_name'];

    899. 

  899. 			$frealname = @$value['name'];

    900. 

  900. 			$ftype = @$value['type'];

    901. 

  901. 			$out .= "<input type='hidden' name='file_".$name."' value='".htmlspecialchars($fname)."' />"

    902. 

  902. 				. "<input type='hidden' name='file_info_".$name."_name' value='".htmlspecialchars($frealname)."' />"

    903. 

  903. 				. "<input type='hidden' name='file_info_".$name."_type' value='".htmlspecialchars($ftype)."' />";

    904. 

  904. 		}

    905. 

  905. 	}

    906. 

  906. 	

    907. 

  907. 	$memRequired = $required ? 'memRequired' : '';

    908. 

  908. 	$class = htmlspecialchars($class);

    909. 

  909. 	

    910. 

  910. 	$size = ($size) ? ' size="'.$size.'"' : '';

    911. 

  911. 	$accept = (!empty($accept) ? ' accept="'.$accept.'"' : '');

    912. 

  912. 	

    913. 

  913. 

    914. 

  914. 	$field_out = '<label for="'.$name.'" class="'.$class.' '.$memRequired.$isError.' '.$name.'">'.htmlspecialchars($label).'</label>'.$break;

    915. 

  915. 

    916. 

  916. 	if (!empty($frealname) && $no_replace)

    917. 

  917. 	{

    918. 

  918. 		$field_out .= '<div id="'.$name.'">'.htmlspecialchars($frealname) . ' <span id="'.$name.'_ftype">('. htmlspecialchars($ftype).')</span></div>';

    919. 

  919. 	}

    920. 

  920. 	else

    921. 

  921. 	{

    922. 

  922. 		$field_out .= '<input type="file" id="'.$name.'" class="'.$class.' '.$memRequired.$isError.'" name="'.$name.'"' .$size.' />';

    923. 

  923. 	}

    924. 

  924. 

    925. 

  925.   return $out.$field_out;		

    926. 

  926. }

    927. 

  927. 

    928. 

  928. function mem_form_textarea($atts, $thing='')

    929. 

  929. {

    930. 

  930. 	global $mem_form_error, $mem_form_submit, $mem_form_default, $mem_form_default_break;

    931. 

  931. 

    932. 

  932. 	extract(mem_form_lAtts(array(

    933. 

  933. 		'break'		=> $mem_form_default_break,

    934. 

  934. 		'cols'		=> 58,

    935. 

  935. 		'default'	=> '',

    936. 

  936. 		'isError'	=> '',

    937. 

  937. 		'label'		=> mem_form_gTxt('textarea'),

    938. 

  938. 		'max'		=> 10000,

    939. 

  939. 		'min'		=> 0,

    940. 

  940. 		'name'		=> '',

    941. 

  941. 		'class'		=> 'memTextarea',

    942. 

  942. 		'required'	=> 1,

    943. 

  943. 		'rows'		=> 8,

    944. 

  944. 		'escape_value'	=> 1

    945. 

  945. 	), $atts));

    946. 

  946. 

    947. 

  947. 	$min = intval($min);

    948. 

  948. 	$max = intval($max);

    949. 

  949. 	$cols = intval($cols);

    950. 

  950. 	$rows = intval($rows);

    951. 

  951. 

    952. 

  952. 	if (empty($name)) $name = mem_form_label2name($label);

    953. 

  953. 

    954. 

  954. 	if ($mem_form_submit)

    955. 

  955. 	{

    956. 

  956. 		$value = preg_replace('/^\s*[\r\n]/', '', rtrim(ps($name)));

    957. 

  957. 		$utf8len = preg_match_all("/./su", ltrim($value), $utf8ar);

    958. 

  958. 		$hlabel = htmlspecialchars($label);

    959. 

  959. 

    960. 

  960. 		if (strlen(ltrim($value)))

    961. 

  961. 		{

    962. 

  962. 			if (!$utf8len)

    963. 

  963. 			{

    964. 

  964. 				$mem_form_error[] = mem_form_gTxt('invalid_utf8', array('{label}'=>$hlabel));

    965. 

  965. 				$isError = true;

    966. 

  966. 			}

    967. 

  967. 

    968. 

  968. 			elseif ($min and $utf8len < $min)

    969. 

  969. 			{

    970. 

  970. 				$mem_form_error[] = mem_form_gTxt('min_warning', array('{label}'=>$hlabel, '{min}'=>$min));

    971. 

  971. 				$isError = true;

    972. 

  972. 			}

    973. 

  973. 

    974. 

  974. 			elseif ($max and $utf8len > $max)

    975. 

  975. 			{

    976. 

  976. 				$mem_form_error[] = mem_form_gTxt('max_warning', array('{label}'=>$hlabel, '{max}'=>$max));

    977. 

  977. 				$isError = true;

    978. 

  978. 			}

    979. 

  979. 

    980. 

  980. 			else

    981. 

  981. 			{

    982. 

  982. 				$isError = false === mem_form_store($name, $label, $value);

    983. 

  983. 			}

    984. 

  984. 		}

    985. 

  985. 

    986. 

  986. 		elseif ($required)

    987. 

  987. 		{

    988. 

  988. 			$mem_form_error[] = mem_form_gTxt('field_missing', array('{label}'=>$hlabel));

    989. 

  989. 			$isError = true;

    990. 

  990. 		}

    991. 

  991. 	}

    992. 

  992. 

    993. 

  993. 	else

    994. 

  994. 	{

    995. 

  995. 		if (isset($mem_form_default[$name]))

    996. 

  996. 			$value = $mem_form_default[$name];

    997. 

  997. 		else if (!empty($default))

    998. 

  998. 			$value = $default;

    999. 

  999. 		else

    1000. 

  1000. 			$value = parse($thing);

    1001. 

  1001. 	}

    1002. 

  1002. 

    1003. 

  1003. 	$isError = $isError ? 'errorElement' : '';

    1004. 

  1004. 	$memRequired = $required ? 'memRequired' : '';

    1005. 

  1005. 	$class = htmlspecialchars($class);

    1006. 

  1006. 	

    1007. 

  1007. 	if ($escape_value)

    1008. 

  1008. 	{

    1009. 

  1009. 		$value = htmlspecialchars($value);

    1010. 

  1010. 	}

    1011. 

  1011. 

    1012. 

  1012. 	return '<label for="'.$name.'" class="'.$class.' '.$memRequired.$isError.' '.$name.'">'.htmlspecialchars($label).'</label>'.$break.

    1013. 

  1013. 		'<textarea id="'.$name.'" class="'.$class.' '.$memRequired.$isError.'" name="'.$name.'" cols="'.$cols.'" rows="'.$rows.'">'.$value.'</textarea>';

    1014. 

  1014. }

    1015. 

  1015. 

    1016. 

  1016. function mem_form_email($atts)

    1017. 

  1017. {

    1018. 

  1018. 	global $mem_form_error, $mem_form_submit, $mem_form_from, $mem_form_default, $mem_form_default_break;

    1019. 

  1019. 

    1020. 

  1020. 	extract(mem_form_lAtts(array(

    1021. 

  1021. 		'default'	=> '',

    1022. 

  1022. 		'isError'	=> '',

    1023. 

  1023. 		'label'		=> mem_form_gTxt('email'),

    1024. 

  1024. 		'max'		=> 100,

    1025. 

  1025. 		'min'		=> 0,

    1026. 

  1026. 		'name'		=> '',

    1027. 

  1027. 		'required'	=> 1,

    1028. 

  1028. 		'break'		=> $mem_form_default_break,

    1029. 

  1029. 		'size'		=> '',

    1030. 

  1030. 		'class'		=> 'memEmail',

    1031. 

  1031. 	), $atts));

    1032. 

  1032. 

    1033. 

  1033. 	if (empty($name)) $name = mem_form_label2name($label);

    1034. 

  1034. 

    1035. 

  1035. 	if ($mem_form_submit)

    1036. 

  1036. 	{

    1037. 

  1037. 		$email = trim(ps($name));

    1038. 

  1038. 

    1039. 

  1039. 		if (strlen($email))

    1040. 

  1040. 		{

    1041. 

  1041. 			if (!is_valid_email($email))

    1042. 

  1042. 			{

    1043. 

  1043. 				$mem_form_error[] = mem_form_gTxt('invalid_email', array('{email}'=>htmlspecialchars($email)));

    1044. 

  1044. 				$isError = true;

    1045. 

  1045. 			}	

    1046. 

  1046. 			else

    1047. 

  1047. 			{

    1048. 

  1048. 				preg_match("/@(.+)$/", $email, $match);

    1049. 

  1049. 				$domain = $match[1];

    1050. 

  1050. 	

    1051. 

  1051. 				if (is_callable('checkdnsrr') and checkdnsrr('textpattern.com.','A') and !checkdnsrr($domain.'.','MX') and !checkdnsrr($domain.'.','A'))

    1052. 

  1052. 				{

    1053. 

  1053. 					$mem_form_error[] = mem_form_gTxt('invalid_host', array('{domain}'=>htmlspecialchars($domain)));

    1054. 

  1054. 					$isError = true;

    1055. 

  1055. 				}

    1056. 

  1056. 				else

    1057. 

  1057. 				{

    1058. 

  1058. 					$mem_form_from = $email;

    1059. 

  1059. 				}

    1060. 

  1060. 			}

    1061. 

  1061. 		}

    1062. 

  1062. 	}

    1063. 

  1063. 	else 

    1064. 

  1064. 	{

    1065. 

  1065. 		if (isset($mem_form_default[$name]))

    1066. 

  1066. 			$email = $mem_form_default[$name];

    1067. 

  1067. 		else

    1068. 

  1068. 			$email = $default;

    1069. 

  1069. 	}

    1070. 

  1070. 

    1071. 

  1071. 	return mem_form_text(array(

    1072. 

  1072. 		'default'	=> $email,

    1073. 

  1073. 		'isError'	=> $isError,

    1074. 

  1074. 		'label'		=> $label,

    1075. 

  1075. 		'max'		=> $max,

    1076. 

  1076. 		'min'		=> $min,

    1077. 

  1077. 		'name'		=> $name,

    1078. 

  1078. 		'required'	=> $required,

    1079. 

  1079. 		'break'		=> $break,

    1080. 

  1080. 		'size'		=> $size,

    1081. 

  1081. 		'class'		=> $class,

    1082. 

  1082. 	));

    1083. 

  1083. }

    1084. 

  1084. 

    1085. 

  1085. function mem_form_select_section($atts)

    1086. 

  1086. {

    1087. 

  1087. 	extract(mem_form_lAtts(array(

    1088. 

  1088. 		'exclude'	=> '',

    1089. 

  1089. 		'sort'		=> 'name ASC',

    1090. 

  1090. 		'delimiter'	=> ',',

    1091. 

  1091. 	),$atts,false));

    1092. 

  1092. 	

    1093. 

  1093. 	if (!empty($exclude)) {

    1094. 

  1094. 		$exclusion = array_map('trim', explode($delimiter, preg_replace('/[\r\n\t\s]+/', ' ',$exclude)));

    1095. 

  1095. 		$exclusion = array_map('strtolower', $exclusion);

    1096. 

  1096. 

    1097. 

  1097. 		if (count($exclusion))

    1098. 

  1098. 			$exclusion = join($delimiter, quote_list($exclusion));

    1099. 

  1099. 	}

    1100. 

  1100. 

    1101. 

  1101. 	$where = empty($exclusion) ? '1=1' : 'LOWER(name) NOT IN ('.$exclusion.')';

    1102. 

  1102. 	

    1103. 

  1103. 	$sort = empty($sort) ? '' : ' ORDER BY '. doSlash($sort);

    1104. 

  1104. 	

    1105. 

  1105. 	$rs = safe_rows('name, title','txp_section',$where . $sort);

    1106. 

  1106. 	

    1107. 

  1107. 	$items = array();

    1108. 

  1108. 	$values = array();

    1109. 

  1109. 	

    1110. 

  1110. 	if ($rs) {

    1111. 

  1111. 		foreach($rs as $r) {

    1112. 

  1112. 			$items[] = $r['title'];

    1113. 

  1113. 			$values[] = $r['name'];

    1114. 

  1114. 		}	

    1115. 

  1115. 	}

    1116. 

  1116. 	

    1117. 

  1117. 	unset($atts['exclude'], $atts['sort']);

    1118. 

  1118. 

    1119. 

  1119. 	$atts['items'] = join($delimiter, $items);

    1120. 

  1120. 	$atts['values'] = join($delimiter, $values);

    1121. 

  1121. 	

    1122. 

  1122. 	return mem_form_select($atts);

    1123. 

  1123. }

    1124. 

  1124. 

    1125. 

  1125. function mem_form_select_category($atts)

    1126. 

  1126. {

    1127. 

  1127. 	extract(mem_form_lAtts(array(

    1128. 

  1128. 		'root'	=> 'root',

    1129. 

  1129. 		'exclude'	=> '',

    1130. 

  1130. 		'delimiter'	=> ',',

    1131. 

  1131. 		'type'	=> 'article'

    1132. 

  1132. 	),$atts,false));

    1133. 

  1133. 	

    1134. 

  1134. 	$rs = getTree($root, $type);

    1135. 

  1135. 

    1136. 

  1136. 	if (!empty($exclude)) {

    1137. 

  1137. 		$exclusion = array_map('trim', explode($delimiter, preg_replace('/[\r\n\t\s]+/', ' ',$exclude)));

    1138. 

  1138. 		$exclusion = array_map('strtolower', $exclusion);

    1139. 

  1139. 	}

    1140. 

  1140. 	else

    1141. 

  1141. 		$exclusion = array();

    1142. 

  1142. 

    1143. 

  1143. 	$items = array();

    1144. 

  1144. 	$values = array();

    1145. 

  1145. 

    1146. 

  1146. 	if ($rs) {

    1147. 

  1147. 		foreach ($rs as $cat) {

    1148. 

  1148. 			if (count($exclusion) && in_array(strtolower($cat['name']), $exclusion))

    1149. 

  1149. 				continue;

    1150. 

  1150. 

    1151. 

  1151. 			$items[] = $cat['title'];

    1152. 

  1152. 			$values[] = $cat['name'];			

    1153. 

  1153. 		}

    1154. 

  1154. 	}

    1155. 

  1155. 	

    1156. 

  1156. 	unset($atts['root'], $atts['type']);

    1157. 

  1157. 	

    1158. 

  1158. 	$atts['items'] = join($delimiter, $items);

    1159. 

  1159. 	$atts['values'] = join($delimiter, $values);

    1160. 

  1160. 

    1161. 

  1161. 	return mem_form_select($atts);

    1162. 

  1162. }

    1163. 

  1163. 

    1164. 

  1164. function mem_form_select_range($atts)

    1165. 

  1165. {

    1166. 

  1166. 	global $mem_form_default_break;

    1167. 

  1167. 

    1168. 

  1168. 	$latts = mem_form_lAtts(array(

    1169. 

  1169. 		'start'		=> 0,

    1170. 

  1170. 		'stop'		=> false,

    1171. 

  1171. 		'step'		=> 1,

    1172. 

  1172. 		'name'		=> '',

    1173. 

  1173. 		'break'		=> $mem_form_default_break,

    1174. 

  1174. 		'delimiter'	=> ',',

    1175. 

  1175. 		'isError'	=> '',

    1176. 

  1176. 		'label'		=> mem_form_gTxt('option'),

    1177. 

  1177. 		'first'		=> FALSE,

    1178. 

  1178. 		'required'	=> 1,

    1179. 

  1179. 		'select_limit'	=> FALSE,

    1180. 

  1180. 		'as_csv'	=> FALSE,

    1181. 

  1181. 		'selected'	=> '',

    1182. 

  1182. 		'class'		=> 'memSelect',		

    1183. 

  1183. 	), $atts);

    1184. 

  1184. 

    1185. 

  1185. 	if ($stop === false)

    1186. 

  1186. 	{

    1187. 

  1187. 		trigger_error(gTxt('missing_required_attribute', array('{name}' => 'stop')), E_USER_ERROR);

    1188. 

  1188. 	}

    1189. 

  1189. 

    1190. 

  1190. 	$step = empty($latts['step']) ? 1 : assert_int($latts['step']);

    1191. 

  1191. 	$start= assert_int($latts['start']);

    1192. 

  1192. 	$stop = assert_int($latts['stop']);

    1193. 

  1193. 	

    1194. 

  1194. 	// fixup start/stop based upon step direction

    1195. 

  1195. 	$start = $step > 0 ? min($start, $stop) : max($start, $stop);

    1196. 

  1196. 	$stop = $step > 0 ? max($start, $stop) : min($start, $stop);

    1197. 

  1197. 

    1198. 

  1198. 	$values = array();

    1199. 

  1199. 	for($i=$start; $i >= $start && $i < $stop; $i += $step)

    1200. 

  1200. 	{

    1201. 

  1201. 		array_push($values, $i);		

    1202. 

  1202. 	}

    1203. 

  1203. 	

    1204. 

  1204. 	// intentional trample

    1205. 

  1205. 	$latts['items'] = $latts['values'] = implode($latts['delimiter'], $values);

    1206. 

  1206. 	

    1207. 

  1207. 	return mem_form_select($latts);

    1208. 

  1208. }

    1209. 

  1209. 

    1210. 

  1210. function mem_form_select($atts)

    1211. 

  1211. {

    1212. 

  1212. 	global $mem_form_error, $mem_form_submit, $mem_form_default, $mem_form_default_break;

    1213. 

  1213. 

    1214. 

  1214. 	extract(mem_form_lAtts(array(

    1215. 

  1215. 		'name'		=> '',

    1216. 

  1216. 		'break'		=> $mem_form_default_break,

    1217. 

  1217. 		'delimiter'	=> ',',

    1218. 

  1218. 		'isError'	=> '',

    1219. 

  1219. 		'label'		=> mem_form_gTxt('option'),

    1220. 

  1220. 		'items'		=> mem_form_gTxt('general_inquiry'),

    1221. 

  1221. 		'values'	=> '',

    1222. 

  1222. 		'first'		=> FALSE,

    1223. 

  1223. 		'required'	=> 1,

    1224. 

  1224. 		'select_limit'	=> FALSE,

    1225. 

  1225. 		'as_csv'	=> FALSE,

    1226. 

  1226. 		'selected'	=> '',

    1227. 

  1227. 		'class'		=> 'memSelect',

    1228. 

  1228. 	), $atts, false));

    1229. 

  1229. 

    1230. 

  1230. 	if (empty($name)) $name = mem_form_label2name($label);

    1231. 

  1231. 	

    1232. 

  1232. 	if (!empty($items) && $items[0] == '<') $items = parse($items);

    1233. 

  1233. 	if (!empty($values) && $values[0] == '<') $values = parse($values);

    1234. 

  1234. 	

    1235. 

  1235. 	if ($first !== FALSE) {

    1236. 

  1236. 		$items = $first.$delimiter.$atts['items'];

    1237. 

  1237. 		$values = $first.$delimiter.$atts['values'];

    1238. 

  1238. 	}

    1239. 

  1239. 	

    1240. 

  1240. 	$select_limit = empty($select_limit) ? 1 : assert_int($select_limit);

    1241. 

  1241. 

    1242. 

  1242. 	$items = array_map('trim', explode($delimiter, preg_replace('/[\r\n\t\s]+/', ' ',$items)));

    1243. 

  1243. 	$values = array_map('trim', explode($delimiter, preg_replace('/[\r\n\t\s]+/', ' ',$values)));

    1244. 

  1244. 	if ($select_limit > 1)

    1245. 

  1245. 	{

    1246. 

  1246. 		$selected = array_map('trim', explode($delimiter, preg_replace('/[\r\n\t\s]+/', ' ',$seelcted)));

    1247. 

  1247. 	}

    1248. 

  1248. 	else

    1249. 

  1249. 	{

    1250. 

  1250. 		$selected = array(trim($selected));

    1251. 

  1251. 	}

    1252. 

  1252. 

    1253. 

  1253. 	$use_values_array = (count($items) == count($values));

    1254. 

  1254. 

    1255. 

  1255. 	if ($mem_form_submit)

    1256. 

  1256. 	{

    1257. 

  1257. 		if (strpos($name, '[]'))

    1258. 

  1258. 		{

    1259. 

  1259. 			$value = ps(substr($name, 0, strlen($name)-2));

    1260. 

  1260. 

    1261. 

  1261. 			$selected = $value;

    1262. 

  1262. 

    1263. 

  1263. 			if ($as_csv)

    1264. 

  1264. 			{

    1265. 

  1265. 				$value = implode($delimiter, $value);

    1266. 

  1266. 			}

    1267. 

  1267. 		}

    1268. 

  1268. 		else

    1269. 

  1269. 		{

    1270. 

  1270. 			$value = trim(ps($name));

    1271. 

  1271. 			

    1272. 

  1272. 			$selected = array($value);

    1273. 

  1273. 		}

    1274. 

  1274. 

    1275. 

  1275. 		if (!empty($selected))

    1276. 

  1276. 		{

    1277. 

  1277. 			if (count($selected) <= $select_limit)

    1278. 

  1278. 			{

    1279. 

  1279. 				foreach ($selected as $v)

    1280. 

  1280. 				{

    1281. 

  1281. 					$is_valid = ($use_values_array && in_array($v, $values)) or (!$use_values_array && in_array($v, $items));

    1282. 

  1282. 					if (!$is_valid)

    1283. 

  1283. 					{

    1284. 

  1284. 						$invalid_value = $v;

    1285. 

  1285. 						break;

    1286. 

  1286. 					}

    1287. 

  1287. 				}

    1288. 

  1288. 

    1289. 

  1289. 				if ($is_valid)

    1290. 

  1290. 				{

    1291. 

  1291. 					$isError = false === mem_form_store($name, $label, $value);

    1292. 

  1292. 				}

    1293. 

  1293. 				else

    1294. 

  1294. 				{

    1295. 

  1295. 					$mem_form_error[] = mem_form_gTxt('invalid_value', array('{label}'=> htmlspecialchars($label), '{value}'=> htmlspecialchars($invalid_value)));

    1296. 

  1296. 					$isError = true;

    1297. 

  1297. 				}			

    1298. 

  1298. 			}

    1299. 

  1299. 			else

    1300. 

  1300. 			{

    1301. 

  1301. 				$mem_form_error[] = mem_form_gTxt('invalid_too_many_selected', array(

    1302. 

  1302. 											'{label}'=> htmlspecialchars($label),

    1303. 

  1303. 											'{count}'=> $select_limit,

    1304. 

  1304. 											'{plural}'=> ($select_limit==1 ? mem_form_gTxt('item') : mem_form_gTxt('items'))

    1305. 

  1305. 										));

    1306. 

  1306. 				$isError = true;

    1307. 

  1307. 			}

    1308. 

  1308. 		}

    1309. 

  1309. 

    1310. 

  1310. 		elseif ($required)

    1311. 

  1311. 		{

    1312. 

  1312. 			$mem_form_error[] = mem_form_gTxt('field_missing', array('{label}'=> htmlspecialchars($label)));

    1313. 

  1313. 			$isError = true;

    1314. 

  1314. 		}

    1315. 

  1315. 	}

    1316. 

  1316. 	else if (isset($mem_form_default[$name]))

    1317. 

  1317. 	{

    1318. 

  1318. 		$selected = array($mem_form_default[$name]);

    1319. 

  1319. 	}

    1320. 

  1320. 

    1321. 

  1321. 	$out = '';

    1322. 

  1322. 

    1323. 

  1323. 	foreach ($items as $item)

    1324. 

  1324. 	{

    1325. 

  1325. 		$v = $use_values_array ? array_shift($values) : $item;

    1326. 

  1326. 

    1327. 

  1327. 		$sel = !empty($selected) && in_array($v, $selected);

    1328. 

  1328. 

    1329. 

  1329. 		$out .= n.t.'<option'.($use_values_array ? ' value="'.$v.'"' : '').($sel ? ' selected="selected">' : '>').

    1330. 

  1330. 				(strlen($item) ? htmlspecialchars($item) : ' ').'</option>';

    1331. 

  1331. 	}

    1332. 

  1332. 

    1333. 

  1333. 	$isError = $isError ? 'errorElement' : '';

    1334. 

  1334. 	$memRequired = $required ? 'memRequired' : '';

    1335. 

  1335. 	$class = htmlspecialchars($class);

    1336. 

  1336. 

    1337. 

  1337. 	$multiple = $select_limit > 1 ? ' multiple="multiple"' : '';

    1338. 

  1338. 

    1339. 

  1339. 	return '<label for="'.$name.'" class="'.$class.' '.$memRequired.$isError.' '.$name.'">'.htmlspecialchars($label).'</label>'.$break.

    1340. 

  1340. 		n.'<select id="'.$name.'" name="'.$name.'" class="'.$class.' '.$memRequired.$isError.'"' . $multiple . '>'.

    1341. 

  1341. 			$out.

    1342. 

  1342. 		n.'</select>';

    1343. 

  1343. }

    1344. 

  1344. 

    1345. 

  1345. function mem_form_checkbox($atts)

    1346. 

  1346. {

    1347. 

  1347. 	global $mem_form_error, $mem_form_submit, $mem_form_default, $mem_form_default_break;

    1348. 

  1348. 

    1349. 

  1349. 	extract(mem_form_lAtts(array(

    1350. 

  1350. 		'break'		=> $mem_form_default_break,

    1351. 

  1351. 		'checked'	=> 0,

    1352. 

  1352. 		'isError'	=> '',

    1353. 

  1353. 		'label'		=> mem_form_gTxt('checkbox'),

    1354. 

  1354. 		'name'		=> '',

    1355. 

  1355. 		'class'		=> 'memCheckbox',

    1356. 

  1356. 		'required'	=> 1

    1357. 

  1357. 	), $atts));

    1358. 

  1358. 

    1359. 

  1359. 	if (empty($name)) $name = mem_form_label2name($label);

    1360. 

  1360. 

    1361. 

  1361. 	if ($mem_form_submit)

    1362. 

  1362. 	{

    1363. 

  1363. 		$value = (bool) ps($name);

    1364. 

  1364. 

    1365. 

  1365. 		if ($required and !$value)

    1366. 

  1366. 		{

    1367. 

  1367. 			$mem_form_error[] = mem_form_gTxt('field_missing', array('{label}'=> htmlspecialchars($label)));

    1368. 

  1368. 			$isError = true;

    1369. 

  1369. 		}

    1370. 

  1370. 

    1371. 

  1371. 		else

    1372. 

  1372. 		{

    1373. 

  1373. 			$isError = false === mem_form_store($name, $label, $value ? gTxt('yes') : gTxt('no'));

    1374. 

  1374. 		}

    1375. 

  1375. 	}

    1376. 

  1376. 

    1377. 

  1377. 	else {

    1378. 

  1378. 		if (isset($mem_form_default[$name]))

    1379. 

  1379. 			$value = $mem_form_default[$name];

    1380. 

  1380. 		else

    1381. 

  1381. 			$value = $checked;

    1382. 

  1382. 	}

    1383. 

  1383. 

    1384. 

  1384. 	$isError = $isError ? 'errorElement' : '';

    1385. 

  1385. 	$memRequired = $required ? 'memRequired' : '';

    1386. 

  1386. 	$class = htmlspecialchars($class);

    1387. 

  1387. 

    1388. 

  1388. 	return '<input type="checkbox" id="'.$name.'" class="'.$class.' '.$memRequired.$isError.'" name="'.$name.'"'.

    1389. 

  1389. 		($value ? ' checked="checked"' …
    1390.

Large files files are truncated, but you can click here to view the full file