<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE module [
  <!ELEMENT module (dtdversion,name,version,description*,help*,about*,requires*,file+)>
  <!ELEMENT dtdversion (#PCDATA)>
  <!ELEMENT name (#PCDATA)>
  <!ELEMENT version (#PCDATA)>
  <!ELEMENT mincmsversion (#PCDATA)>
  <!ELEMENT description (#PCDATA)>
  <!ELEMENT help (#PCDATA)>
  <!ELEMENT about (#PCDATA)>
  <!ELEMENT requires (requiredname,requiredversion)>
  <!ELEMENT requiredname (#PCDATA)>
  <!ELEMENT requiredversion (#PCDATA)>
  <!ELEMENT file (filename,isdir,data)>
  <!ELEMENT filename (#PCDATA)>
  <!ELEMENT isdir (#PCDATA)>
  <!ELEMENT data (#PCDATA)>
]>
<module>
	<dtdversion>1.3</dtdversion>
	<name>FormBuilder</name>
	<version>0.5.5</version>
  <mincmsversion>1.1</mincmsversion>
	<help><h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create feedback forms (in fact, it's a replacement of the original Feedback Form module), with the added power of database storage. With its companion module Form Browser, you can use it to create simple database applications.</p>
<p>The forms created using the Form Builder may be inserted
into templates and/or content pages. Forms may contain many kinds of inputs, and may have
validation applied to these inputs. The results of these forms may be handled in a variety of ways.</p>

<h3>How Do I Use it?</h3>
<P>Install it, and poke around the menus. Play with it. Try creating forms, and adding them to your content.
If you get stuck, chat with me on the #cms IRC channel, post to the forum, send me email, or, if you're
really desperate, try reading the instructions on the rest of this page.</P>

<h3>How Do I Create a Form</h3>
<p>In the CMS Admin Menu, you should get a new menu item called FormBuilder. Click on this. On the page
that gets shown, there are options (at the bottom of the list of Forms) to Add a New Form or Modify
Configuration.</p>

<h3>Adding a Form to a Page</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module='FormBuilder' form='sample_form'}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page's content if you use a WYSIWYG editor such as TinyMCE, FCKEdit, or HTMLArea. These editors may stealthily
change the quote marks (") into HTML entities (&amp;quot;), and the forms will not show up. Try using
single quotes (') or editing the HTML directly.</p>

<h3>Working with Forms</h3>
<p>By clicking on a Form's name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you'll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing.</p>
<p>Below this, if you have it enabled, is the "fast field adder" pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Form Submission</h4>
<p>When the form is submitted, you can either redirect the user to another page of your site, or you can present the user some message (which can contain any of the user's form entries, or just static text). In this tab, you select which of these approaches you wish to use, and, if you chose redirection, it allows you to pick the page to redirect users to after a successful form submission.</p>
<p>Also on this page, you can specify the labels of various submission buttons ("Previous", "next", "submit"). You can also opt to have some Javascript added to the last page of a form that will prevent multiple submissions (useful on slow servers).</p>
<h4>Form Display Options</h4>
<p>This tab allows for other form customizations, like the symbol to show for required fields.</p>
<h4>Captcha Settings</h4>
<p>If you have installed the Captcha module, this tab lets you configure the Captcha settings for your form.</p>
<h4>Form Template</h4>
<p>This is where you do your customization work of your form's Smarty Template. See the section called Form Template Variables below.</p>
<p>The form should default to a Custom template that documents the Smarty tags available to you.</p>
<p>Unless you're a Smarty expert, you probably don't want to mess around with this. If you are a Smarty expert, this is where you can unleash your magic.</p>
<h4>Submission Template</h4>
<p>If, in the Form Submission tab, you selected 'Display "Submission Template", this is where you can create that template. There is a display of which smarty variables are available to you, and a button to generate a sample template.</p>
<p>If you're a Smarty expert, you can do all manner of creative and powerful things here. If you're not a Smarty expert, you might just want to use the default.
</p>

<h3>Adding Fields to your Form</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it's submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it's safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked "Required", which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to "view source" on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It's really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It's really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Canadian Province. This is a pulldown listing the Canadian Provinces (Contributed by Noel McGran. Thanks!)</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
<li>Time Picker. This is a set of pulldowns allowing the user to select a time (using 12 or 24 hour clock).</li>
<li>File Upload. This is a file upload field.</li>
<li>Link (User Entered). This creates a double input field for getting a link URL and link title.</li>
<li>Text Field (Multiple). This field creates one or more text inputs with add and delete buttons, effectively giving the end user a way of creating variable-length lists.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the "From" field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the "From" field.</li>
<li>Email Subject Field. This allows users to provide a subject for their email. The email generated when the form gets handled will use this in the "Subject" field. This may cause trouble with certain dispositions that want to control the Email Subject, so use it with caution.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Fieldset Start. Combined with Fieldset End, this allows you to group various fields within your form. Use this to start a given grouping.</li>
<li>-Fieldset End. Combined with Fieldset Start, this allows you to group various fields within your form. Use this to end a given grouping.</li>
<li>-Hidden Field. This allows you to embed a hidden field in your form.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you're not using a Custom Template to render your form.</li>
<li>-Static Link. This allows you to put a link to a given page into your form. Optionally, you can have it autopopulate with the page where the form is embedded (useful if you're sending results via email).</li>
<li>-Computed Field. This allows you to embed a computed field in your form. It is not visible to the user until after the form is submitted. It allows you to do simple arithmetic or string concatenation.</li>
<li>-Unique Integer (Serial). This is an integer that increases every time someone hits your form. Your results may not be sequential, but they will increase monotonically.</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<ul><li>*Call a User Defined Tag With the Form Results. This submits all the form results to the User-Defined Tag you specify. The UDT can handle the results however it wants. Values are passed as $param['field_name'].</li>
<li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these "Director" pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email to User-Supplied Address. This puts an input field in the form for the user to populate with an email address. The form results get sent to that address. Beware of Spam abuse! Active the primitive anti-spam features in the FormBuilder configuration screen.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Redirect to Page Based on Pulldown. This allows you to redirect the form to a different site page depending on its value. If you have multiple dispositions, make sure this is used last.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered "approved," and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the "output" directory under the
module's installation directory, assuming the web server has permission to write there.</li>
<li>*Save Results to File Based on Pulldown. Like the Flat File disposition, except the value of a pull-down determines which file results get written to.</li>
<li>*Save Results to File(s) Based on Multiple Selections. Like the Flat File disposition, except the value(s) of checkboxes  determines which file(s) results get written to.</li>
<li>*Email to CMS Admin User. Provides a pull-down of CMS Admin users, and directs the results as an email to the selected admin.</li>
<li>*Store Results for FormBrowser Module v.3. Stores the form results in an XML structure as a single database record. This will become the interface to Form Browser in the next release.</li>

</ul></li></li></ul>


<h3>Passing Default Values to Forms</h3>
<p>Calguy added a nice feature, which is that you can pass default field values to your form via the module tag. This allows you to have
the same form in multiple places, but with different default values. It may not work for more exotic field types, but for fields that have
a single value, you can specify like:</p>
<p>{cms_module module='FormBuilder' form='my_form' value_<i>FIELDNAME</i>='default_value'}</p>
<p>This will set the field with <i>FIELDNAME</i> to 'default_value'.</p>
<p>This can be problematic, as sometimes field names are unweildy or contain characters that don't work well with Smarty. So there is an
alternative like this:</p>
<p>{cms_module module='FormBuilder' form='my_form' value_fld<i>NUMBER</i>='default_value'}</p>
<p>That uses field <i>NUMBER</i>, where <i>NUMBER</i> is the internal FormBuilder field id. You might wonder how you know what that id is. Simply go into the FormBuilder configuration tab,
and check "Show Field IDs"</p>

<h3>Email and Flat File Templates</h3>
<p>Many disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it's own best guess, which may or may not work out to your liking. You can always click on the "Create Sample Template" and then customize the results.</p>
<p>To the right, you'll find a legend which lists all of the variables that are available to you to use in your template. As of version 0.3, variables have two names, one based on the field name, the other based on the field ID. If you use field names that have characters outside of the ASCII 32-126 range, it will be safer to use the ID-based variables.</p>
<p><strong>Note that once you've changed a template, it will no longer automatically add new fields.</strong> For this reason, it's usually best to create your templates as the last step of creating your form.</p>
<p>As of version 0.2.4, you can opt to send any of these emails as HTML email. There should be a checkbox at the top of the template page for this. There is also a "Create Sample HTML Template" button over in the legend area. For HTML email, the email body will also provide the default text-only values.</p>

<h3>Configuration</h3>
<p>There are some global configuration options for FormBuilder:</p>
<ul>
<li>Enable fast field add pulldown. This enables the pulldown on the Form Edit page which saves a step in the creation of new fields.</li>
<li>Hide Errors. This is set by default. Unchecking it will cause more detailed errors to be displayed if there are problems when you submit your form.</li>
<li>Require Field Names. Typically, you will want form fields to be named so you can tell which is which. However, in some cases, you might want to have nameless fields. Uncheck this if you want to allow nameless fields.</li>
<li>Unique Field Names. Typically, you will want form fields to have unique names so you can tell which is which. Uncheck this if you want to allow fields to share names.</li>
<li>Use relaxed email validation. This uses a less restrictive regular expression for validating email; e.g., x@y will be allowed, where typically x@y.tld is required.</li>
<li>Show Form Builder Version. Displays the version of FormBuilder you're using in a comment when the form is generated. Typically only useful when debugging.</li>
<li>Enable primitive anti-spam features. When turned on, this allows any given IP address to only generate 10 emails per hour.</li>
<li>Show Field IDs. When turned on, FormBuilder will display field ids when adding or editing a form.</li>
</ul>
<h3>Styling and CSS</h3>
<p>Paul Noone graciously provides us all with a pretty good standard CSS that you can use for forms:</p>
<pre>
	/* Sample FormBuilder CSS base */
	form {margin-top:0}
	form, td, th, li { font-size: 100%}
	form div {margin-bottom:0}
	fieldset div {
		margin-bottom:0.5em;
		margin-left:1em;
	}
	fieldset div div {
		margin-top:0.5em;
		margin-left:1em
	}
	fieldset {
		margin-bottom:1em;
		border:1px solid #F60;
		padding:0.5em
	}
	fieldset label {
		width:auto;
	}
	legend {
		color:#FFF;
		background:#F60;
		font-style:italic;
		font-size:1.2em;
		margin-bottom:0.5em;
		padding:0.2em;
		width:auto;
		border:1px solid #CCC
	}
	textarea {
		margin: 0.5em 0;
		width:98%;
		height: 6em
	}

	/* Apply this class to text/select input fields with shorter labels
		to help alignment */
	.short-label label {float:left; width:10em}
	.short-label fieldset div input,
	.short-label fieldset div select {width:16em}

	/* Pretty up your Captcha image output */
	.captcha {
		margin:0.5em 0;
		width:200px;
		text-align:center
	}
	.captcha img {border:1px solid #F60; margin-bottom:0.5em}
	.captcha input {width:196px; margin-top:0.5em}

	/* Just a bit more room for the Submit button */
	.submit {margin-top:0.5em}
</pre>

<h3>Form Template Variables</h3>

<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you'd like.
   To make the form work, you'll need to always include the &#123;$fb_hidden} and &#123;$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., &#123;$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that's the way you swing)</td></tr>
<tr><td>field->name</td><td>the field's name</td></tr>
<tr><td>field->input</td><td>the field's input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field's input (useful for label for="foo")</td></tr>
<tr><td>field->type</td><td>the field's data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays "page x of y" for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>"Back" button for multipart forms</td></tr>
<tr><td>submit</td><td>"Continue" or "Submit" button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you'd want some of those, but there you go...</p>


<h3>Known Issues</h3>
<ul>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn't matter since the user side is pretty simple.</li>
<li>FileUpload Fields may not work correctly with multipage forms.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you're running CMS 1.1 or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you're missing fields in an email that gets generated, check the disposition field's template, and make sure you're specifying the missing fields. Seems obvious, but it's an easy mistake to make.</li>
<li>Uncheck the "Hide Errors" checkbox in the global options, and see what message gets displayed when you submit your form.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is no longer a particularly early version, but it is probably still buggy. While I've done all I can
to make sure no egregious bugs have crept in, I have to admit that during early testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor's nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href="mailto:sjg@cmsmodules.com">&lt;sjg@cmsmodules.com&gt;</a>.</li>
<li>Additional discussion of this module may also be found in the <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
<li>Donations are good motivators, too. Keep in mind that the dollar is weak, and if you are not in the US, your donation gets magnified.</li>
</ul>
<p>Keep in mind that the author has put hundreds and hundreds of hours into the development of this module. Please take the time to read the documentation before sending questions. Either that, or send your questions written on financially negotiable instruments (i.e., checks or cash). Am I sounding like a broken record? Do you kids these days even know what a broken record is? I would say skipping CD, but you might not know what that is either. Like a sample that got stuck on loop? Damn, I am getting old. So is this paragraph. Time to move on, here.</p>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2008, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com">&lt;sjg@cmsmodules.com&gt;</a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>. You must agree to this license before using the module.</p><h3>Dependencies</h3><ul><li>CMSMailer =&gt; 1.73</li></ul><h3>Parameters</h3><ul><li><em>(optional)</em> lang="en_US" - Parameter is used to specify what language to use for display on the frontend. Not all modules support or need this.</li><li><em>(optional)</em> fbrp_*="null" - General parameters for internal operations</li><li><em>(optional)</em> form_id="null" - Form ID for internal operations</li><li><em>(optional)</em> form="null" - Form Name</li><li><em>(optional)</em> field_id="null" - Field ID for internal operations</li><li><em>(optional)</em> value_*="null" - Default field values; see module help</li><li><em>(optional)</em> response_id="null" - Response ID. Used by FormBrowser</li></ul></help>
	<about>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</about>
	<description>Add, edit and manage interactive Forms</description>
	<requires>
	  <requiredname>CMSMailer</requiredname>
	  <requiredversion>1.73</requiredversion>
	</requires>
	<file>
	  <filename>/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/action.admin_add_edit_field.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.admin_add_edit_form.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCmlmICghaXNzZXQoJGdDbXMpKSBleGl0OwppZiAoISAkdGhpcy0+Q2hlY2tBY2Nlc3MoKSkgZXhpdDsKCgkJaWYgKGlzc2V0KCRwYXJhbXNbJ2ZicnBfc2V0X2ZpZWxkX2xldmVsJ10pKQoJCQl7CgkJCSR0aGlzLT5TZXRQcmVmZXJlbmNlKCdzaG93X2ZpZWxkX2xldmVsJywkcGFyYW1zWydmYnJwX3NldF9maWVsZF9sZXZlbCddKTsKCQkJfQoJCSRhZWZvcm0gPSBuZXcgZmJGb3JtKCR0aGlzLCAkcGFyYW1zLCB0cnVlKTsKCQllY2hvICRhZWZvcm0tPkFkZEVkaXRGb3JtKCRpZCwgJHJldHVybmlkLCBpc3NldCgkcGFyYW1zWydmYnJwX21lc3NhZ2UnXSk/JHRoaXMtPlNob3dNZXNzYWdlKCRwYXJhbXNbJ2ZicnBfbWVzc2FnZSddKTonJyk7Cgo/Pg==]]></data>
	</file>
	<file>
	  <filename>/action.admin_delete_field.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCmlmICghaXNzZXQoJGdDbXMpKSBleGl0OwppZiAoISAkdGhpcy0+Q2hlY2tBY2Nlc3MoKSkgZXhpdDsKCiAgICAgICAgJGFlZm9ybSA9IG5ldyBmYkZvcm0oJHRoaXMsICRwYXJhbXMsIHRydWUpOwogICAgICAgICRhZWZvcm0tPkRlbGV0ZUZpZWxkKCRwYXJhbXNbJ2ZpZWxkX2lkJ10pOwoJCWVjaG8gJGFlZm9ybS0+QWRkRWRpdEZvcm0oJGlkLCAkcmV0dXJuaWQsICR0aGlzLT5MYW5nKCdmaWVsZF9kZWxldGVkJykpOwo/PgoK]]></data>
	</file>
	<file>
	  <filename>/action.admin_delete_form.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCmlmICghaXNzZXQoJGdDbXMpKSBleGl0OwppZiAoISAkdGhpcy0+Q2hlY2tBY2Nlc3MoKSkgZXhpdDsKCiAgICAgICAgJGFlZm9ybSA9IG5ldyBmYkZvcm0oJHRoaXMsICRwYXJhbXMsIHRydWUpOwogICAgICAgICRhZWZvcm0tPkRlbGV0ZSgpOwoKICAgICAgICAkcGFyYW1zWydmYnJwX21lc3NhZ2UnXSA9ICR0aGlzLT5MYW5nKCdmb3JtX2RlbGV0ZWQnKTsKICAgICAgICAkdGhpcy0+RG9BY3Rpb24oJ2RlZmF1bHRhZG1pbicsICRpZCwgJHBhcmFtcyk7Cj8+]]></data>
	</file>
	<file>
	  <filename>/action.admin_get_template.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKaWYgKCFpc3NldCgkZ0NtcykpIGV4aXQ7CgppZiAocHJlZ19tYXRjaCgnL1wudHBsJC8nLCRwYXJhbXNbJ2ZicnBfdGlkJ10pKQogICAgewogICAgJHRwbHN0ciA9IGZpbGVfZ2V0X2NvbnRlbnRzKGRpcm5hbWUoX19GSUxFX18pLicvdGVtcGxhdGVzLycuJHBhcmFtc1snZmJycF90aWQnXSk7CiAgICB9CmVsc2UKICAgIHsKICAgICRkYiA9ICYkZ0Ntcy0+R2V0RGIoKTsKICAgICRxdWVyeSA9ICJTRUxFQ1QgdmFsdWUgRlJPTSAiLmNtc19kYl9wcmVmaXgoKS4KCQkibW9kdWxlX2ZiX2Zvcm1fYXR0ciBXSEVSRSBmb3JtX2lkPT8gYW5kIG5hbWU9J2Zvcm1fdGVtcGxhdGUnIjsKCSRkYnJlc3VsdCA9ICRkYi0+RXhlY3V0ZSgkcXVlcnksYXJyYXkoJHBhcmFtc1snZmJycF90aWQnXSkpOwoJaWYgKCRkYnJlc3VsdCAhPT0gZmFsc2UgJiYgJHJvdyA9ICRkYnJlc3VsdC0+RmV0Y2hSb3coKSkKCQl7CgkJJHRwbHN0ciA9ICRyb3dbJ3ZhbHVlJ107CgkJfQogICAgfQoKICAgIEBvYl9jbGVhbigpOwogICAgQG9iX2NsZWFuKCk7CiAgICBoZWFkZXIoJ1ByYWdtYTogcHVibGljJyk7CiAgICBoZWFkZXIoJ0V4cGlyZXM6IDAnKTsKICAgIGhlYWRlcignQ2FjaGUtQ29udHJvbDogbXVzdC1yZXZhbGlkYXRlLCBwb3N0LWNoZWNrPTAsIHByZS1jaGVjaz0wJyk7CiAgICBoZWFkZXIoJ0NhY2hlLUNvbnRyb2w6IHByaXZhdGUnLGZhbHNlKTsKICAgIGhlYWRlcignQ29udGVudC1EZXNjcmlwdGlvbjogRmlsZSBUcmFuc2ZlcicpOwogICAgaGVhZGVyKCdDb250ZW50LUxlbmd0aDogJyAuIHN0cmxlbigkdHBsc3RyKSk7CiAgICBlY2hvICR0cGxzdHI7CiAgICBleGl0Owo/Pg==]]></data>
	</file>
	<file>
	  <filename>/action.admin_reorder_form.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCmlmICghaXNzZXQoJGdDbXMpKSBleGl0OwppZiAoISAkdGhpcy0+Q2hlY2tBY2Nlc3MoKSkgZXhpdDsKCgokYWVmb3JtID0gbmV3IGZiRm9ybSgkdGhpcywgJHBhcmFtcywgdHJ1ZSk7CgokZmllbGRzID0gYXJyYXkoKTsKZm9yZWFjaCAoJGFlZm9ybS0+R2V0RmllbGRzKCkgYXMgJHRoaXNGaWVsZCkKICAgewogICAkZmxkID0gbmV3IFN0ZENsYXNzKCk7CiAgICRmbGQtPmlkID0gJ2ZicnBfJy4kdGhpc0ZpZWxkLT5HZXRJZCgpOwogICAkZmxkLT5uYW1lID0gJHRoaXNGaWVsZC0+R2V0TmFtZSgpOwogICAkZmxkLT50eXBlID0gJHRoaXNGaWVsZC0+R2V0RmllbGRUeXBlKCk7CiAgIGFycmF5X3B1c2goJGZpZWxkcywgJGZsZCk7CiAgIH0KCiR0aGlzLT5zbWFydHktPmFzc2lnbignc3RhcnRfZm9ybScsJHRoaXMtPkNyZWF0ZUZvcm1TdGFydCgkaWQsCgkJCSdhZG1pbl9yZW9yZGVyX3N0b3JlJywgJHJldHVybmlkLCAncG9zdCcpKTsKJHRoaXMtPnNtYXJ0eS0+YXNzaWduKCdzdWJtaXQnLCAkdGhpcy0+Q3JlYXRlSW5wdXRTdWJtaXQoJGlkLCAnZmJycF9zdWJtaXQnLCAkdGhpcy0+TGFuZygncmVvcmRlcicpLCdvbmNsaWNrPSJyZXR1cm4gc2VuZF9vcmRlcl92YXIoKSInKSk7CiR0aGlzLT5zbWFydHktPmFzc2lnbignZW5kX2Zvcm0nLCR0aGlzLT5DcmVhdGVGb3JtRW5kKCkpOwokdGhpcy0+c21hcnR5LT5hc3NpZ24oJ2lkJywkaWQpOwokdGhpcy0+c21hcnR5LT5hc3NpZ24oJ2ZiX2hpZGRlbicsJHRoaXMtPkNyZWF0ZUlucHV0SGlkZGVuKCRpZCwnZm9ybV9pZCcsJHBhcmFtc1snZm9ybV9pZCddKSk7CiR0aGlzLT5zbWFydHktPmFzc2lnbl9ieV9yZWYoJ2ZpZWxkcycsJGZpZWxkcyk7CiR0aGlzLT5zbWFydHktPmFzc2lnbignc2NyaXB0YWN1bG91cycsCiAgICc8c2NyaXB0IHNyYz0iJy5kaXJuYW1lKGRpcm5hbWUoZGlybmFtZShfX0ZJTEVfXykpKS4KICAgJy9saWIvc2NyaXB0YWN1bG91cy9zY3JpcHRhY3Vsb3VzLmpzIiB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPjwvc2NyaXB0PicpOwoKZWNobyAkdGhpcy0+UHJvY2Vzc1RlbXBsYXRlKCdSZW9yZGVyRm9ybS50cGwnKTsKPz4=]]></data>
	</file>
	<file>
	  <filename>/action.admin_reorder_store.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCmlmICghaXNzZXQoJGdDbXMpKSBleGl0OwppZiAoISAkdGhpcy0+Q2hlY2tBY2Nlc3MoKSkgZXhpdDsKCiRvcmRlcl9saXN0ID0gZXhwbG9kZSgnLCcsJHBhcmFtc1snZmJycF9vcmRlciddKTsKJGNvdW50ID0gMTsKLy9kZWJ1Z19kaXNwbGF5KCRwYXJhbXNbJ2ZicnBfb3JkZXInXSk7CmlmICghIGlzX2FycmF5KCRvcmRlcl9saXN0KSkKCXsKCSRvcmRlcl9saXN0ID0gYXJyYXkoJG9yZGVyX2xpc3QpOwoJfQoKJGRiID0mICRnQ21zLT5HZXREYigpOwokc3FsID0gJ3VwZGF0ZSAnLmNtc19kYl9wcmVmaXgoKS4KCSdtb2R1bGVfZmJfZmllbGQgc2V0IG9yZGVyX2J5PT8gd2hlcmUgZmllbGRfaWQ9Pyc7CgkKZm9yZWFjaCAoJG9yZGVyX2xpc3QgYXMgJHRoaXNGaWVsZCkKCXsKCSRmbGRpZCA9IHN1YnN0cigkdGhpc0ZpZWxkLHN0cnBvcygkdGhpc0ZpZWxkLCdfJykrMSk7CgkkcnMgPSAkZGItPkV4ZWN1dGUoJHNxbCwgYXJyYXkoJGNvdW50LCAkZmxkaWQpKTsKCSRjb3VudCsrOwoJfQoKJGFlZm9ybSA9IG5ldyBmYkZvcm0oJHRoaXMsICRwYXJhbXMsIHRydWUpOwoKZWNobyAkYWVmb3JtLT5BZGRFZGl0Rm9ybSgkaWQsICRyZXR1cm5pZCwgJHRoaXMtPkxhbmcoJ2ZpZWxkX29yZGVyX3VwZGF0ZWQnKSk7Cj8+]]></data>
	</file>
	<file>
	  <filename>/action.admin_store_field.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCmlmICghaXNzZXQoJGdDbXMpKSBleGl0OwppZiAoISAkdGhpcy0+Q2hlY2tBY2Nlc3MoKSkgZXhpdDsKCiRhZWZvcm0gPSBuZXcgZmJGb3JtKCR0aGlzLCAkcGFyYW1zLCB0cnVlKTsKJGFlZmllbGQgPSAkYWVmb3JtLT5OZXdGaWVsZCgkcGFyYW1zKTsKJHZhbCA9ICRhZWZpZWxkLT5BZG1pblZhbGlkYXRlKCk7CmlmICgkdmFsWzBdKQogIHsKICAgICRhZWZpZWxkLT5Qb3N0QWRtaW5TdWJtaXRDbGVhbnVwKCk7CiAgICAkYWVmaWVsZC0+U3RvcmUodHJ1ZSk7CiAgICAkcGFyYW1zWydmYnJwX21lc3NhZ2UnXT0kcGFyYW1zWydmYnJwX29wJ107CiAgICAkdGhpcy0+RG9BY3Rpb24oJ2FkbWluX2FkZF9lZGl0X2Zvcm0nLCAkaWQsICRwYXJhbXMpOwogIH0KIGVsc2UKICAgewogICAgICRhZWZpZWxkLT5Mb2FkRmllbGQoJHBhcmFtcyk7CiAgICAgJHBhcmFtc1snZmJycF9tZXNzYWdlJ10gPSAkdmFsWzFdOwogICAgIGVjaG8gJGFlZm9ybS0+QWRkRWRpdEZpZWxkKCRpZCwgJGFlZmllbGQsIChpc3NldCgkcGFyYW1zWydmYnJwX2Rpc3Bvc2Vfb25seSddKT8kcGFyYW1zWydmYnJwX2Rpc3Bvc2Vfb25seSddOjApLCAkcmV0dXJuaWQsIGlzc2V0KCRwYXJhbXNbJ2ZicnBfbWVzc2FnZSddKT8kcGFyYW1zWydmYnJwX21lc3NhZ2UnXTonJyk7CiAgIH0KCj8+Cg==]]></data>
	</file>
	<file>
	  <filename>/action.admin_store_form.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCmlmICghaXNzZXQoJGdDbXMpKSBleGl0OwppZiAoISAkdGhpcy0+Q2hlY2tBY2Nlc3MoKSkgZXhpdDsKCiAgICAgICAgJGFlZm9ybSA9IG5ldyBmYkZvcm0oJHRoaXMsICRwYXJhbXMsIHRydWUpOwogICAgICAgICRhZWZvcm0tPlN0b3JlKCk7CiAgICAgICAgaWYgKCRwYXJhbXNbJ2ZicnBfc3VibWl0J10gPT0gJHRoaXMtPkxhbmcoJ3NhdmUnKSkKICAgICAgICAgICAgewogICAgICAgICAgICAkcGFyYW1zWydmYnJwX21lc3NhZ2UnXSA9ICR0aGlzLT5MYW5nKCdmb3JtJywkcGFyYW1zWydmYnJwX2Zvcm1fb3AnXSk7CiAgICAgICAgICAgICR0aGlzLT5Eb0FjdGlvbignZGVmYXVsdGFkbWluJywgJGlkLCAkcGFyYW1zKTsKICAgICAgICAgICAgfQogICAgICAgIGVsc2UKICAgICAgICAJewoJCQllY2hvICRhZWZvcm0tPkFkZEVkaXRGb3JtKCRpZCwgJHJldHVybmlkLCR0aGlzLT5MYW5nKCdmb3JtJywkcGFyYW1zWydmYnJwX2Zvcm1fb3AnXSkpOwoJCQl9Cj8+Cg==]]></data>
	</file>
	<file>
	  <filename>/action.admin_update_config.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.admin_update_field_order.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCmlmICghaXNzZXQoJGdDbXMpKSBleGl0OwppZiAoISAkdGhpcy0+Q2hlY2tBY2Nlc3MoKSkgZXhpdDsKCiAgICAgICAgJGFlZm9ybSA9IG5ldyBmYkZvcm0oJHRoaXMsICRwYXJhbXMsIHRydWUpOwogICAgICAgICRzcmNJbmRleCA9ICRhZWZvcm0tPkdldEZpZWxkSW5kZXhGcm9tSWQoJHBhcmFtc1snZmllbGRfaWQnXSk7CiAgICAgICAgaWYgKCRwYXJhbXNbJ2ZicnBfZGlyJ10gPT0gJ3VwJykKICAgICAgICAgICAgewogICAgICAgICAgICAkZGVzdEluZGV4ID0gJHNyY0luZGV4IC0gMTsKICAgICAgICAgICAgfQogICAgICAgIGVsc2UKICAgICAgICAgICAgewogICAgICAgICAgICAkZGVzdEluZGV4ID0gJHNyY0luZGV4ICsgMTsKICAgICAgICAgICAgfQogICAgICAgICRhZWZvcm0tPlN3YXBGaWVsZHNCeUluZGV4KCRzcmNJbmRleCwkZGVzdEluZGV4KTsKCi8vIGZvcmNlIHJlbG9hZCBvZiBmb3JtLCB0aGlzIGlzIGtpbmRhIGhhY2tpc2ggYnV0IGNhbnQgdGhpbmsgb2YgYW55dGhpbmcgZWxzZSA7KQokYWVmb3JtID0gbmV3IGZiRm9ybSgkdGhpcywgJHBhcmFtcywgdHJ1ZSk7CgoKICAgICAgICBlY2hvICRhZWZvcm0tPkFkZEVkaXRGb3JtKCRpZCwgJHJldHVybmlkLCAkdGhpcy0+U2hvd01lc3NhZ2UoJHRoaXMtPkxhbmcoJ2ZpZWxkX29yZGVyX3VwZGF0ZWQnKSkpOwo/Pg==]]></data>
	</file>
	<file>
	  <filename>/action.admin_update_field_required.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCmlmICghaXNzZXQoJGdDbXMpKSBleGl0OwppZiAoISAkdGhpcy0+Q2hlY2tBY2Nlc3MoKSkgZXhpdDsKCiAgICAgICAgJGFlZm9ybSA9IG5ldyBmYkZvcm0oJHRoaXMsICRwYXJhbXMsIHRydWUpOwogICAgICAgIAogICAgICAgICRhZWZpZWxkID0gJGFlZm9ybS0+R2V0RmllbGRCeUlkKCRwYXJhbXNbJ2ZpZWxkX2lkJ10pOwoJCWlmICgkYWVmaWVsZCAhPT0gZmFsc2UpCgkJCXsKCQkJLy8kYWVmaWVsZC0+U2V0UmVxdWlyZWQoJHBhcmFtc1snZmJycF9hY3RpdmUnXT09J29uJz90cnVlOmZhbHNlKTsKCQkJJGFlZmllbGQtPlRvZ2dsZVJlcXVpcmVkKCk7CgkJCSRhZWZpZWxkLT5TdG9yZSgpOwogICAgICAgICAkYWVmb3JtID0gbmV3IGZiRm9ybSgkdGhpcywgJHBhcmFtcywgdHJ1ZSk7CgkJCX0KCQllY2hvICRhZWZvcm0tPkFkZEVkaXRGb3JtKCRpZCwgJHJldHVybmlkLCAkdGhpcy0+TGFuZygnZmllbGRfcmVxdWlyZW1lbnRfdXBkYXRlZCcpKTsKPz4=]]></data>
	</file>
	<file>
	  <filename>/action.default.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.defaultadmin.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/* 
   FormBuilder. Copyright (c) 2005-2007 Samuel Goldstein <sjg@cmsmodules.com>
   More info at http://dev.cmsmadesimple.org/projects/formbuilder
   
   A Module for CMS Made Simple, Copyright (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
  This project's homepage is: http://www.cmsmadesimple.org
*/
if (!isset($gCms)) exit;

		// and a list of all the extant forms.
        $forms = $this->GetForms();
		$num_forms = count($forms);
        
        $this->smarty->assign('tabheaders', $this->StartTabHeaders() .
			$this->SetTabHeader('forms',$this->Lang('forms')) .
			$this->SetTabHeader('config',$this->Lang('configuration')) .
			$this->EndTabHeaders().
			$this->StartTabContent());
		$this->smarty->assign('start_formtab',$this->StartTab("forms"));
		$this->smarty->assign('start_configtab',$this->StartTab("config"));
		$this->smarty->assign('end_tab',$this->EndTab());
		$this->smarty->assign('end_tabs',$this->EndTabContent());
		$this->smarty->assign('title_form_name',$this->Lang('title_form_name'));
        $this->smarty->assign('title_form_alias',$this->Lang('title_form_alias'));
        $this->smarty->assign('start_configform',$this->CreateFormStart($id,
			'admin_update_config', $returnid));
        $this->smarty->assign('message', isset($params['fbrp_message'])?$params['fbrp_message']:'');

		$formArray = array();
		$currow = "row1";
		foreach ($forms as $thisForm)
    		{
			$oneset = new stdClass();
			$oneset->rowclass = $currow;
			if ($this->CheckPermission('Modify Forms'))
				{
				$oneset->name = $this->CreateLink($id,
				 	'admin_add_edit_form', '',
            		$thisForm['name'], array('form_id'=>$thisForm['form_id']));
				$oneset->xml = $this->CreateLink($id,'exportxml','',"<img src=\"".$gCms->config['root_url']."/images/cms/xml_rss.gif\" class=\"systemicon\" alt=\"Export Form as XML\" />",array('form_id'=>$thisForm['form_id']));
				$oneset->editlink = $this->CreateLink($id,
					'admin_add_edit_form', '',
					$gCms->variables['admintheme']->DisplayImage('icons/system/edit.gif',$this->Lang('edit'),'','','systemicon'),
						array('form_id'=>$thisForm['form_id']));
				$oneset->deletelink = $this->CreateLink($id,
					'admin_delete_form', '',
					$gCms->variables['admintheme']->DisplayImage('icons/system/delete.gif',$this->Lang('delete'),'','','systemicon'),
					array('form_id'=>$thisForm['form_id']),
					$this->Lang('are_you_sure_delete_form',$thisForm['name']));

				}
			else
				{
				$oneset->name=$thisForm['name'];
				$oneset->editlink = '';
				$oneset->deletelink = '';
				}
			$oneset->usage = $thisForm['alias'];
			array_push($formArray,$oneset);
			($currow == "row1"?$currow="row2":$currow="row1");
			}
		if ($this->CheckPermission('Modify Forms'))
			{
			$this->smarty->assign('addlink',$this->CreateLink($id,
				'admin_add_edit_form', '',
				$gCms->variables['admintheme']->DisplayImage('icons/system/newobject.gif', $this->Lang('title_add_new_form'),'',
					'','systemicon'), array()));
			$this->smarty->assign('addform',$this->CreateLink($id,
				'admin_add_edit_form', '', $this->Lang('title_add_new_form'),
				array()));
			$this->smarty->assign('may_config',1);
			}
		else
			{
			$this->smarty->assign('no_permission',
				$this->Lang('lackpermission'));
			}
	
		$this->smarty->assign('title_hide_errors',$this->Lang('title_hide_errors'));		
		$this->smarty->assign('input_hide_errors',$this->CreateInputCheckbox($id, 'fbrp_hide_errors', 1, $this->GetPreference('hide_errors','1')). $this->Lang('title_hide_errors_long'));		
		$this->smarty->assign('title_relaxed_email_regex',$this->Lang('title_relaxed_email_regex'));		
		$this->smarty->assign('input_relaxed_email_regex',$this->CreateInputCheckbox($id, 'fbrp_relaxed_email_regex', 1, $this->GetPreference('relaxed_email_regex','0')). $this->Lang('title_relaxed_regex_long'));

		$this->smarty->assign('title_enable_fastadd',$this->Lang('title_enable_fastadd'));
		$this->smarty->assign('input_enable_fastadd',$this->CreateInputCheckbox($id, 'fbrp_enable_fastadd', 1, $this->GetPreference('enable_fastadd','1')). $this->Lang('title_enable_fastadd_long'));		


		$this->smarty->assign('title_require_fieldnames',$this->Lang('title_require_fieldnames'));		
		$this->smarty->assign('input_require_fieldnames',$this->CreateInputCheckbox($id, 'fbrp_require_fieldnames', 1, $this->GetPreference('require_fieldnames','1')). $this->Lang('title_require_fieldnames_long'));		

      $this->smarty->assign('title_unique_fieldnames',$this->Lang('title_unique_fieldnames'));
		$this->smarty->assign('input_unique_fieldnames',$this->CreateInputCheckbox($id, 'fbrp_unique_fieldnames', 1, $this->GetPreference('unique_fieldnames','1')). $this->Lang('title_unique_fieldnames_long'));		

		$this->smarty->assign('title_enable_antispam',$this->Lang('title_enable_antispam'));
		$this->smarty->assign('input_enable_antispam',$this->CreateInputCheckbox($id, 'fbrp_enable_antispam', 1, $this->GetPreference('enable_antispam','1')). $this->Lang('title_enable_antispam_long'));

$smarty->assign('title_show_fieldids',$this->Lang('title_show_fieldids'));
$smarty->assign('input_show_fieldids',
		$this->CreateInputcheckbox($id,'fbrp_show_fieldids',1,
					   $this->GetPreference('show_fieldids','0')). $this->Lang('title_show_fieldids_long'));

	$smarty->assign('title_show_fieldaliases',$this->Lang('title_show_fieldaliases'));
	$smarty->assign('input_show_fieldaliases',
			$this->CreateInputcheckbox($id,'fbrp_show_fieldaliases',1,
						   $this->GetPreference('show_fieldaliases','0')). $this->Lang('title_show_fieldaliases_long'));


		$this->smarty->assign('title_show_version',$this->Lang('title_show_version'));
		$this->smarty->assign('input_show_version',$this->CreateInputCheckbox($id, 'fbrp_show_version', 1, $this->GetPreference('show_version','1')). $this->Lang('title_show_version_long'));				
		$this->smarty->assign('submit', $this->CreateInputSubmit($id, 'fbrp_submit', $this->Lang('save')));
		$this->smarty->assign('end_configform',$this->CreateFormEnd());

      $this->smarty->assign('start_xmlform',$this->CreateFormStart($id,
			'importxml', $returnid, 'post','multipart/form-data'));
		$this->smarty->assign('submitxml', $this->CreateInputSubmit($id, 'fbrp_submit', $this->Lang('upload')));
		$this->smarty->assign('end_xmlform',$this->CreateFormEnd());
      $this->smarty->assign('input_xml_to_upload',$this->CreateInputFile($id, 'fbrp_xmlfile'));
      $this->smarty->assign('title_xml_to_upload',$this->Lang('title_xml_to_upload'));
      $this->smarty->assign('title_xml_upload_formname',$this->Lang('title_xml_upload_formname'));
      $this->smarty->assign('input_xml_upload_formname',
		      $this->CreateInputText($id,'fbrp_import_formname','',25));
      $this->smarty->assign('title_xml_upload_formalias',$this->Lang('title_xml_upload_formalias'));
      $this->smarty->assign('input_xml_upload_formalias',
		      $this->CreateInputText($id,'fbrp_import_formalias','',25));
      $smarty->assign('info_leaveempty',$this->Lang('help_leaveempty'));
      $smarty->assign('legend_xml_import',$this->Lang('title_import_legend'));

        $this->smarty->assign_by_ref('forms', $formArray);			
        echo $this->ProcessTemplate('AdminMain.tpl');
?>
]]></data>
	</file>
	<file>
	  <filename>/action.exportxml.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKaWYgKCFpc3NldCgkZ0NtcykpIGV4aXQ7CgppZiAoISBpc3NldCgkcGFyYW1zWydmb3JtX2lkJ10pICYmIGlzc2V0KCRwYXJhbXNbJ2Zvcm0nXSkpCiAgewogICAgLy8gZ2V0IHRoZSBmb3JtIGJ5IG5hbWUsIG5vdCBJRAogICAgJHBhcmFtc1snZm9ybV9pZCddID0gJHRoaXMtPkdldEZvcm1JREZyb21BbGlhcygkcGFyYW1zWydmb3JtJ10pOwogIH0KCiRhZWZvcm0gPSBuZXcgZmJGb3JtKCR0aGlzLCRwYXJhbXMsdHJ1ZSk7Cgokc3BlYyA9ICRhZWZvcm0tPkdldE5hbWUoKS4iLnhtbCI7CiRzcGVjID0gcHJlZ19yZXBsYWNlKCcvW15cd1xkXC5cLVxfXS8nLCdfJywkc3BlYyk7CiR4bWxzdHIgPSAkYWVmb3JtLT5FeHBvcnRYTUwoaXNzZXQoJHBhcmFtc1snZmJycF9leHBvcnRfdmFsdWVzJ10pP3RydWU6ZmFsc2UpOwoKICAgIEBvYl9jbGVhbigpOwogICAgQG9iX2NsZWFuKCk7CiAgICBoZWFkZXIoJ1ByYWdtYTogcHVibGljJyk7CiAgICBoZWFkZXIoJ0V4cGlyZXM6IDAnKTsKICAgIGhlYWRlcignQ2FjaGUtQ29udHJvbDogbXVzdC1yZXZhbGlkYXRlLCBwb3N0LWNoZWNrPTAsIHByZS1jaGVjaz0wJyk7CiAgICBoZWFkZXIoJ0NhY2hlLUNvbnRyb2w6IHByaXZhdGUnLGZhbHNlKTsKICAgIGhlYWRlcignQ29udGVudC1EZXNjcmlwdGlvbjogRmlsZSBUcmFuc2ZlcicpOwogICAgaGVhZGVyKCdDb250ZW50LVR5cGU6IGFwcGxpY2F0aW9uL2ZvcmNlLWRvd25sb2FkOyBjaGFyc2V0PXV0Zi04Jyk7CiAgICBoZWFkZXIoJ0NvbnRlbnQtTGVuZ3RoOiAnIC4gc3RybGVuKCR4bWxzdHIpKTsKICAgIGhlYWRlcignQ29udGVudC1EaXNwb3NpdGlvbjogYXR0YWNobWVudDsgZmlsZW5hbWU9JyAuICRzcGVjKTsKICAgIGVjaG8gJHhtbHN0cjsKICAgIGV4aXQ7Cj8+]]></data>
	</file>
	<file>
	  <filename>/action.importxml.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKaWYgKCFpc3NldCgkZ0NtcykpIGV4aXQ7CgppZiAoISAkdGhpcy0+Q2hlY2tBY2Nlc3MoKSkgZXhpdDsKCiRwYXJhbXNbJ2ZicnBfeG1sX2ZpbGUnXSA9ICRfRklMRVNbJGlkLidmYnJwX3htbGZpbGUnXVsndG1wX25hbWUnXTsKCiRhZWZvcm0gPSBuZXcgZmJGb3JtKCR0aGlzLCAkcGFyYW1zLCB0cnVlKTsKJHJlcyA9ICRhZWZvcm0tPkltcG9ydFhNTCgkcGFyYW1zKTsKCmlmICgkcmVzKQoJewoJJHBhcmFtc1snZmJycF9tZXNzYWdlJ10gPSAkdGhpcy0+TGFuZygnZm9ybV9pbXBvcnRlZCcpOwoJfQplbHNlCgl7CgkkcGFyYW1zWydmYnJwX21lc3NhZ2UnXSA9ICR0aGlzLT5MYW5nKCdmb3JtX2ltcG9ydF9mYWlsZWQnKTsKCX0KJHRoaXMtPkRvQWN0aW9uKCdkZWZhdWx0YWRtaW4nLCAkaWQsICRwYXJhbXMpOwo/Pg==]]></data>
	</file>
	<file>
	  <filename>/action.validate.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCgkJCmlmICghaXNzZXQoJHBhcmFtc1snZmJycF9mJ10pIHx8ICFpc3NldCgkcGFyYW1zWydmYnJwX3InXSkgfHwgIWlzc2V0KCRwYXJhbXNbJ2ZicnBfYyddKSkKCXsKCWVjaG8gJHRoaXMtPkxhbmcoJ3ZhbGlkYXRpb25fcGFyYW1fZXJyb3InKTsKCX0KJHBhcmFtc1sncmVzcG9uc2VfaWQnXT0kcGFyYW1zWydmYnJwX3InXTsKJHBhcmFtc1snZm9ybV9pZCddPSRwYXJhbXNbJ2ZicnBfZiddOwokcGFyYW1zWydmYnJwX3VzZXJfZm9ybV92YWxpZGF0ZSddPXRydWU7CiRhZWZvcm0gPSBuZXcgZmJGb3JtKCR0aGlzLCAkcGFyYW1zLCB0cnVlKTsKCmlmICghJGFlZm9ybS0+Q2hlY2tSZXNwb25zZSgkcGFyYW1zWydmYnJwX2YnXSwgJHBhcmFtc1snZmJycF9yJ10sICRwYXJhbXNbJ2ZicnBfYyddKSkKCXsKCWVjaG8gJHRoaXMtPkxhbmcoJ3ZhbGlkYXRpb25fcmVzcG9uc2VfZXJyb3InKTsKCX0KCiRmaWVsZHMgPSAkYWVmb3JtLT5HZXRGaWVsZHMoKTsKJGNvbmZpcm1hdGlvbkZpZWxkID0gLTE7CmZvcigkaT0wOyRpPGNvdW50KCRmaWVsZHMpOyRpKyspCgl7CglpZiAoJGZpZWxkc1skaV0tPkdldEZpZWxkVHlwZSgpID09ICdEaXNwb3NpdGlvbkVtYWlsQ29uZmlybWF0aW9uJykKCQl7CgkJJGNvbmZpcm1hdGlvbkZpZWxkID0gJGk7CgkJfQoJfQppZiAoJGNvbmZpcm1hdGlvbkZpZWxkICE9IC0xKQoJewoJJGZpZWxkc1skY29uZmlybWF0aW9uRmllbGRdLT5BcHByb3ZlVG9HbygkcGFyYW1zWydmYnJwX3InXSk7CgkkcmVzdWx0cyA9ICRhZWZvcm0tPkRpc3Bvc2UoJHJldHVybmlkKTsKCWlmICgkcmVzdWx0c1swXSA9PSB0cnVlKQoJCXsKCQkkcmV0ID0gJGZpZWxkc1skY29uZmlybWF0aW9uRmllbGRdLT5HZXRPcHRpb24oJ3JlZGlyZWN0X3BhZ2UnLCctMScpOwoJCWlmICgkcmV0ICE9IC0xKQoJCQl7CgkJCSR0aGlzLT5SZWRpcmVjdENvbnRlbnQoJHJldCk7CgkJCX0KCQl9CgllbHNlCgkJewoJCWVjaG8gIkVycm9yITogIjsKCQlmb3JlYWNoICgkcmVzdWx0c1sxXSBhcyAkdGhpc1JlcykKCQkJewoJCQllY2hvICR0aGlzUmVzIC4gJzxiciAvPic7CgkJCX0KCQl9Cgl9CmVsc2UKCXsKCQllY2hvICR0aGlzLT5MYW5nKCd2YWxpZGF0aW9uX25vX2ZpZWxkX2Vycm9yJyk7Cgl9Cj8+Cg==]]></data>
	</file>
	<file>
	  <filename>/classes/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/classes/CatalogerItemsField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/* 
   FormBuilder. Copyright (c) 2005-2006 Samuel Goldstein <sjg@cmsmodules.com>
   More info at http://dev.cmsmadesimple.org/projects/formbuilder
   
   A Module for CMS Made Simple, Copyright (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
  This project's homepage is: http://www.cmsmadesimple.org
*/

/* A class to provide a dynamic multiselect list to allow selecting one
 * or more items from the cataloger 
 * the item list is filtered by an array
 * of options as specified in the admin.
 */
class fbCatalogerItemsField extends fbFieldBase {

  var $optionCount;
  var $optionAdd;

  function fbMultiselectField(&$form_ptr, &$params)
  {
    $this->fbFieldBase($form_ptr, $params);
    $mod = &$form_ptr->module_ptr;
    $this->Type = 'CatalogerItemsField';
    $this->DisplayInForm = true;
    $this->NonRequirableField = false;
    $this->HasAddOp = false;
    $this->HasDeleteOp = false;
    $this->ValidationTypes = array(
            );
    $this->optionAdd = 0;
    $this->sortable = false;
  }


  function GetFieldInput($id, &$params, $returnid)
  {
    global $gCms;

    $mod = &$this->form_ptr->module_ptr;
    $cataloger =& $mod->GetModuleInstance('Cataloger');
    if( !$cataloger )
      {
	return $mod->Lang('error_cataloger_module_not_available');
      }
    
    $cataloger->getUserAttributes();
    $tmp_attrs =& $gCms->variables['catalog_attrs'];
    $lines = (int)$this->GetOption('lines','5');
    $nameregex = trim($this->GetOption('nameregex',''));
    
    $attrs = array();
    foreach( $tmp_attrs as $one )
      {
	$safeattr = strtolower(preg_replace('/\W/','',$one->attr));
	$val = trim($this->GetOption('attr_'.$safeattr,''));
	if( empty($val) ) continue;
	$one->input = $val;
	$attrs[] = $one;
      }

    // put the hidden fields into smarty.
    if( !isset($gCms->variables['fb_smarty_vars_set']) )
      {
	$smarty =& $gCms->GetSmarty();
	$theFields =& $this->form_ptr->GetFields();
	
	for($i = 0; $i < count($theFields); $i++ )
	  {
	    if( $theFields[$i]->GetFieldType() != 'HiddenField' ) continue;
	    $smarty->assign('fld_'.$theFields[$i]->GetId(),$theFields[$i]->Value);
	    if( $theFields[$i]->GetAlias() != '' )
	      {
		$smarty->assign($theFields[$i]->GetAlias(),$theFields[$i]->Value);
	      }
	  }

	$gCms->variables['fb_smarty_vars_set'] = 1;
      }

    // for each hierarchy item (from the root down)
    $hm =& $gCms->GetHierarchyManager();
    $allcontent = $hm->getFlatList();
    $results = array();
    foreach( $allcontent as $onepage )
      {
	$content = $onepage->GetContent();

	// if it's not a cataloger item continue
	if( $content->Type() != 'catalogitem' ) continue;

	// if it's not active or shown in menu continue
	if( !$content->Active() || !$content->ShowInMenu() ) continue;

	// if the nameregex string is not empty, and the name does not match the
	//    regex, continue
	if( !empty($nameregex ) && !preg_match('/'.$nameregex.'/',$content->Name()) )
	  {
	    continue;
	  }

	// for each attribute
	$passed = true;
	foreach( $attrs as $oneattr )
	  {
	    // parse the field value through smarty?
	    $expr = $mod->ProcessTemplateFromData($oneattr->input);
	    if( empty($expr) ) continue; // no expression for this field. pass
	    
	    // get the value for this attribute for this content
	    $currentval = $content->GetPropertyValue($oneattr->attr);
	    if( empty($currentval) )
	      {
		// no value for this field, but we have an expression
		// this catalog item fails.
		$passed = false;
		break;
	      }

	    list($type,$expr) = explode(':',$expr,2);
	    $type = trim($type);
	    $expr = trim($expr);

	    $res = false;
	    switch( strtolower($type) )
	      {
	      case 'range':
		// for ranges:
		// grab min and max values
		list($minval,$maxval) = explode('to',$expr);
		$minval = trim($minval); $maxval = trim($maxval);
		// check for numeric
		if( !is_numeric($minval) || !is_numeric($maxval) )
		  {
		    // can't test ranges with non numeric values
		    // so fail
		    $passed = false;
		    break;
		  }
		if( $minval > $maxval )
		  {
		    $tmp = $minval;
		    $minval = $maxval;
		    $maxval = $tmp;
		  }
		$res = ($currentval >= $minval && $currentval <= $maxval );
		break;

	      case 'multi':
		// for multi
		$tmp = explode('|',$expr);
		$res = in_array($currentval,$tmp);
		break;
	      }

	    if( !$res )
	      {
		$passed = false;
		break;
	      }
	  } // foreach attr

	if( $passed )
	  {
	    $results[$content->Name()] = $content->Name();
	  }
      } // foreach content
   

    // All done, do we have something to display?
    if( count($results) ) 
      {
	$size = min($lines,count($results));
	$size = min(50,$size); // maximum 50 lines, though this is probably big

	$val = array();
	if( $this->Value !== false )
	  {
	    $val = $this->Value;
	    if( !is_array( $this->Value ) )
	      {
		$val = array($this->Value);
	      }
	  }
	return $mod->CreateInputSelectList($id,'fbrp__'.$this->Id.'[]', $results, $val,
					   $size);
      }

    return ''; // error
  }


  function StatusInfo()
  {
    // return a string for displaying in the options field
    $mod = &$this->form_ptr->module_ptr;
    $cataloger =& $mod->GetModuleInstance('Cataloger');
    if( !$cataloger )
      {
	return $mod->Lang('error_cataloger_module_not_available');
      }
    return '';
  }
	

  function PrePopulateAdminForm($formDescriptor)
  {
    $mod = &$this->form_ptr->module_ptr;

    $main = array();
    $cataloger =& $mod->GetModuleInstance('Cataloger');
    if( !$cataloger )
      {
	$tmp = array($mod->Lang('warning'),$mod->Lang('error_cataloger_module_not_available'));
	$main[] = $tmp;
      }
    else
      {
	global $gCms;
	$cataloger->getUserAttributes();
	$attrs =& $gCms->variables['catalog_attrs'];

	$tmp = array($mod->Lang('title_field_height'),
		     $mod->CreateInputText($formDescriptor,
					   'fbrp_opt_lines',
					   $this->GetOption('lines','5'),3,3).
		     '&nbsp;'.$mod->Lang('help_field_height'));
	$main[] = $tmp;

	$tmp = array($mod->Lang('title_name_regex'),
		     $mod->CreateInputText($formDescriptor,
					   'frbp_opt_nameregex',
					   $this->GetOption('nameregex',''),
					   25,25).
		     '&nbsp;'.$mod->Lang('help_name_regex'));
	$main[] = $tmp;

	$tmp = array('',$mod->Lang('help_cataloger_attribute_fields'));
	$main[] = $tmp;
	
	foreach( $attrs as $one )
	  {
	    $safeattr = strtolower(preg_replace('/\W/','',$one->attr));
	    if( $one->is_text ) continue;
	    $tmp = array($one->attr,
			 $mod->CreateInputText($formDescriptor,
					       'fbrp_opt_attr_'.$safeattr,
					       $this->GetOption('attr_'.$safeattr,''),
					       30,80));
	    $main[] = $tmp;
	  }
      }

    $adv = array();
    return array('main'=>$main,'adv'=>$adv);
  }


  function GetHumanReadableValue($as_string=true)
  {
    $mod = &$this->form_ptr->module_ptr;
    $form = &$this->form_ptr;
    $vals = &$this->GetOptionRef('option_value');
    if ($this->HasValue())
      {
	$fieldRet = array();
	if (! is_array($this->Value))
	  {
	    $this->Value = array($this->Value);
	  }
	foreach ($this->Value as $thisOne)
	  {
	    array_push($fieldRet,$vals[$thisOne - 1]);
	  }
	if ($as_string)
	  {
	    return join($form->GetAttr('list_delimiter',','),$fieldRet);
	  }
	else
	  {
	    return array($fieldRet);
	  }			
      }
    else
      {
	if ($as_string)
	  {
	    return $mod->Lang('unspecified');
	  }
	else
	  {
	    return array($mod->Lang('unspecified'));
	  }
      }
	
  }

}
?>
]]></data>
	</file>
	<file>
	  <filename>/classes/CheckboxField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/CheckboxGroupField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/* 
   FormBuilder. Copyright (c) 2005-2006 Samuel Goldstein <sjg@cmsmodules.com>
   More info at http://dev.cmsmadesimple.org/projects/formbuilder
   
   A Module for CMS Made Simple, Copyright (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
  This project's homepage is: http://www.cmsmadesimple.org
*/

class fbCheckboxGroupField extends fbFieldBase {

	var $boxCount;
	var $boxAdd;
	
	function fbCheckboxGroupField(&$form_ptr, &$params)
	{
        $this->fbFieldBase($form_ptr, $params);
        $mod = &$form_ptr->module_ptr;
		$this->Type = 'CheckboxGroupField';
		$this->DisplayInForm = true;
		$this->HasAddOp = true;
		$this->HasDeleteOp = true;
		$this->NonRequirableField = true;
		$this->ValidationTypes = array(
            );
        $this->boxAdd = 0;
        $this->hasMultipleFormComponents = true;
        $this->sortable = false;
	}

	function countBoxes()
	{
			$tmp = &$this->GetOptionRef('box_name');
			if (is_array($tmp))
				{
	        	$this->boxCount = count($tmp);
	        	}
	        elseif ($tmp !== false)
	        	{
	        	$this->boxCount = 1;
	        	}
	        else
	        	{
	        	$this->boxCount = 0;
	        	}
	}

    function StatusInfo()
	{
        $mod = &$this->form_ptr->module_ptr;
		$this->countBoxes();
		$ret = $mod->Lang('boxes',$this->boxCount);
		 return $ret;
	}

	function GetOptionAddButton()
	{
		$mod = &$this->form_ptr->module_ptr;
		return $mod->Lang('add_checkboxes');
	}

	function GetOptionDeleteButton()
	{
		$mod = &$this->form_ptr->module_ptr;
		return $mod->Lang('delete_checkboxes');
	}

	function GetFieldInput($id, &$params, $returnid)
	{
		$mod = &$this->form_ptr->module_ptr;
		$names = &$this->GetOptionRef('box_name');
		$is_set = &$this->GetOptionRef('box_is_set');
		$js = $this->GetOption('javascript','');
		if (! is_array($names))
			{
			$names = array($names);
			}	
		if (! is_array($is_set))
			{
			$is_set = array($is_set);
			}
		$fieldDisp = array();
		for ($i=0;$i<count($names);$i++)
			{
			$label = '';
			$thisBox = new stdClass();
			if (strlen($names[$i]) > 0)
				{
				$thisBox->name = '<label for="'.$id.'fbrp__'.$this->Id.'_'.$i.'">'.$names[$i].'</label>';
				$thisBox->title = $names[$i];
				}
			$check_val = false;
			if ($this->Value !== false)
				{
				$check_val = $this->FindArrayValue($i+1);
				}
			else
				{
				if (isset($is_set[$i]) && $is_set[$i] == 'y')
					{
					$check_val = true;
					}
				}
			$thisBox->input = $mod->CreateInputCheckbox($id, 'fbrp__'.$this->Id.'[]', ($i+1),
				$check_val !== false?($i+1):'-1',' id="'.$id.'fbrp__'.$this->Id.'_'.$i.'" '.$js);

			array_push($fieldDisp, $thisBox);
			}			
		return $fieldDisp;
	}

	function GetHumanReadableValue($as_string=true)
	{
		$form = &$this->form_ptr;
		$names = &$this->GetOptionRef('box_name');
		if (! is_array($names))
			{
				$names = array($names);
			}		
		$checked = &$this->GetOptionRef('box_checked');
		if (! is_array($checked))
			{
				$checked = array($checked);
			}
		$unchecked = &$this->GetOptionRef('box_unchecked');
		if (! is_array($unchecked))
			{
				$unchecked = array($unchecked);
			}
		$fieldRet = array();
		for ($i=1;$i<=count($names);$i++)
			{
				if ($this->FindArrayValue($i) === false)
					{
						if ($this->GetOption('no_empty','0') != '1' && isset($unchecked[$i-1]) && trim($unchecked[$i-1]) != '' )
							{
							$fieldRet[] = $unchecked[$i-1];
							}
					}
				else
					{
						if( isset($checked[$i-1]) && trim($checked[$i-1]) != '' )
							$fieldRet[] = $checked[$i-1];
					}
			}
		if ($as_string)
			{
			return join($form->GetAttr('list_delimiter',','),$fieldRet);
			}
		else
			{
			return $fieldRet;
			}
	}

	function DoOptionAdd(&$params)
	{
		$this->boxAdd = 1;
	}

	function DoOptionDelete(&$params)
	{
		$delcount = 0;
		foreach ($params as $thisKey=>$thisVal)
			{
			if (substr($thisKey,0,9) == 'fbrp_del_')
				{
				$this->RemoveOptionElement('box_name', $thisVal - $delcount);
				$this->RemoveOptionElement('box_checked', $thisVal - $delcount);
				$this->RemoveOptionElement('box_unchecked', $thisVal - $delcount);
				$this->RemoveOptionElement('box_is_set', $thisVal - $delcount);
				$delcount++;
				}
			}
	}


	function PrePopulateAdminForm($formDescriptor)
	{
		$mod = &$this->form_ptr->module_ptr;
		$yesNo = array($mod->Lang('no')=>'n',$mod->Lang('yes')=>'y');

		$this->countBoxes();
		if ($this->boxAdd > 0)
			{
			$this->boxCount += $this->boxAdd;
			$this->boxAdd = 0;
			}
		$boxes = '<table class="module_fb_table"><tr><th>'.$mod->Lang('title_checkbox_label').'</th><th>'.
			$mod->Lang('title_checked_value').'</th><th>'.
			$mod->Lang('title_unchecked_value').'</th><th>'.
			$mod->Lang('title_default_set').'</th><th>'.
			$mod->Lang('title_delete').'</th></tr>';


		for ($i=0;$i<($this->boxCount>1?$this->boxCount:1);$i++)
			{
			$boxes .= '<tr><td>'.
            		$mod->CreateInputText($formDescriptor, 'fbrp_opt_box_name[]',$this->GetOptionElement('box_name',$i),25,128).
            		'</td><td>'.
            		$mod->CreateInputText($formDescriptor, 'fbrp_opt_box_checked[]',$this->GetOptionElement('box_checked',$i),25,128).
            		'</td><td>'.
            		$mod->CreateInputText($formDescriptor, 'fbrp_opt_box_unchecked[]',$this->GetOptionElement('box_unchecked',$i),25,128).
            		'</td><td>'.            		    
            		$mod->CreateInputDropdown($formDescriptor, 'fbrp_opt_box_is_set[]', $yesNo, -1, $this->GetOptionElement('box_is_set',$i)).
            		
            		
            		'</td><td>'.
//CreateInputCheckbox($id, $name, $value='', $selectedvalue='',
            		$mod->CreateInputCheckbox($formDescriptor, 'fbrp_del_'.$i, $i,-1).
             		'</td></tr>';
			}
		$boxes .= '</table>';
		$main = array(
			array($mod->Lang('title_dont_submit_unchecked'),
				$mod->CreateInputHidden($formDescriptor,'fbrp_opt_no_empty','0').
					$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_no_empty','1',$this->GetOption('no_empty','0')).
					$mod->Lang('title_dont_submit_unchecked_help'),
	           ),
			array($mod->Lang('title_checkbox_details'),$boxes)
		);
		$adv = array();
		return array('main'=>$main,'adv'=>$adv);
	}

	function PostPopulateAdminForm(&$mainArray, &$advArray)
	{
		$mod = &$this->form_ptr->module_ptr;
		// remove the "required" field, since this can only be done via validation
		$reqIndex = -1;
		for ($i=0;$i<count($mainArray);$i++)
			{
			if ($mainArray[$i]->title == $mod->Lang('title_field_required'))
				{
				$reqIndex = $i;
				}
			}
		if ($reqIndex != -1)
			{
			array_splice($mainArray, $reqIndex,1);
			}
	}


	function PostAdminSubmitCleanup()
	{
		$names = &$this->GetOptionRef('box_name');
		$checked = &$this->GetOptionRef('box_checked');
		$unchecked = &$this->GetOptionRef('box_unchecked');
		$is_set = &$this->GetOptionRef('box_is_set');
		for ($i=0;$i<count($names);$i++)
			{
			if ($names[$i] == '' && $checked[$i] == '' )
				{
				$this->RemoveOptionElement('box_name', $i);
				$this->RemoveOptionElement('box_checked', $i);
				$this->RemoveOptionElement('box_unchecked', $i);
				$this->RemoveOptionElement('box_is_set', $i);
				$i--;
				}
			}
		$this->countBoxes();
	}
}

?>
]]></data>
	</file>
	<file>
	  <filename>/classes/ComputedField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/CountryPickerField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/* 
   FormBuilder. Copyright (c) 2005-2006 Samuel Goldstein <sjg@cmsmodules.com>
   More info at http://dev.cmsmadesimple.org/projects/formbuilder
   
   A Module for CMS Made Simple, Copyright (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
  This project's homepage is: http://www.cmsmadesimple.org
*/
class fbCountryPickerField extends fbFieldBase {

	var $Countries;
	
	function fbCountryPickerField(&$form_ptr, &$params)
	{
        $this->fbFieldBase($form_ptr, $params);
        $mod = &$form_ptr->module_ptr;
		$this->Type = 'CountryPickerField';
		$this->DisplayInForm = true;
		$this->ValidationTypes = array(
            );

        $this->Countries = array($mod->Lang('no_default')=>'',
        'Afghanistan'=>'AF', 'Aland Islands'=>'AX', 
        'Albania'=>'AL',  'Algeria'=>'DZ', 'American Samoa'=>'AS', 'Andorra'=>'AD',
         'Angola'=>'AO', 'Anguilla'=>'AI', 'Antarctica'=>'AQ',  'Antigua and Barbuda'=>'AG',
        'Argentina'=>'AR', 'Armenia'=>'AM', 'Aruba'=>'AW', 'Australia'=>'AU', 'Austria'=>'AT', 		'Azerbaijan'=>'AZ', 'Bahamas'=>'BS', 'Bahrain'=>'BH', 'Barbados'=>' BB',
        'Bangladesh'=>'BD', 'Belarus'=>'BY', 'Belgium'=>'BE',
        'Belize'=>'BZ', 'Benin'=>'BJ', 'Bermuda'=>'BM', 'Bhutan'=>'BT', 'Botswana'=>'BW',
        'Bolivia'=>'BO', 'Bosnia and Herzegovina'=>'BA', 'Bouvet Island'=>'BV',
        'Brazil'=>'BR', 'British Indian Ocean Territory'=>'IO', 'Brunei Darussalam'=>'BN', 'Bulgaria'=>'BG',
        'Burkina Faso'=>'BF', 'Burundi'=>'BI', 'Cambodia'=>'KH',
        'Cameroon'=>'CM', 'Canada'=>'CA' , 'Cape Verde'=>'CV', 'Cayman Islands'=>'KY', 
        'Central African Republic'=>'CF', 'Chad'=>'TD',
        'Chile'=>'CL', 'China'=>'CN', 'Christmas Island'=>'CX', 
        'Cocos (Keeling) Islands'=>'CC', 'Colombia'=>'CO', 'Comoros'=>'KM',
        'Congo'=>'CG', 'Congo,  Democratic Republic'=>'CD',  'Cook Islands'=>'CK',
        'Costa Rica'=>'CR', 'Cote D\'Ivoire (Ivory Coast)'=>'CI', 'Croatia (Hrvatska)'=>'HR',  'Cuba'=>'CU',
        'Cyprus'=>'CY', 'Czech Republic'=>'CZ', 'Denmark'=>'DK',
        'Djibouti'=>'DJ', 'Dominica'=>'DM ',  'Dominican Republic'=>'DO',
        'East Timor'=>'TP', 'Ecuador'=>'EC',
        'Egypt'=>'EG', 'El Salvador'=>'SV', 'Equatorial Guinea'=>'GQ',
        'Eritrea'=>'ER', 'Estonia'=>'EE', 'Ethiopia'=>'ET', 'Falkland Islands (Malvinas)'=>'FK',
        'Faroe Islands'=>'FO', 'Fiji'=>'FJ',
        'Finland'=>'FI', 'France'=>'FR', 'France,  Metropolitan'=>'FX',
         'French Guiana'=>'GF', 'French Polynesia'=>'PF', 'French Southern Territories'=>'TF',
         'F.Y.R.O.M. (Macedonia)'=>'MK',
        'Gabon'=>'GA', 'Gambia'=>'GM', 'Georgia'=>'GE', 'Germany'=>'DE',
         'Ghana'=>'GH', 'Gibraltar'=>'GI', 'Great Britain (UK)'=>'GB',
        'Greece'=>'GR', 'Greenland'=>'GL',  'Grenada'=>'GD',
        'Guadeloupe'=>'GP',  'Guam'=>'GU',  'Guatemala'=>'GT',
        'Guernsey'=>'GF',  'Guinea'=>'GN',  'Guinea-Bissau'=>'GW',
        'Guyana'=>'GY',  'Haiti'=>'HT',  'Heard and McDonald Islands'=>'HM',
        'Honduras'=>'HN',  'Hong Kong'=>'HK',
        'Hungary'=>'HU',  'Iceland'=>'IS',  'India'=>'IN',
        'Indonesia'=>'ID',  'Iran'=>'IR',  'Iraq'=>'IQ', 
        'Ireland'=>'IE', 'Israel'=>'IL',  'Isle of Man'=>'IM', 
        'Italy'=>'IT', 'Jersey'=>'JE',  'Jamaica'=>'JM',  'Japan'=>'JP',
         'Jordan'=>'JO', 'Kazakhstan'=>'KZ',  'Kenya'=>'KE', 
        'Kiribati'=>'KI',  'Korea (North)'=>'KP',  'Korea (South)'=>'KR', 
        'Kuwait'=>'KW', 'Kyrgyzstan'=>'KG', 
        'Laos'=>'LA',  'Latvia'=>'LV', 'Lebanon'=>'LB', 
        'Liechtenstein'=>'LI',  'Liberia'=>'LR', 'Libya'=>'LY', 
        'Lesotho'=>'LS',  'Lithuania'=>'LT', 'Luxembourg'=>'LU', 
        'Macau'=>'MO',  'Madagascar'=>'MG', 'Malawi'=>'MW', 
        'Malaysia'=>'MY',  'Maldives'=>'MV', 'Mali'=>'ML', 
        'Malta'=>'MT',  'Marshall Islands'=>'MH', 'Martinique'=>'MQ', 
        'Mauritania'=>'MR',  'Mauritius'=>'MU', 'Mayotte'=>'YT', 
        'Mexico'=>'MX',  'Micronesia'=>'FM', 'Monaco'=>'MC', 
        'Moldova'=>'MD',  'Morocco'=>'MA', 'Mongolia'=>'MN', 
        'Montserrat'=>'MS',  'Mozambique'=>'MZ', 'Myanmar'=>'MM', 
        'Namibia'=>'NA',  'Nauru'=>'NR',  'Nepal'=>'NP',
        'Netherlands'=>'NL',  'Netherlands Antilles'=>'AN',  'Neutral Zone'=>'NT',
        'New Caledonia'=>'NC',  'New Zealand (Aotearoa)'=>'NZ',  'Nicaragua'=>'NI',  'Niger'=>'NE',
        'Nigeria'=>'NG',  'Niue'=>'NU',  'Norfolk Island'=>'NF', 
        'Northern Mariana Islands'=>'MP',  'Norway'=>'NO', 
        'Oman'=>'OM', 'Pakistan'=>'PK',  'Palau'=>'PW',  'Palestinian Territory'=>'PS',
        'Panama'=>'PA',  'Papua New Guinea'=>'PG', 
        'Paraguay'=>'PY', 'Peru'=>'PE',  'Philippines'=>'PH', 
        'Pitcairn'=>'PN', 'Poland'=>'PL',  'Portugal'=>'PT',  'Puerto Rico'=>'PR',
        'Qatar'=>'QA',  'Reunion'=>'RE',  'Romania'=>'RO', 
        'Russian Federation'=>'RU',  'Rwanda'=>'RW',  'S. Georgia and S. Sandwich Isls.'=>'GS',
        'Saint Kitts and Nevis'=>'KN',  'Saint Lucia'=>'LC',  'Saint Vincent &amp; the Grenadines'=>'VC',
        'Samoa'=>'WS',  'San Marino'=>'SM',  'Sao Tome and Principe'=>'ST',
         'Saudi Arabia'=>'SA',  'Senegal'=>'SN',
        'Seychelles'=>'SC',  'Sierra Leone'=>'SL',  'Singapore'=>'SG',
        'Slovenia'=>'SI',  'Slovak Republic'=>'SK',  'Solomon Islands'=>'SB',  'Somalia'=>'SO', 
        'South Africa'=>'ZA',
        'Spain'=>'ES',  'Sri Lanka'=>'LK',  'St. Helena'=>'SH',  'St. Pierre and Miquelon '=>'PM',
        'Sudan'=>'SD',  'Suriname'=>'SR',
        'Svalbard &amp; Jan Mayen Islands'=>'SJ',  'Swaziland'=>'SZ',
        'Sweden'=>'SE',  'Switzerland'=>'CH',  'Syria'=>'SY',
        'Taiwan'=>'TW',  'Tajikistan'=>'TJ',  'Tanzania'=>'TZ',
        'Thailand'=>'TH',  'Togo'=>'TG',  'Tokelau'=>'TK', 
        'Tonga'=>'TO', 'Trinidad and Tobago'=>'TT',  'Tunisia'=>'TN', 
        'Turkey'=>'TR', 'Turkmenistan'=>'TM',  'Turks and Caicos Islands'=>'TC',
        'Tuvalu'=>'TV',  'Uganda'=>'UG', 
        'Ukraine'=>'UA',  'United Arab Emirates'=>'AE',  'United Kingdom'=>'UK',
        'United States'=>'US', 'US Minor Outlying Islands'=>'UM',  'Uruguay'=>'UY', 
        'Uzbekistan'=>'UZ', 
        'Vanuatu'=>'VU',  'Vatican City State (Holy See)'=>'VA', 
        'Venezuela'=>'VE',  'Viet Nam'=>'VN',  'Virgin Islands (British)'=>'VG',
        'Virgin Islands (U.S.)'=>'VI',  'Wallis and Futuna Islands'=>'WF', 
        'Western Sahara'=>'EH', 'Yemen'=>'YE', 
        'Yugoslavia'=>'YU',  'Zambia'=>'ZM', 'Zimbabwe'=>'ZW' );
	}


    function StatusInfo()
	{
		return '';
	}

	function GetHumanReadableValue($as_string=true)
	{
		$ret = array_search($this->Value,$this->Countries);
		if ($as_string)
			{
			return $ret;
			}
		else
			{
			return array($ret);
			}
	}

	function GetFieldInput($id, &$params, $returnid)
	{
		$mod = &$this->form_ptr->module_ptr;

		unset($this->Countries[$mod->Lang('no_default')]);
		$js = $this->GetOption('javascript','');
		if ($this->GetOption('select_one','') != '')
			{
			$this->Countries = array_merge(array($this->GetOption('select_one','')=>''),$this->Countries);
			}
		else
			{
			$this->Countries = array_merge(array($mod->Lang('select_one')=>''),$this->Countries);
			}

		if (! $this->HasValue() && $this->GetOption('default','') != '')
		  {
		  $this->SetValue($this->GetOption('default',''));
		  }

		return $mod->CreateInputDropdown($id, 'fbrp__'.$this->Id, $this->Countries, -1, $this->Value, 'id="'.$id. 'fbrp__'.$this->Id.'" '.$js);
	}

	function PrePopulateAdminForm($formDescriptor)
	{
		$mod = &$this->form_ptr->module_ptr;
		ksort($this->Countries);

		$main = array(
			array($mod->Lang('title_select_default_country'),
            		$mod->CreateInputDropdown($formDescriptor, 'fbrp_opt_default',
            		$this->Countries, -1, $this->GetOption('default',''))),
			array($mod->Lang('title_select_one_message'),
            		$mod->CreateInputText($formDescriptor, 'fbrp_opt_select_one',
            		$this->GetOption('select_one',$mod->Lang('select_one'))))
		);
		return array('main'=>$main,array());
	}


}

?>
]]></data>
	</file>
	<file>
	  <filename>/classes/DatePickerField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionDatabase.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionDeliverToEmailAddressField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionDirector.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/* 
   FormBuilder. Copyright (c) 2005-2006 Samuel Goldstein <sjg@cmsmodules.com>
   More info at http://dev.cmsmadesimple.org/projects/formbuilder
   
   A Module for CMS Made Simple, Copyright (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
  This project's homepage is: http://www.cmsmadesimple.org
*/

require_once('DispositionEmailBase.class.php');

class fbDispositionDirector extends fbDispositionEmailBase {

	var $addressCount;
	var $addressAdd;

	function fbDispositionDirector(&$form_ptr, &$params)
	{
       $this->fbDispositionEmailBase($form_ptr, $params);
        $mod = &$form_ptr->module_ptr;
		$this->Type = 'DispositionDirector';
		$this->DisplayInForm = true;
		$this->IsDisposition = true;
		$this->HasAddOp = true;
		$this->HasDeleteOp = true;
		$this->ValidationTypes = array(
       		);
       	$this->addressAdd = 0;
	}

	function GetOptionAddButton()
	{
		$mod = &$this->form_ptr->module_ptr;
		return $mod->Lang('add_destination');
	}

	function GetOptionDeleteButton()
	{
		$mod = &$this->form_ptr->module_ptr;
		return $mod->Lang('delete_destination');
	}

	function DoOptionAdd(&$params)
	{
		$this->addressAdd = 1;
	}

	function DoOptionDelete(&$params)
	{
		$delcount = 0;
		foreach ($params as $thisKey=>$thisVal)
			{
			if (substr($thisKey,0,9) == 'fbrp_del_')
				{
				$this->RemoveOptionElement('destination_address', $thisVal - $delcount);
				$this->RemoveOptionElement('destination_subject', $thisVal - $delcount);
				$delcount++;
				}
			}
	}

	function countAddresses()
	{
			$tmp = &$this->GetOptionRef('destination_address');
			if (is_array($tmp))
				{
	        	$this->addressCount = count($tmp);
	        	}
	        elseif ($tmp !== false)
	        	{
	        	$this->addressCount = 1;
	        	}
	        else
	        	{
	        	$this->addressCount = 0;
	        	}
	}

	function GetFieldInput($id, &$params, $returnid)
	{
		$mod = &$this->form_ptr->module_ptr;
		$js = $this->GetOption('javascript','');

		// why all this? Associative arrays are not guaranteed to preserve
		// order, except in "chronological" creation order.
		$sorted =array();
		if ($this->GetOption('select_one','') != '')
			{
			$sorted[' '.$this->GetOption('select_one','')]='';
			}
		else
			{
			$sorted[' '.$mod->Lang('select_one')]='';
			}
		$subjects = &$this->GetOptionRef('destination_subject');

		if (count($subjects) > 1)
			{
			for($i=0;$i<count($subjects);$i++)
				{
				$sorted[$subjects[$i]]=($i+1);
				}
			}
		else
			{
			$sorted[$subjects] = '1';
			}
		return $mod->CreateInputDropdown($id, 'fbrp__'.$this->Id, $sorted, -1, $this->Value, 'id="'.$id. '_'.$this->Id.'" '.$js);
	}



    function StatusInfo()
	{
		$mod = &$this->form_ptr->module_ptr;
		$opt = $this->GetOption('destination_address','');
		
		if (is_array($opt))
		  {
		      $num = count($opt);
		  }
		elseif ($opt != '')
			{
			$num = 1;
			}
		else
		  {
          $num = 0;
          }
         $ret= $mod->Lang('destination_count',$num);
        $ret.= $this->TemplateStatus();
        return $ret;
	}
	
	function PrePopulateAdminForm($formDescriptor)
	{
		$mod = &$this->form_ptr->module_ptr;

		$this->countAddresses();
		if ($this->addressAdd > 0)
			{
			$this->addressCount += $this->addressAdd;
			$this->addressAdd = 0;
			}
		$dests = '<table class="module_fb_table"><tr><th>'.$mod->Lang('title_selection_subject').'</th><th>'.
			$mod->Lang('title_destination_address').'</th><th>'.
			$mod->Lang('title_delete').'</th></tr>';


		for ($i=0;$i<($this->addressCount>1?$this->addressCount:1);$i++)
			{
			$dests .=  '<tr><td>'.
            		$mod->CreateInputText($formDescriptor, 'fbrp_opt_destination_subject[]',$this->GetOptionElement('destination_subject',$i),25,128).
            		'</td><td>'.
            		$mod->CreateInputText($formDescriptor, 'fbrp_opt_destination_address[]',$this->GetOptionElement('destination_address',$i),25,128).
            		'</td><td>'.
            		$mod->CreateInputCheckbox($formDescriptor, 'fbrp_del_'.$i, $i,-1).
             		'</td></tr>';
			}
		$dests .= '</table>';
		list($main,$adv) = $this->PrePopulateAdminFormBase($formDescriptor);
		array_push($main,array($mod->Lang('title_select_one_message'),
			$mod->CreateInputText($formDescriptor, 'fbrp_opt_select_one',
			$this->GetOption('select_one',$mod->Lang('select_one')),25,128)));
		array_push($main,array($mod->Lang('title_allow_subject_override'),
			$mod->CreateInputHidden($formDescriptor,'fbrp_opt_subject_override','0').
			$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_subject_override',
                '1',$this->GetOption('subject_override','0')).
				$mod->Lang('title_allow_subject_override_long')));		
		array_push($main,array($mod->Lang('title_director_details'),$dests));
		return array('main'=>$main,'adv'=>$adv);
	}

	function PostPopulateAdminForm(&$mainArray, &$advArray)
	{
		$mod = &$this->form_ptr->module_ptr;
		// remove the "email subject" field
		$hideIndex = -1;
		for ($i=0;$i<count($mainArray);$i++)
			{
			if ($mainArray[$i]->title == $mod->Lang('title_email_subject'))
				{
				$hideIndex = $i;
				}
			}
		if ($hideIndex != -1)
			{
			array_splice($mainArray, $hideIndex,1);
			}
		// remove the "hide css" field
		$hideIndex = -1;
		for ($i=0;$i<count($advArray);$i++)
			{
			if ($advArray[$i]->title == $mod->Lang('title_field_css_class'))
				{
				$hideIndex = $i;
				}
			}
		if ($hideIndex != -1)
			{
			array_splice($advArray, $hideIndex,1);
			}
		if (count($advArray) == 0)
			{
			$advArray[0]->title = $mod->Lang('tab_advanced');
			$advArray[0]->input = $mod->Lang('title_no_advanced_options');
			}
	}

	function GetHumanReadableValue($as_string=true)
	{
		$mod = &$this->form_ptr->module_ptr;
		if ($this->HasValue())
			{
			$ret = $this->GetOptionElement('destination_subject',($this->Value - 1));
			}
		else
			{
			$ret = $mod->Lang('unspecified');
			}	
		if ($as_string)
			{
			return $ret;
			}
		else
			{
			return array($ret);
			}
	}
	
	function DisposeForm($returnid)
	{
		if ($this->GetOption('subject_override','0') == '1' && $this->GetOption('email_subject','') != '')
			{
			$subject = $this->GetOption('email_subject');
			}
		else
			{
			$subject = $this->GetOptionElement('destination_subject',($this->Value - 1));
			}
		return $this->SendForm($this->GetOptionElement('destination_address',($this->Value - 1)),
			$subject);
	}


	function AdminValidate()
    {
		$mod = &$this->form_ptr->module_ptr;
    	$opt = $this->GetOption('destination_address');
  		list($ret, $message) = $this->DoesFieldHaveName();
		if ($ret)
			{
			list($ret, $message) = $this->DoesFieldNameExist();
			}		

		if (count($opt) == 0)
			{
			$ret = false;
			$message .= $mod->Lang('must_specify_one_destination').'</br>';
			}
		if (! preg_match(($mod->GetPreference('relaxed_email_regex','0')==0?$mod->email_regex:$mod->email_regex_relaxed),$this->GetOption('email_from_address')))
			{
    	       	$ret = false;
                $message .= $mod->Lang('not_valid_email',$this->GetOption('email_from_address')) . '<br/>';
			}
        for($i=0;$i<count($opt);$i++)
    	   {
			if (! preg_match($mod->email_regex, $opt[$i]))
    	       {
    	       	$ret = false;
                $message .= $mod->Lang('not_valid_email',$opt[$i]).'<br/>';
    	       }
        }
        return array($ret,$message);
    }
    
    function Validate()
    {
         $mod = &$this->form_ptr->module_ptr;
         $result = true;
         $message = '';

         if ($this->Value == false)
            {
            $result = false;
            $message .=
$mod->Lang('must_specify_one_destination').'</br>';
            }
        return array($result,$message);
    }

}
?>
]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionEmail.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionEmailBase.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/*
   FormBuilder. Copyright (c) 2005-2006 Samuel Goldstein <sjg@cmsmodules.com>
   More info at http://dev.cmsmadesimple.org/projects/formbuilder

   A Module for CMS Made Simple, Copyright (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
  This project's homepage is: http://www.cmsmadesimple.org
*/

class fbDispositionEmailBase extends fbFieldBase
{

  function fbDispositionEmailBase(&$form_ptr, &$params)
  {
    $this->fbFieldBase($form_ptr, $params);
    $mod = &$form_ptr->module_ptr;
    $this->IsDisposition = true;
    $this->ValidationTypes = array();

  }

  // override me!
  function StatusInfo()
  {
  }

  function TemplateStatus()
  {
    $mod = &$this->form_ptr->module_ptr;
    if ($this->GetOption('email_template','') == '')
      {
  return $mod->Lang('email_template_not_set');
      }
  }

  // override me!
  function DisposeForm()
  {
    return array(true,'');
  }

  // override me as necessary
  function SetFromAddress()
  {
    return true;
  }

  // override me as necessary
  function SetFromName()
  {
    return true;
  }

  // Send off those emails
  function SendForm($destination_array, $subject)
  {
    global $gCms;
    $mod = &$this->form_ptr->module_ptr;
    $form = &$this->form_ptr;

   if ($mod->GetPreference('enable_antispam',1))
     {
    $db =& $gCms->GetDb();
    $query = 'select count(src_ip) as sent from '.cms_db_prefix().
      'module_fb_ip_log where src_ip=? AND sent_time > ?';

    $dbresult = $db->GetOne($query, array($_SERVER['REMOTE_ADDR'],
               trim($db->DBTimeStamp(time() - 3600),"'")));

    if ($dbresult && $dbresult['sent'] > 9)
      {
      // too many from this IP address. Kill it.
        $msg = '<hr />'.$mod->Lang('suspected_spam'). '<hr />';
      audit(-1, $mod->GetName(),$mod->Lang('log_suspected_spam',$_SERVER['REMOTE_ADDR']));
      return array(false,$msg);
      }
    }

    $mail =& $mod->GetModuleInstance('CMSMailer');
    if ($mail == FALSE)
      {
  $msg = '';
  if (! $mod->GetPreference('hide_errors',0))
    {
      $msg = '<hr />'.$mod->Lang('missing_cms_mailer'). '<hr />';
    }
  audit(-1, $mod->GetName(),$mod->Lang('missing_cms_mailer'));
  return array(false,$msg);
      }
    $mail->reset();
    if ($this->SetFromAddress())
      {
  	  //$mail->SetFrom($this->GetOption('email_from_address'));
      $mail->AddReplyTo($this->GetOption('email_from_address'),$this->SetFromName()?$this->GetOption('email_from_name'):'');
      }
    if ($this->SetFromName())
      {
  $mail->SetFromName($this->GetOption('email_from_name'));
      }
    $mail->SetCharSet($this->GetOption('email_encoding','utf-8'));

    $message = $this->GetOption('email_template','');
    $htmlemail = ($this->GetOption('html_email','0') == '1');
    if ($htmlemail)
     {
    $mail->IsHTML(true);
    }
   if (strlen($message) < 1)
      {
    $message = $form->createSampleTemplate(false);
      if ($htmlemail)
       {
      $message2 = $form->createSampleTemplate(true);
      }
      }
    elseif ($htmlemail)
      {
    $message2 = $message;
    }
    $form->setFinishedFormSmarty();

    $theFields = &$form->GetFields();

    for($i=0;$i<count($theFields);$i++)
		{
 		if (strtolower(get_class($theFields[$i])) == 'fbfileuploadfield' )
    		{
    		if(! $theFields[$i]->GetOption('sendto_uploads') )
      			{
        		// we have a file we wish to attach
				$thisAtt = $theFields[$i]->GetHumanReadableValue(false);
			
				if (is_array($thisAtt))
					{
					if (function_exists('finfo_open'))
						{
						$finfo = finfo_open(FILEINFO_MIME); // return mime type ala mimetype extension
						$thisType = finfo_file($finfo, $thisAtt[0]);
						finfo_close($finfo);
						}
					else if (function_exists('mime_content_type'))
						{
						$thisType = mime_content_type($thisAtt[0]);
						}
					else
						{
						$thisType = 'application/octet-stream';
						}
					$thisNames = split('[/:\\]',$thisAtt[0]);
					$thisName = array_pop($thisNames);
    				if (! $mail->AddAttachment($thisAtt[0], $thisName, "base64", $thisType))
          				{
      					// failed upload kills the send.
      					audit(-1, (isset($name)?$name:""), $mod->Lang('submit_error',$mail->GetErrorInfo()));
      					return array($res, $mod->Lang('upload_attach_error',
                  				array($thisAtt[0],$thisAtt[0] ,$thisType)));
          				}
					}
      			}
     		}
    	}


    $message = $mod->ProcessTemplateFromData( $message );
    $subject = $mod->ProcessTemplateFromData( $subject );
    $mail->SetSubject($subject);
     if ($htmlemail)
     {
    $message2 = $mod->ProcessTemplateFromData($message2);
    $mail->SetAltBody(strip_tags(html_entity_decode($message)));
    $mail->SetBody($message2);
    }
   else
     {
     $mail->SetBody(html_entity_decode($message));
    }
    // send the message...
    if (! is_array($destination_array))
      {
  $destination_array = array($destination_array);
      }
    foreach ($destination_array as $thisDest)
      {
  $mail->AddAddress($thisDest);
      }

    $res = $mail->Send();
    if ($res === false)
      {
  audit(-1, (isset($name)?$name:""), $mod->Lang('submit_error',$mail->GetErrorInfo()));
      }
    else if ($mod->GetPreference('enable_antispam',1))
     {
    $db =& $gCms->GetDb();

    $rec_id = $db->GenID(cms_db_prefix().'module_fb_ip_log_seq');
    $query = 'INSERT INTO '.cms_db_prefix().
      'module_fb_ip_log (sent_id, src_ip, sent_time) VALUES (?, ?, ?)';

    $dbresult = $db->Execute($query, array($rec_id, $_SERVER['REMOTE_ADDR'],
               trim($db->DBTimeStamp(time()),"'")));
    }
    return array($res, $mail->GetErrorInfo());
  }

  function PrePopulateAdminFormBase($formDescriptor)
  {
    $mod = &$this->form_ptr->module_ptr;
    $message = $this->GetOption('email_template','');

	$parm = array();
	$parm['opt_email_template']['html_button'] = true;
	$parm['opt_email_template']['text_button'] = true;
	$parm['opt_email_template']['is_email'] = true;
    return array(
     array(
           array($mod->Lang('title_email_subject'),$mod->CreateInputText($formDescriptor, 'fbrp_opt_email_subject',$this->GetOption('email_subject',''),50).'<br/>'.$mod->Lang('canuse_smarty')),
           array($mod->Lang('title_email_from_name'),$mod->CreateInputText($formDescriptor, 'fbrp_opt_email_from_name',$this->GetOption('email_from_name',$mod->Lang('friendlyname')),25,128)),
           array($mod->Lang('title_email_from_address'),$mod->CreateInputText($formDescriptor, 'fbrp_opt_email_from_address',$this->GetOption('email_from_address',''),25,128).'<br />'.
		$mod->Lang('email_from_addr_help',array($_SERVER['SERVER_NAME']))),
           ),
     array(
          array($mod->Lang('title_html_email'),
            $mod->CreateInputHidden($formDescriptor,'fbrp_opt_html_email','0').$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_html_email',
                '1',$this->GetOption('html_email','0'))),
           array($mod->Lang('title_email_template'),
           array($mod->CreateTextArea(false, $formDescriptor,
              /*($this->GetOption('html_email','0')=='1'?$message:htmlspecialchars($message))*/
			 $message,'fbrp_opt_email_template', 'module_fb_area_wide', '','',0,0),
              $this->form_ptr->AdminTemplateHelp($formDescriptor,$parm))),
           array($mod->Lang('title_email_encoding'),$mod->CreateInputText($formDescriptor, 'fbrp_opt_email_encoding',$this->GetOption('email_encoding','utf-8'),25,128))
           )
     );
  }

}

// EOF
?>
]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionEmailConfirmation.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionEmailSiteAdmin.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/* 
   FormBuilder. Copyright (c) 2005-2008 Samuel Goldstein <sjg@cmsmodules.com>
   More info at http://dev.cmsmadesimple.org/projects/formbuilder
   
   A Module for CMS Made Simple, Copyright (c) 2008 by Ted Kulp (wishy@cmsmadesimple.org)
  This project's homepage is: http://www.cmsmadesimple.org
*/

require_once('DispositionEmailBase.class.php');

class fbDispositionEmailSiteAdmin extends fbDispositionEmailBase {

	var $addressCount;
	var $addressAdd;

	function fbDispositionEmailSiteAdmin(&$form_ptr, &$params)
	{
       $this->fbDispositionEmailBase($form_ptr, $params);
        $mod = &$form_ptr->module_ptr;
		$this->Type = 'DispositionEmailSiteAdmin';
		$this->DisplayInForm = true;
		$this->IsDisposition = true;
		$this->HasAddOp = false;
		$this->HasDeleteOp = false;
		$this->ValidationTypes = array(
       		);
	}


	function GetFieldInput($id, &$params, $returnid)
	{
	    global $gCms;
	    $userops =& $gCms->GetUserOperations();
		$mod = &$this->form_ptr->module_ptr;
		$js = $this->GetOption('javascript','');

		// why all this? Associative arrays are not guaranteed to preserve
		// order, except in "chronological" creation order.
		$sorted =array();
		if ($this->GetOption('select_one','') != '')
			{
			$sorted[' '.$this->GetOption('select_one','')]='';
			}
		else
			{
			$sorted[' '.$mod->Lang('select_one')]='';
			}
			
		if ($this->GetOption('restrict_to_group','0')=='1')
			{
			$userlist = $userops->LoadUsersInGroup($this->GetOption('group'));
			}
		else
			{
			$userlist = $userops->LoadUsers();
			}
		for($i=0;$i<count($userlist);$i++)
			{
			$name = array();
			if ($this->GetOption('show_userfirstname','0')=='1')
				{
				array_push($name,$userlist[$i]->firstname);
				}
			if ($this->GetOption('show_userlastname','0')=='1')
				{
				array_push($name,$userlist[$i]->lastname);
				}
			if ($this->GetOption('show_username','0')=='1')
				{
				array_push($name,' ('.$userlist[$i]->username.')');
				}
			$sname = implode(' ',$name);
			$sorted[$sname]=($i+1);
			}
		return $mod->CreateInputDropdown($id, 'fbrp__'.$this->Id, $sorted, -1, $this->Value, 'id="'.$id. '_'.$this->Id.'" '.$js);
	}



    function StatusInfo()
	{
	    global $gCms;
	    $groupops =& $gCms->GetGroupOperations();
		$mod = &$this->form_ptr->module_ptr;
        $ret = $this->TemplateStatus();
		if ($this->GetOption('restrict_to_group','0')=='1')
			{
			$group = $groupops->LoadGroupByID($this->GetOption('group'));
			if ($group && isset($group->name))
				{
				$ret .= ', '.$mod->Lang('restricted_to_group',$group->name);
				}
			}
        return $ret;
	}
	
	function PrePopulateAdminForm($formDescriptor)
	{
	    global $gCms;
	    $groupops =& $gCms->GetGroupOperations();
	    $groups = $groupops->LoadGroups();
		$mod = &$this->form_ptr->module_ptr;

		list($main,$adv) = $this->PrePopulateAdminFormBase($formDescriptor);
		array_push($main,array($mod->Lang('title_select_one_message'),
			$mod->CreateInputText($formDescriptor, 'fbrp_opt_select_one',
			$this->GetOption('select_one',$mod->Lang('select_one')),25,128)));
		array_push($main,array($mod->Lang('title_show_userfirstname'),
				$mod->CreateInputHidden($formDescriptor,'fbrp_opt_show_userfirstname','0').
				$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_show_userfirstname', '1',
				$this->GetOption('show_userfirstname','1'))));
			array_push($main,array($mod->Lang('title_show_userlastname'),
					$mod->CreateInputHidden($formDescriptor,'fbrp_opt_show_userlastname','0').
					$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_show_userlastname', '1',
					$this->GetOption('show_userlastname','1'))));
		array_push($main,array($mod->Lang('title_show_username'),
				$mod->CreateInputHidden($formDescriptor,'fbrp_opt_show_username','0').
				$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_show_username', '1',
				$this->GetOption('show_username','0'))));
				

		$items = array();
		foreach ($groups as $thisGroup)
			{
			$items[$thisGroup->name]=$thisGroup->id;
			}
		
		array_push($main,array($mod->Lang('title_restrict_to_group'),
				$mod->CreateInputHidden($formDescriptor,'fbrp_opt_restrict_to_group','0').
				$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_restrict_to_group', '1',
				$this->GetOption('restrict_to_group','0')).
				$mod-> CreateInputDropdown($formDescriptor, 'fbrp_opt_group', $items, -1, $this->GetOption('group',''))
				));
				
		return array('main'=>$main,'adv'=>$adv);
	}

	function PostPopulateAdminForm(&$mainArray, &$advArray)
	{
		$mod = &$this->form_ptr->module_ptr;
		// remove the "hide css" field
		$hideIndex = -1;
		for ($i=0;$i<count($advArray);$i++)
			{
			if ($advArray[$i]->title == $mod->Lang('title_field_css_class'))
				{
				$hideIndex = $i;
				}
			}
		if ($hideIndex != -1)
			{
			array_splice($advArray, $hideIndex,1);
			}
		if (count($advArray) == 0)
			{
			$advArray[0]->title = $mod->Lang('tab_advanced');
			$advArray[0]->input = $mod->Lang('title_no_advanced_options');
			}
	}

	function GetHumanReadableValue($as_string=true)
	{
	    global $gCms;
	    $userops =& $gCms->GetUserOperations();
		$mod = &$this->form_ptr->module_ptr;

		if ($this->GetOption('restrict_to_group','0')=='1')
			{
			$userlist = $userops->LoadUsersInGroup($this->GetOption('group'));
			}
		else
			{
			$userlist = $userops->LoadUsers();
			}
		if (isset($userlist[$this->Value - 1]))
			{
			$ret = $userlist[$this->Value - 1]->firstname . ' '. $userlist[$this->Value - 1]->lastname;
			}
		else
			{
			$ret = $mod->Lang('unspecified');
			}
		if ($as_string)
			{
			return $ret;
			}
		else
			{
			return array($ret);
			}
		
	}
	
	function DisposeForm($returnid)
	{
	    global $gCms;
	    $userops =& $gCms->GetUserOperations();
		$mod = &$this->form_ptr->module_ptr;

		if ($this->GetOption('restrict_to_group','0')=='1')
			{
			$userlist = $userops->LoadUsersInGroup($this->GetOption('group'));
			}
		else
			{
			$userlist = $userops->LoadUsers();
			}
		$dest = array($userlist[$this->Value - 1]->email);
		return $this->SendForm($dest,$this->GetOption('email_subject'));
	}


	function AdminValidate()
    {
		$mod = &$this->form_ptr->module_ptr;
		$ret = true;
		$message = "";
		if (! preg_match(($mod->GetPreference('relaxed_email_regex','0')==0?$mod->email_regex:$mod->email_regex_relaxed),$this->GetOption('email_from_address')))
			{
    	       	$ret = false;
                $message .= $mod->Lang('not_valid_email',$this->GetOption('email_from_address')) . '<br/>';
			}
        return array($ret,$message);
    }
    
    function Validate()
    {
         $mod = &$this->form_ptr->module_ptr;
         $result = true;
         $message = '';

         if ($this->Value == false)
            {
            $result = false;
            $message .=
$mod->Lang('must_specify_one_destination').'</br>';
            }
        return array($result,$message);
    }

}
?>
]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionFile.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionFileDirector.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/* 
   FormBuilder. Copyright (c) 2005-2006 Samuel Goldstein <sjg@cmsmodules.com>
   More info at http://dev.cmsmadesimple.org/projects/formbuilder
   
   A Module for CMS Made Simple, Copyright (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
  This project's homepage is: http://www.cmsmadesimple.org

   This file: Copyright (c) 2007 Robert Campbell <calguy1000@hotmail.com>
   All rights reserved.
*/

class fbDispositionFileDirector extends fbFieldBase 
{
  var $fileCount;
  var $fileAdd;
  var $sampleTemplateCode;
  var $sampleHeader;
  var $dflt_filepath;

  function fbDispositionFileDirector(&$form_ptr, &$params)
  {
    $this->fbFieldBase($form_ptr, $params);
    $mod = &$form_ptr->module_ptr;
    $this->Type = 'DispositionFileDirector';
    $this->IsDisposition = true;
    $this->DisplayInSubmission = false;
    $this->DisplayInForm = true;
    $this->HasAddOp = true;
    $this->HasDeleteOp = true;
    $this->sortable = false;
    $this->fileAdd = 0;

    global $gCms;
    $config =& $gCms->getConfig();
    $this->dflt_filepath = $config['uploads_path'];
  }


  function DoOptionAdd(&$params)
  {
    $this->fileAdd = 1;
  }

  function DoOptionDelete(&$params)
  {
    $delcount = 0;
    foreach ($params as $thisKey=>$thisVal)
      {
	if (substr($thisKey,0,9) == 'fbrp_del_')
	  {
	    $this->RemoveOptionElement('destination_filename', $thisVal - $delcount);
	    $this->RemoveOptionElement('destination_displayname', $thisVal - $delcount);
	    $delcount++;
	  }
      }
  }

  function countFiles()
  {
    $tmp = &$this->GetOptionRef('destination_filename');
    if (is_array($tmp))
      {
	$this->fileCount = count($tmp);
      }
    elseif ($tmp !== false)
      {
	$this->fileCount = 1;
      }
    else
      {
	$this->fileCount = 0;
      }
  }

  function GetFieldInput($id, &$params, $returnid)
  {
    $mod = &$this->form_ptr->module_ptr;
    $js = $this->GetOption('javascript','');
	
    // why all this? Associative arrays are not guaranteed to preserve
    // order, except in "chronological" creation order.
    $sorted =array();
    if ($this->GetOption('select_one','') != '')
      {
	$sorted[' '.$this->GetOption('select_one','')]='';
      }
    else
      {
	$sorted[' '.$mod->Lang('select_one')]='';
      }
    $displaynames = &$this->GetOptionRef('destination_displayname');
    
    if (count($displaynames) > 1)
      {
	for($i=0;$i<count($displaynames);$i++)
	  {
	    $sorted[$displaynames[$i]]=($i+1);
	  }
      }
    else
      {
	$sorted[$displaynames] = '1';
      }
    return $mod->CreateInputDropdown($id, 'fbrp__'.$this->Id, $sorted, -1, $this->Value, 'id="'.$id. '_'.$this->Id.'" '.$js);
  }

  function StatusInfo()
  {
    $this->countFiles();
    $mod=&$this->form_ptr->module_ptr;
    $ret= $mod->Lang('file_count',$this->fileCount);
    return $ret;
  }

  function DisposeForm($returnid)
  {
	global $gCms;
	$options = $gCms->GetConfig();
    $mod=&$this->form_ptr->module_ptr;
    $form=&$this->form_ptr;
    $count = 0;
    while (! $mod->GetFileLock() && $count<200)
      {
	$count++;
	usleep(500);
      }
    if ($count == 200)
      {
	return array(false, $mod->Lang('submission_error_file_lock'));
      }


    $dir = $this->GetOption('file_path',$this->dflt_filepath).'/';
    $filespec = $dir.
      preg_replace("/[^\w\d\.]|\.\./", "_", 
		   $this->GetOptionElement('destination_filename',
					   ($this->Value - 1)));

    $line = '';
    if (! file_exists($filespec))
      {
	$header = $this->GetOption('file_header','');
	if ($header == '')
	  {
	    $header = $form->createSampleHeader();
	  } 
	$header .= "\n";
      }
    $template = $this->GetOption('file_template','');
    if ($template == '')
      {
	$template = $form->createSampleTemplate();
      }
    $line = $template;

	$form->setFinishedFormSmarty();
    $newline = $mod->ProcessTemplateFromData( $line );
	$replchar = $this->GetOption('newlinechar','');
	if ($replchar != '')
		{
		$newline = rtrim($newline,"\r\n");
    	$newline = preg_replace('/[\n\r]/',$replchar,$newline);
		}
    if (substr($newline,-1,1) != "\n")
      {
	  $newline .= "\n";
      }
    $f2 = fopen($filespec,"a");
    fclose($f2); 
    $mod->ReturnFileLock();
    return array(true,'');        
  }

  function MakeVar($string)
  {
    $maxvarlen = 24;
    $string = strtolower(preg_replace('/\s+/','_',$string));
    $string = strtolower(preg_replace('/\W/','_',$string));
    if (strlen($string) > $maxvarlen)
      {
	$string = substr($string,0,$maxvarlen);
	$pos = strrpos($string,'_');
	if ($pos !== false)
	  {
	    $string = substr($string,0,$pos);
	  }
      }
    return $string;
  }

  function createSampleHeader()
  {
    $mod = &$this->form_ptr->module_ptr;
    $others = &$this->form_ptr->GetFields();
    $fields = array();
    for($i=0;$i<count($others);$i++)
      {
	if ($others[$i]->DisplayInSubmission())
	  {
	    array_push($fields,$others[$i]->GetName());
	  }
      }
    return implode('{$TAB}',$fields);
  }


  function createSampleTemplate()
  {
    $mod = &$this->form_ptr->module_ptr;
    $others = &$this->form_ptr->GetFields();
    $fields = array();
    for($i=0;$i<count($others);$i++)
      {
	if ($others[$i]->DisplayInSubmission())
	  {
	    array_push($fields,'{$' . $this->MakeVar($others[$i]->GetName()) . '}');
	  }
      }
    return implode('{$TAB}',$fields);
  }


  function PrePopulateAdminForm($formDescriptor)
  {
    $mod = &$this->form_ptr->module_ptr;

    $this->countFiles();
    if( $this->fileAdd > 0 )
      {
	$this->fileCount += $this->fileAdd;
	$this->fileAdd = 0;
      }

    $dests = '<table class="module_fb_table"><tr><th>'.$mod->Lang('title_selection_displayname').'</th><th>'.
      $mod->Lang('title_destination_filename').'</th><th>'.
      $mod->Lang('title_delete').'</th></tr>';

    for ($i=0;$i<($this->fileCount>1?$this->fileCount:1);$i++)
      {
	$dests .=  '<tr><td>'.
	  $mod->CreateInputText($formDescriptor, 'fbrp_opt_destination_displayname[]',$this->GetOptionElement('destination_displayname',$i),25,128).
	  '</td><td>'.
	  $mod->CreateInputText($formDescriptor, 'fbrp_opt_destination_filename[]',$this->GetOptionElement('destination_filename',$i),25,128).
	  '</td><td>'.
	  $mod->CreateInputCheckbox($formDescriptor, 'fbrp_del_'.$i, $i,-1).
	  '</td></tr>';
      }
    $dests .= '</table>';

    $main = array();
    $adv = array();
    $parmMain = array();
    $parmMain['opt_file_template']['is_oneline']=true;
    $parmMain['opt_file_header']['is_oneline']=true;
    $parmMain['opt_file_header']['is_header']=true;
    array_push($main,array($mod->Lang('title_select_one_message'),
			   $mod->CreateInputText($formDescriptor, 
						 'fbrp_opt_select_one',
	    $this->GetOption('select_one',$mod->Lang('select_one')),25,128)));
    array_push($main,array($mod->Lang('title_director_details'),$dests));

    array_push($adv,array($mod->Lang('title_file_path'),
			  $mod->CreateInputText($formDescriptor,
						'fbrp_opt_file_path',
						$this->GetOption('file_path',$this->dflt_filepath),40,128)));
    array_push($adv,array($mod->Lang('title_file_template'),
			  array($mod->CreateTextArea(false, $formDescriptor,
						     htmlspecialchars($this->GetOption('file_template','')),'fbrp_opt_file_template', 'module_fb_area_short', '','',0,0),$this->form_ptr->AdminTemplateHelp($formDescriptor,$parmMain))));
    array_push($adv,array($mod->Lang('title_file_header'),
			  $mod->CreateTextArea(false, $formDescriptor,
					       htmlspecialchars($this->GetOption('file_header','')),'fbrp_opt_file_header', 'module_fb_area_short', '','',0,0)));
    array_push($main,array($mod->Lang('title_newline_replacement'),
			   $mod->CreateInputText($formDescriptor, 'fbrp_opt_newlinechar',
						 $this->GetOption('newlinechar',''),5,15).'<br />'.
						$mod->Lang('title_newline_replacement_help')));

    return array('main'=>$main,'adv'=>$adv);
  }

  function PostPopulateAdminForm(&$mainArray, &$advArray)
  {
    //$this->HiddenDispositionFields($mainArray, $advArray);
  }
}

?>
]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionFormBrowser.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionFromEmailAddressField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCnJlcXVpcmVfb25jZShkaXJuYW1lKF9fRklMRV9fKS4nL0Rpc3Bvc2l0aW9uRW1haWxCYXNlLmNsYXNzLnBocCcpOwoKY2xhc3MgZmJEaXNwb3NpdGlvbkZyb21FbWFpbEFkZHJlc3NGaWVsZCBleHRlbmRzIGZiRGlzcG9zaXRpb25FbWFpbEJhc2UgewoKCWZ1bmN0aW9uIGZiRGlzcG9zaXRpb25Gcm9tRW1haWxBZGRyZXNzRmllbGQoJiRmb3JtX3B0ciwgJiRwYXJhbXMpCgl7CiAgICAgICR0aGlzLT5mYkRpc3Bvc2l0aW9uRW1haWxCYXNlKCRmb3JtX3B0ciwgJHBhcmFtcyk7CiAgICAgICRtb2QgPSAmJGZvcm1fcHRyLT5tb2R1bGVfcHRyOwoJCSR0aGlzLT5UeXBlID0gJ0Rpc3Bvc2l0aW9uRnJvbUVtYWlsQWRkcmVzc0ZpZWxkJzsKICAgICAgJHRoaXMtPklzRGlzcG9zaXRpb24gPSB0cnVlOwoJCSR0aGlzLT5EaXNwbGF5SW5Gb3JtID0gdHJ1ZTsKCQkkdGhpcy0+VmFsaWRhdGlvblR5cGVzID0gYXJyYXkoCgkJCSRtb2QtPkxhbmcoJ3ZhbGlkYXRpb25fbm9uZScpPT4nbm9uZScsCiAgICAgICAgICAgICRtb2QtPkxhbmcoJ3ZhbGlkYXRpb25fZW1haWxfYWRkcmVzcycpPT4nZW1haWwnLAogICAgICAgICAgICApOwoJJHRoaXMtPm1vZGlmaWVzT3RoZXJGaWVsZHMgPSB0cnVlOwoJJHRoaXMtPk5vblJlcXVpcmFibGVGaWVsZCA9IGZhbHNlOwoJCgl9CgoJZnVuY3Rpb24gR2V0RmllbGRJbnB1dCgkaWQsICYkcGFyYW1zLCAkcmV0dXJuaWQpCgl7CgkJJG1vZCA9ICYkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CgkJJGpzID0gJHRoaXMtPkdldE9wdGlvbignamF2YXNjcmlwdCcsJycpOwoJCSRyZXRzdHIgPSAkbW9kLT5DcmVhdGVJbnB1dFRleHQoJGlkLCAnZmJycF9fJy4kdGhpcy0+SWQuJ1tdJywKCQkJaHRtbHNwZWNpYWxjaGFycygkdGhpcy0+VmFsdWVbMF0sIEVOVF9RVU9URVMpLAogICAgICAgICAgIDI1LDEyOCwkanMpOwogCQlpZiAoJHRoaXMtPkdldE9wdGlvbignc2VuZF91c2VyX2NvcHknLCduJykgPT0gJ2MnKQoJCQl7CgkJCSRyZXRzdHIgLj0gJG1vZC0+Q3JlYXRlSW5wdXRDaGVja2JveCgkaWQsICdmYnJwX18nLiR0aGlzLT5JZC4nW10nLCAxLAoJCQkJCTAsJyBpZD0iJy4kdGhpcy0+SWQuJ18yIicpOwoJCQkkcmV0c3RyIC49ICc8bGFiZWwgZm9yPSInLiR0aGlzLT5JZC4nXzIiPicuJHRoaXMtPkdldE9wdGlvbignc2VuZF91c2VyX2xhYmVsJywKCQkJCSRtb2QtPkxhbmcoJ3RpdGxlX3NlbmRfbWVfYV9jb3B5JykpLic8L2xhYmVsPic7CgkJCX0KCQlyZXR1cm4gJHJldHN0cjsKCX0KCiAgCWZ1bmN0aW9uIEdldFZhbHVlKCkKICAJewogICAgCXJldHVybiAkdGhpcy0+VmFsdWVbMF07CiAgCX0KCglmdW5jdGlvbiBHZXRIdW1hblJlYWRhYmxlVmFsdWUoJGFzX3N0cmluZz10cnVlKQoJewoJCXJldHVybiAkdGhpcy0+VmFsdWVbMF07Cgl9CgoJZnVuY3Rpb24gRGlzcG9zZUZvcm0oKQoJewogICAgICBpZiAoJHRoaXMtPkhhc1ZhbHVlKCkgIT0gZmFsc2UgJiYgCgkJCSgKCQkJCSR0aGlzLT5HZXRPcHRpb24oJ3NlbmRfdXNlcl9jb3B5JywnbicpID09ICdhJwoJCQkJfHwKCQkJCSgkdGhpcy0+R2V0T3B0aW9uKCdzZW5kX3VzZXJfY29weScsJ24nKSA9PSAnYycgJiYgaXNzZXQoJHRoaXMtPlZhbHVlWzFdKSAmJiAkdGhpcy0+VmFsdWVbMV0gPT0gMSkKCQkJKQoJCSApCgkJCXsKCQkJcmV0dXJuICR0aGlzLT5TZW5kRm9ybSgkdGhpcy0+VmFsdWVbMF0sJHRoaXMtPkdldE9wdGlvbignZW1haWxfc3ViamVjdCcpKTsKCQkJfQoJICBlbHNlCgkJewogICAgICAgIHJldHVybiBhcnJheSh0cnVlLCcnKTsKICAgICAgICB9Cgl9CgoKCWZ1bmN0aW9uIFN0YXR1c0luZm8oKQoJewoJCXJldHVybiAkdGhpcy0+VGVtcGxhdGVTdGF0dXMoKTsKCX0KCglmdW5jdGlvbiBQcmVQb3B1bGF0ZUFkbWluRm9ybSgkZm9ybURlc2NyaXB0b3IpCgl7CgkJJG1vZCA9ICYkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CgkJbGlzdCgkbWFpbiwkYWR2KSA9ICR0aGlzLT5QcmVQb3B1bGF0ZUFkbWluRm9ybUJhc2UoJGZvcm1EZXNjcmlwdG9yKTsKCQkkb3B0cyA9IGFycmF5KCRtb2QtPkxhbmcoJ29wdGlvbl9uZXZlcicpPT4nbicsJG1vZC0+TGFuZygnb3B0aW9uX3VzZXJfY2hvaWNlJyk9PidjJywkbW9kLT5MYW5nKCdvcHRpb25fYWx3YXlzJyk9PidhJyk7CgkJYXJyYXlfcHVzaCgkbWFpbixhcnJheSgkbW9kLT5MYW5nKCd0aXRsZV9zZW5kX3VzZXJjb3B5JyksCgkJCSRtb2QtPkNyZWF0ZUlucHV0RHJvcGRvd24oJGZvcm1EZXNjcmlwdG9yLCAnZmJycF9vcHRfc2VuZF91c2VyX2NvcHknLCAkb3B0cywgLTEsICR0aGlzLT5HZXRPcHRpb24oJ3NlbmRfdXNlcl9jb3B5JywnbicpKSkpOwoJCWFycmF5X3B1c2goJG1haW4sYXJyYXkoJG1vZC0+TGFuZygndGl0bGVfc2VuZF91c2VyY29weV9sYWJlbCcpLAoJCQkkbW9kLT5DcmVhdGVJbnB1dFRleHQoJGZvcm1EZXNjcmlwdG9yLCAnZmJycF9vcHRfc2VuZF91c2VyX2xhYmVsJywgJHRoaXMtPkdldE9wdGlvbignc2VuZF91c2VyX2xhYmVsJywKCQkJCSRtb2QtPkxhbmcoJ3RpdGxlX3NlbmRfbWVfYV9jb3B5JykpLDI1LDEyNSkpKTsKCQlyZXR1cm4gYXJyYXkoJ21haW4nPT4kbWFpbiwnYWR2Jz0+JGFkdik7Cgl9CgoJZnVuY3Rpb24gUG9zdFBvcHVsYXRlQWRtaW5Gb3JtKCYkbWFpbkFycmF5LCAmJGFkdkFycmF5KQoJewoJCSRtb2QgPSAmJHRoaXMtPmZvcm1fcHRyLT5tb2R1bGVfcHRyOwoJCSRoaWRlSW5kZXggPSAtMTsKCQlmb3IgKCRpPTA7JGk8Y291bnQoJG1haW5BcnJheSk7JGkrKykKCQkJewoJCQlpZiAoJG1haW5BcnJheVskaV0tPnRpdGxlID09ICRtb2QtPkxhbmcoJ3RpdGxlX2VtYWlsX2Zyb21fYWRkcmVzcycpKQoJCQkJewoJCQkJJGhpZGVJbmRleCA9ICRpOwoJCQkJfQoJCQl9CgkJaWYgKCRoaWRlSW5kZXggIT0gLTEpCgkJCXsKCQkJYXJyYXlfc3BsaWNlKCRtYWluQXJyYXksICRoaWRlSW5kZXgsMSk7CgkJCX0KCQkvLyByZW1vdmUgdGhlICJoaWRlIGNzcyIgZmllbGQKCQkkaGlkZUluZGV4ID0gLTE7CgkJZm9yICgkaT0wOyRpPGNvdW50KCRhZHZBcnJheSk7JGkrKykKCQkJewoJCQlpZiAoJGFkdkFycmF5WyRpXS0+dGl0bGUgPT0gJG1vZC0+TGFuZygndGl0bGVfZmllbGRfY3NzX2NsYXNzJykpCgkJCQl7CgkJCQkkaGlkZUluZGV4ID0gJGk7CgkJCQl9CgkJCX0KCQlpZiAoJGhpZGVJbmRleCAhPSAtMSkKCQkJewoJCQlhcnJheV9zcGxpY2UoJGFkdkFycmF5LCAkaGlkZUluZGV4LDEpOwoJCQl9CgkJaWYgKGNvdW50KCRhZHZBcnJheSkgPT0gMCkKCQkJewoJCQkkYWR2QXJyYXlbMF0tPnRpdGxlID0gJG1vZC0+TGFuZygndGFiX2FkdmFuY2VkJyk7CgkJCSRhZHZBcnJheVswXS0+aW5wdXQgPSAkbW9kLT5MYW5nKCd0aXRsZV9ub19hZHZhbmNlZF9vcHRpb25zJyk7CgkJCX0KCX0KCgoJZnVuY3Rpb24gTW9kaWZ5T3RoZXJGaWVsZHMoKQoJewoJCSRtb2QgPSAmJHRoaXMtPmZvcm1fcHRyLT5tb2R1bGVfcHRyOwoJCSRvdGhlcnMgPSAmJHRoaXMtPmZvcm1fcHRyLT5HZXRGaWVsZHMoKTsKCQlpZiAoJHRoaXMtPlZhbHVlICE9PSBmYWxzZSkKCQkJewoJCQlmb3IoJGk9MDskaTxjb3VudCgkb3RoZXJzKTskaSsrKQoJCQkJewoJCQkJJHJlcGxWYWwgPSAnJzsKCQkJCWlmICgkb3RoZXJzWyRpXS0+SXNEaXNwb3NpdGlvbigpICYmIGlzX3N1YmNsYXNzX29mKCRvdGhlcnNbJGldLCdmYkRpc3Bvc2l0aW9uRW1haWxCYXNlJykpCgkJCQkJewoJCQkJCSRvdGhlcnNbJGldLT5TZXRPcHRpb24oJ2VtYWlsX2Zyb21fYWRkcmVzcycsJHRoaXMtPlZhbHVlWzBdKTsKCQkJCQl9CgkJCQl9CgkJCX0KCX0KCglmdW5jdGlvbiBWYWxpZGF0ZSgpCgl7CgogIAkJJHRoaXMtPnZhbGlkYXRlZCA9IHRydWU7CiAgCQkkdGhpcy0+dmFsaWRhdGlvbkVycm9yVGV4dCA9ICcnOwoJCSRyZXN1bHQgPSB0cnVlOwoJCSRtZXNzYWdlID0gJyc7CgkJJG1vZCA9ICYkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CgkJaWYgKCR0aGlzLT5WYWxpZGF0aW9uVHlwZSAhPSAnbm9uZScpCgkJCXsKCQkgICAgICBpZiAoJHRoaXMtPlZhbHVlICE9PSBmYWxzZSAmJgoJCSAgICAgICAgICAgICEgcHJlZ19tYXRjaCgoJG1vZC0+R2V0UHJlZmVyZW5jZSgncmVsYXhlZF9lbWFpbF9yZWdleCcsJzAnKT09MD8kbW9kLT5lbWFpbF9yZWdleDokbW9kLT5lbWFpbF9yZWdleF9yZWxheGVkKSwgJHRoaXMtPlZhbHVlWzBdKSkKCQkgICAgICAgICB7CgkJICAgICAgICAgJHRoaXMtPnZhbGlkYXRlZCA9IGZhbHNlOwoJCSAgICAgICAgICR0aGlzLT52YWxpZGF0aW9uRXJyb3JUZXh0ID0gJG1vZC0+TGFuZygncGxlYXNlX2VudGVyX2FuX2VtYWlsJywkdGhpcy0+TmFtZSk7CgkJICAgICAgICAgfQoJCQl9CgkJcmV0dXJuIGFycmF5KCR0aGlzLT52YWxpZGF0ZWQsICR0aGlzLT52YWxpZGF0aW9uRXJyb3JUZXh0KTsKCX0KfQoKPz4K]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionMultiselectFileDirector.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/* 
   FormBuilder. Copyright (c) 2005-2006 Samuel Goldstein <sjg@cmsmodules.com>
   More info at http://dev.cmsmadesimple.org/projects/formbuilder
   
   A Module for CMS Made Simple, Copyright (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
  This project's homepage is: http://www.cmsmadesimple.org

   This file: Copyright (c) 2007 Robert Campbell <calguy1000@hotmail.com>
   All rights reserved.
*/

class fbDispositionMultiselectFileDirector extends  fbFieldBase 
{
  var $fileCount;
  var $fileAdd;
  var $sampleTemplateCode;
  var $sampleHeader;
  var $dflt_filepath;

  function fbDispositionMultiselectFileDirector(&$form_ptr, &$params)
  {
    $this->fbFieldBase($form_ptr, $params);
    $mod = &$form_ptr->module_ptr;
    $this->Type = 'DispositionMultiselectFileDirector';
    $this->IsDisposition = true;
    $this->DisplayInForm = true;
    $this->DisplayInSubmission = false;
    $this->DisplayInSubmission = true;
    $this->HasAddOp = true;
    $this->HasDeleteOp = true;
    $this->hasMultipleFormComponents = true;
    $this->sortable = false;
    $this->fileAdd = 0;

    global $gCms;
    $config =& $gCms->getConfig();
    $this->dflt_filepath = $config['uploads_path'];
  }


  function DoOptionAdd(&$params)
  {
    $this->fileAdd = 1;
  }

  function DoOptionDelete(&$params)
  {
    $delcount = 0;
    foreach ($params as $thisKey=>$thisVal)
      {
	if (substr($thisKey,0,9) == 'fbrp_del_')
	  {
	    $this->RemoveOptionElement('destination_filename', $thisVal - $delcount);
	    $this->RemoveOptionElement('destination_displayname', $thisVal - $delcount);
	    $delcount++;
	  }
      }
  }

  function countFiles()
  {
    $tmp = &$this->GetOptionRef('destination_filename');
    if (is_array($tmp))
      {
	$this->fileCount = count($tmp);
      }
    elseif ($tmp !== false)
      {
	$this->fileCount = 1;
      }
    else
      {
	$this->fileCount = 0;
      }
  }

  function GetFieldInput($id, &$params, $returnid)
  {
    $mod = &$this->form_ptr->module_ptr;
    $js = $this->GetOption('javascript','');
	
    // why all this? Associative arrays are not guaranteed to preserve
    // order, except in "chronological" creation order.
    $displaynames = &$this->GetOptionRef('destination_displayname');
    $displayfiles = &$this->GetOptionRef('destination_filename');

    $fields = array();
    for( $i = 0; $i < count($displaynames); $i++ )
      {
	$label = '';
	$ctrl = new stdClass();
	$ctrl->name = '<label for="'.$id.'_'.$this->Id.'_'.$i.'">'.$displaynames[$i].'</label>';
	$ctrl->title = $displaynames[$i];
	$ctrl->input = $mod->CreateInputCheckbox($id,
						 'fbrp__'.$this->Id.'[]', 
						 $i+1,'-1',
						 sprintf(' id="%s_%s_%s" ',
							 $id, $this->Id,$i).$js);
	$fields[] = $ctrl;
      }
    return $fields;
  }

  function GetHumanReadableValue($as_string=true)
  {
    $form = &$this->form_ptr;
    $tmp = array();
    if( is_array($this->Value) )
      {
	foreach( $this->Value as $idx )
	  {
	    if( empty($idx) ) continue;
	    
	    $idx--;
	    
	    $str = $this->GetOptionElement('destination_value',$idx);
	    if( empty($str) )
	      {
		$str = $this->GetOptionElement('destination_displayname',$idx);
	      }
	    $tmp[] = $str;
	  } // foreach
      } // if

	if ($as_string)
		{
		return join($form->GetAttr('list_delimiter',','),$tmp);
		}
	else
		{
    	return $tmp;
		}
  }

  function StatusInfo()
  {
    $this->countFiles();
    $mod=&$this->form_ptr->module_ptr;
    $ret= $mod->Lang('file_count',$this->fileCount);
    return $ret;
  }

  function DisposeForm($returnid)
  {

    $mod=&$this->form_ptr->module_ptr;
    $count = 0;
    while (! $mod->GetFileLock() && $count<200)
      {
	$count++;
	usleep(500);
      }
    if ($count == 200)
      {
	return array(false, $mod->Lang('submission_error_file_lock'));
      }


    $dir = $this->GetOption('file_path',$this->dflt_filepath).'/';

	$this->form_ptr->setFinishedFormSmarty();
    $header = $this->GetOption('file_header','');
    if ($header == '')
      {
	$header = $this->createSampleHeader();
      } 
    $header .= "\n";

    $template = $this->GetOption('file_template','');
    if ($template == '')
      {
	$template = $this->createSampleTemplate();
      }

    // Begin output to files
    if( is_array($this->Value) )
      {
	foreach( $this->Value as $idx )
	  {
	    // I dunno why it's empty sometimes, but...
	    if( empty($idx) ) continue;
	    
	    $idx--;
	    
	    // get the filename
	    $filespec = $dir.
	      preg_replace("/[^\w\d\.]|\.\./", "_", 
			   $this->GetOptionElement('destination_filename',$idx));
	    
	    $line = $template;
	    if (! file_exists($filespec))
	      {
		$line = $header.$template;
	      }
	    
	    $newline = $mod->ProcessTemplateFromData( $line );
	    if (substr($newline,-1,1) != "\n")
	      {
		$newline .= "\n";
	      }	
	    
	    $f2 = fopen($filespec,"a");
	    fwrite($f2,$newline);
	    fclose($f2); 
	    
	  } // foreach
      } // if
    $mod->ReturnFileLock();
    return array(true,'');        
  }

  function MakeVar($string)
  {
    $maxvarlen = 24;
    $string = strtolower(preg_replace('/\s+/','_',$string));
    $string = strtolower(preg_replace('/\W/','_',$string));
    if (strlen($string) > $maxvarlen)
      {
	$string = substr($string,0,$maxvarlen);
	$pos = strrpos($string,'_');
	if ($pos !== false)
	  {
	    $string = substr($string,0,$pos);
	  }
      }
    return $string;
  }

  function PrePopulateAdminForm($formDescriptor)
  {
    $mod = &$this->form_ptr->module_ptr;

    $this->countFiles();
    if( $this->fileAdd > 0 )
      {
	$this->fileCount += $this->fileAdd;
	$this->fileAdd = 0;
      }

    $dests = '<table class="module_fb_table"><tr><th>'.$mod->Lang('title_selection_displayname').'</th><th>'.
      $mod->Lang('title_selection_value').'</th><th>'.
      $mod->Lang('title_destination_filename').'</th><th>'.
      $mod->Lang('title_delete').'</th></tr>';

    for ($i=0;$i<($this->fileCount>1?$this->fileCount:1);$i++)
      {
	$dests .=  '<tr><td>'.
	  $mod->CreateInputText($formDescriptor, 'fbrp_opt_destination_displayname[]',$this->GetOptionElement('destination_displayname',$i),25,128).
	  '</td><td>'.
	  $mod->CreateInputText($formDescriptor, 'fbrp_opt_destination_value[]',$this->GetOptionElement('destination_value',$i),25,128).'</td><td>'.
	  $mod->CreateInputText($formDescriptor, 'fbrp_opt_destination_filename[]',$this->GetOptionElement('destination_filename',$i),25,128).
	  '</td><td>'.
	  $mod->CreateInputCheckbox($formDescriptor, 'fbrp_del_'.$i, $i,-1).
	  '</td></tr>';
      }
    $dests .= '</table>';


    $main = array();
    $adv = array();
    $parmMain = array();
    $parmMain['opt_file_template']['is_oneline']=true;
    $parmMain['opt_file_header']['is_oneline']=true;
    $parmMain['opt_file_header']['is_header']=true;
    array_push($main,array($mod->Lang('title_select_one_message'),
			   $mod->CreateInputText($formDescriptor, 
						 'fbrp_opt_select_one',
	    $this->GetOption('select_one',$mod->Lang('select_one')),25,128)));
    array_push($main,array($mod->Lang('title_director_details'),$dests));

    array_push($adv,array($mod->Lang('title_file_path'),
			  $mod->CreateInputText($formDescriptor,
						'fbrp_opt_file_path',
						$this->GetOption('file_path',$this->dflt_filepath),40,128)));
    array_push($adv,array($mod->Lang('title_file_template'),
			  array($mod->CreateTextArea(false, $formDescriptor,
						     htmlspecialchars($this->GetOption('file_template','')),'fbrp_opt_file_template', 'module_fb_area_short', '','',0,0),$this->form_ptr->AdminTemplateHelp($formDescriptor,$parmMain))));
    array_push($adv,array($mod->Lang('title_file_header'),
			  $mod->CreateTextArea(false, $formDescriptor,
					       htmlspecialchars($this->GetOption('file_header','')),'fbrp_opt_file_header', 'module_fb_area_short', '','',0,0)));

    return array('main'=>$main,'adv'=>$adv);
  }

  function PostPopulateAdminForm(&$mainArray, &$advArray)
  {
    //$this->HiddenDispositionFields($mainArray, $advArray);
  }
}

?>
]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionPageRedirector.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/* 
   FormBuilder. Copyright (c) 2005-2006 Samuel Goldstein <sjg@cmsmodules.com>
   More info at http://dev.cmsmadesimple.org/projects/formbuilder
   
   A Module for CMS Made Simple, Copyright (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
  This project's homepage is: http://www.cmsmadesimple.org
*/

class fbDispositionPageRedirector extends fbFieldBase {

	var $addressCount;
	var $addressAdd;

	function fbDispositionPageRedirector(&$form_ptr, &$params)
	{
       	//$this->fbDispositionEmailBase($form_ptr, $params);
 	$this->fbFieldBase($form_ptr, $params);
        $mod = &$form_ptr->module_ptr;
		$this->Type = 'DispositionPageRedirector';
		$this->DisplayInForm = true;
		$this->NonRequirableField = false;
		$this->IsDisposition = true;
		$this->HasAddOp = true;
		$this->HasDeleteOp = true;
		$this->ValidationTypes = array(
       		);
       	$this->addressAdd = 0;
	}

	function GetOptionAddButton()
	{
		$mod = &$this->form_ptr->module_ptr;
		return $mod->Lang('add_destination');
	}

	function GetOptionDeleteButton()
	{
		$mod = &$this->form_ptr->module_ptr;
		return $mod->Lang('delete_destination');
	}

	function DoOptionAdd(&$params)
	{
		$this->addressAdd = 1;
	}

	function DoOptionDelete(&$params)
	{
		$delcount = 0;
		foreach ($params as $thisKey=>$thisVal)
			{
			if (substr($thisKey,0,9) == 'fbrp_del_')
				{
				$this->RemoveOptionElement('destination_page', $thisVal - $delcount);
				$this->RemoveOptionElement('destination_subject', $thisVal - $delcount);
				$delcount++;
				}
			}
	}

	function countAddresses()
	{
			$tmp = &$this->GetOptionRef('destination_page');
			if (is_array($tmp))
				{
	        	$this->addressCount = count($tmp);
	        	}
	        elseif ($tmp !== false)
	        	{
	        	$this->addressCount = 1;
	        	}
	        else
	        	{
	        	$this->addressCount = 0;
	        	}
	}

	function GetFieldInput($id, &$params, $returnid)
	{
		$mod = &$this->form_ptr->module_ptr;
		$js = $this->GetOption('javascript','');

		// why all this? Associative arrays are not guaranteed to preserve
		// order, except in "chronological" creation order.
		$sorted =array();
		if ($this->GetOption('select_one','') != '')
			{
			$sorted[' '.$this->GetOption('select_one','')]='';
			}
		else
			{
			$sorted[' '.$mod->Lang('select_one')]='';
			}
		$subjects = &$this->GetOptionRef('destination_subject');

		if (count($subjects) > 1)
			{
			for($i=0;$i<count($subjects);$i++)
				{
				$sorted[$subjects[$i]]=($i+1);
				}
			}
		else
			{
			$sorted[$subjects] = '1';
			}
		return $mod->CreateInputDropdown($id, 'fbrp__'.$this->Id, $sorted, -1, $this->Value, $js);
	}



    function StatusInfo()
	{
		$mod = &$this->form_ptr->module_ptr;
		$opt = $this->GetOption('destination_page','');
		
		if (is_array($opt))
		  {
		      $num = count($opt);
		  }
		elseif ($opt != '')
			{
			$num = 1;
			}
		else
		  {
          $num = 0;
          }
         $ret= $mod->Lang('destination_count',$num);
      //  $ret.= $this->TemplateStatus();
        return $ret;
	}
	
	function PrePopulateAdminForm($formDescriptor)
	{
   		global $gCms;
		global $id;
    		$contentops =& $gCms->GetContentOperations();
		$mod = &$this->form_ptr->module_ptr;

		$this->countAddresses();
		if ($this->addressAdd > 0)
			{
			$this->addressCount += $this->addressAdd;
			$this->addressAdd = 0;
			}
		$dests = '<table class="module_fb_table"><tr><th>'.$mod->Lang('title_selection_subject').'</th><th>'.
			$mod->Lang('title_destination_page').'</th><th>'.
			$mod->Lang('title_delete').'</th></tr>';


		for ($i=0;$i<($this->addressCount>1?$this->addressCount:1);$i++)
			{
			$dests .=  '<tr><td>';
            		$dests .= $mod->CreateInputText($formDescriptor, 'fbrp_opt_destination_subject[]',$this->GetOptionElement('destination_subject',$i),25,128);
            		$dests .= '</td><td>';
			$dests .=     			$contentops->CreateHierarchyDropdown('',$this->GetOptionElement('destination_page',$i), $id.'fbrp_opt_destination_page[]');
			$dests .= '</td><td>';
            		$dests .= $mod->CreateInputCheckbox($formDescriptor, 'fbrp_del_'.$i, $i,-1);
             		$dests .= '</td></tr>';
            		//$mod->CreateInputText($formDescriptor, 'opt_destination_page[]',$this->GetOptionElement('destination_page',$i),25,128).

			}
		$dests .= '</table>';
		// list($main,$adv) = $this->PrePopulateAdminFormBase($formDescriptor);
		$adv = array();
		$main = array();
		array_push($main,array($mod->Lang('title_select_one_message'),
			$mod->CreateInputText($formDescriptor, 'fbrp_opt_select_one',
			$this->GetOption('select_one',$mod->Lang('select_one')),25,128)));

		array_push($main,array($mod->Lang('title_director_details'),$dests));
		return array('main'=>$main,'adv'=>$adv);
	}

	function PostPopulateAdminForm(&$mainArray, &$advArray)
	{
		$mod = &$this->form_ptr->module_ptr;
		// remove the "required" field
		$reqIndex = -1;
		for ($i=0;$i<count($mainArray);$i++)
			{
			if ($mainArray[$i]->title == $mod->Lang('title_field_required'))
				{
				$reqIndex = $i;
				}
			}
		if ($reqIndex != -1)
			{
			array_splice($mainArray, $reqIndex,1);
			}
		// remove the "email subject" field
		$hideIndex = -1;
		for ($i=0;$i<count($mainArray);$i++)
			{
			if ($mainArray[$i]->title == $mod->Lang('title_email_subject'))
				{
				$hideIndex = $i;
				}
			}
		if ($hideIndex != -1)
			{
			array_splice($mainArray, $hideIndex,1);
			}
		// remove the "hide css" field
		$hideIndex = -1;
		for ($i=0;$i<count($advArray);$i++)
			{
			if ($advArray[$i]->title == $mod->Lang('title_field_css_class'))
				{
				$hideIndex = $i;
				}
			}
		if ($hideIndex != -1)
			{
			array_splice($advArray, $hideIndex,1);
			}
		if (count($advArray) == 0)
			{
			$advArray[0]->title = $mod->Lang('tab_advanced');
			$advArray[0]->input = $mod->Lang('title_no_advanced_options');
			}
	}

	function GetHumanReadableValue($as_string)
	{
		$mod = &$this->form_ptr->module_ptr;
		if ($this->HasValue())
			{
			$ret = $this->GetOptionElement('destination_page',($this->Value - 1));
			}
		else
			{
			$ret = $mod->Lang('unspecified');
			}
		if ($as_string)
			{
			return $ret;
			}
		else
			{
			return array($ret);
			}

	}
	
	function DisposeForm($returnid)
	{
		// If needed, make sure other dispositions get run 1st.See  Dispose($returnid) in Form class.
		// Not really needed, the 'FromEmailAddressField' already calls modify other fields, Just need to make sure the the email results things are listed before this one and everything should be fine.
		// print_r($this->GetOptionElement('destination_page',($this->Value - 1)));
    		global $gCms;
    		$mod = &$this->form_ptr->module_ptr;
    		$mod->RedirectContent($this->GetOptionElement('destination_page',($this->Value - 1)));
		//return $this->SendForm($this->GetOptionElement('destination_page',($this->Value - 1)),
		//	$this->GetOptionElement('destination_subject',($this->Value - 1)));
		return array(true, 'everything worked');
	}


	function AdminValidate()
	{
		$mod = &$this->form_ptr->module_ptr;
    		$opt = $this->GetOption('destination_page');
  		list($ret, $message) = $this->DoesFieldHaveName();
		if ($ret)
			{
			list($ret, $message) = $this->DoesFieldNameExist();
			}		
		if (count($opt) == 0)
			{
			$ret = false;
			$message .= $mod->Lang('must_specify_one_destination').'</br>';
			}
	        return array($ret,$message);
    }

}
?>
]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionUserTag.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/FieldBase.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/* 
   FormBuilder. Copyright (c) 2005-2006 Samuel Goldstein <sjg@cmsmodules.com>
   More info at http://dev.cmsmadesimple.org/projects/formbuilder
   
   A Module for CMS Made Simple, Copyright (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
  This project's homepage is: http://www.cmsmadesimple.org
*/

class fbFieldBase {

  var $Id=-1;
  var $FormId;
  var $Name;
  var $Type;
  var $Required=-1;
  var $OrderBy;
  var $HideLabel=-1;
  var $HasLabel=1;
  var $NeedsDiv=1;
  var $SmartyEval;

  var $ValidationTypes;
  var $ValidationType;
  var $validated = true;
  var $validationErrorText;

  var $DisplayInForm;
  var $DisplayInSubmission;
  var $DispositionPermitted;
  var $IsComputedOnSubmission;
  var $NonRequirableField;
  var $HasAddOp;
  var $HasDeleteOp;
  var $HasUserAddOp;
  var $HasUserDeleteOp;
  var $modifiesOtherFields;
  var $hasMultipleFormComponents;
  var $labelSubComponents;

  var $Value=false;
  var $form_ptr;
  var $Options;
  var $loaded;
  var $sortable;

  function fbFieldBase(&$form_ptr, &$params)
  {

    $this->form_ptr = &$form_ptr;
    $mod = &$form_ptr->module_ptr;
    $this->Options = array();
    $this->DisplayInForm = true;
    $this->DisplayInSubmission = true;
    $this->IsDisposition = false;
    $this->ValidationTypes = array($mod->Lang('validation_none')=>'none');
    $this->loaded = false;
    $this->NonRequirableField = false;
    $this->HasAddOp = false;
    $this->HasDeleteOp = false;
    $this->HasUserAddOp = false;
    $this->HasUserDeleteOp = false;
    $this->modifiesOtherFields = false;
    $this->hasMultipleFormComponents = false;
    $this->DispositionPermitted = true;
    $this->SmartyEval = false;
    $this->labelSubComponents = true;
    $this->sortable = true;
    $this->IsComputedOnSubmission = false;

    if (isset($params['form_id']))
      {
	$this->FormId = $params['form_id'];
      }
    if (isset($params['field_id']))
      {
	$this->Id = $params['field_id'];
      }
    if (isset($params['fbrp_field_name']))
      {
	$this->Name = $params['fbrp_field_name'];
      }
    if (isset($params['fbrp_field_type']))
      {
	$this->Type = $params['fbrp_field_type'];
      }
    else
      {
	$this->Type = '';
      }
    if (isset($params['fbrp_order_by']))
      {
	$this->OrderBy = $params['fbrp_order_by'];
      }
    if (isset($params['fbrp_hide_label']))
      {
	$this->HideLabel = $params['fbrp_hide_label'];
      }
    else if (isset($params['fbrp_set_from_form']))
      {
	$this->HideLabel = 0;
      }
    if (isset($params['fbrp_required']))
      {
	$this->Required = $params['fbrp_required'];
      }
    else if (isset($params['fbrp_set_from_form']))
      {
	$this->Required = 0;
      }
    if (isset($params['fbrp_validation_type']))
      {
	$this->ValidationType = $params['fbrp_validation_type'];
      }

    foreach ($params as $thisParamKey=>$thisParamVal)
      {
	if (substr($thisParamKey,0,9) == 'fbrp_opt_')
	  {
	    $thisParamKey = substr($thisParamKey,9);
	    $this->Options[$thisParamKey] = $thisParamVal;
	  }
      }

    if (isset($params['fbrp__'.$this->Id]) &&
	(is_array($params['fbrp__'.$this->Id]) ||
	 strlen($params['fbrp__'.$this->Id]) > 0))
      {
	   $this->SetValue($params['fbrp__'.$this->Id]);
      }
  }

  function HasMultipleFormComponents()
  {
    return $this->hasMultipleFormComponents;
  }

  function LabelSubComponents()
  {
    return $this->labelSubComponents;
  }

  function ComputeOnSubmission()
  {
    return $this->IsComputedOnSubmission;
  }


  // override me 
  function ComputeOrder()
  {
  	return 0;
  }

  function HasMultipleValues()
  {
  	if ($this->hasMultipleFormComponents || $this->HasUserAddOp)
  		{
  		return true;
  		}
  	else
  		{
  		return false;
  		}
  }

  function GetFieldInputId($id, &$params, $returnid)
  {
    return $id.'fbrp__'.$this->Id;
  }

  function ModifiesOtherFields()
  {
    return $this->modifiesOtherFields;
  }

  // mechanism for fields/dispositions to inhibit other dispositions
  function DispositionIsPermitted()
  {
    return $this->DispositionPermitted;
  }

  // mechanism for fields/dispositions to inhibit other dispositions
  function SetDispositionPermission($permitted=true)
  {
    $this->DispositionPermitted = $permitted;
  }


  // override me if you need to do something after the form has been disposed
  function PostDispositionAction()
  {
	return;
  }

  // override me if you're just tweaking other fields before disposition
  function ModifyOtherFields()
  {
  }

  // override me with a form input string or something
  // this should just be the input portion. The title
  // and any wrapping divs will be provided by the form
  // renderer.
  function GetFieldInput($id, &$params, $returnid)
  {
    return '';
  }
	
  // override me with something to show users
  function StatusInfo()
  {
    return '';
  }

  function DebugDisplay()
  {
    $tmp = $this->form_ptr;
    $this->form_ptr = '[frmptr: '.$tmp->GetId().']';
    debug_display($this);
    $this->form_ptr = $tmp;
  }

  function GetId()
  {
    return $this->Id;
  }

  function HasAddOp()
  {
    return $this->HasAddOp;
  }

  // override me, when necessary or useful
  function DoOptionAdd(&$params)
  {
  }

  // override me
  function GetOptionAddButton()
  {
    $mod = $this->form_ptr->module_ptr;
    return $mod->Lang('add_options');
  }
	
  function HasDeleteOp()
  {
    return $this->HasDeleteOp;
  }

  // override me, when necessary or useful
  function DoOptionDelete(&$params)
  {
  }

  // override me
  function GetOptionDeleteButton()
  {
    $mod = $this->form_ptr->module_ptr;
    return $mod->Lang('delete_options');
  }

  function SetName($name)
  {
  	$this->Name = $name;
  }
  
  function GetName()
  {
    return $this->Name;
  }

  function GetAlias()
  {
    return $this->GetOption('field_alias','');
  }

  function SetAlias($alias)
  {
    $this->SetOption('field_alias',$alias);
  }


  function SetSmartyEval($bool)
  {
  	$this->SmartyEval = $bool;
  }
  
  function GetSmartyEval()
  {
    return $this->SmartyEval;
  }

  function GetOrder()
  {
    return $this->OrderBy;
  }

  function SetOrder($order)
  {
    $this->OrderBy = $order;
  }
	
  function GetFieldType()
  {
    return $this->Type;
  }

  function SetFieldType($type)
  {
    return $this->Type = $type;
  }

	
  function IsDisposition()
  {
    return $this->IsDisposition;
  }

  function HasLabel()
  {
    return $this->HasLabel;
  }

  function NeedsDiv()
  {
    return $this->NeedsDiv;
  }


  function SetHideLabel($hide)
  {
  	$this->HideLabel = $hide?1:0;
  }
  	
  function HideLabel()
  {
    return ($this->HideLabel==1?true:false);
  }

  function DisplayInForm()
  {
    return $this->DisplayInForm;
  }

  function DisplayInSubmission()
  {
    //return ($this->DisplayInForm && $this->DisplayInSubmission);
    return $this->DisplayInSubmission;
  }

	
  function IsNonRequirableField()
  {
    return $this->NonRequirableField;
  }

  function IsRequired()
  {
    return ($this->Required == 1?true:false);
  }

  function SetRequired($required)
  {
    $this->Required = ($required?1:0);
  }

  function ToggleRequired()
  {
    $this->Required = ($this->Required?0:1);
  }


  function GetValidationTypes()
  {
    return $this->ValidationTypes;
  }
	
  function GetValidationType()
  {
    return $this->ValidationType;
  }

  function SetValidationType($theType)
  {
    $this->ValidationType = $theType;
  }

  function IsValid()
  {
  	return $this->validated;
  }
  
  function GetValidationErrorText()
  {
  	return $this->validationErrorText;
  }


  // override me with a displayable type
  function GetDisplayType()
  {
    return $this->form_ptr->module_ptr->Lang('field_type_'.$this->Type);
  }


  function PrePopulateBaseAdminForm($formDescriptor,$disposeOnly=0)
  {
    $mod = $this->form_ptr->module_ptr;
    if ($this->Type == '')
      {
	if ($disposeOnly == 1)
	  {
	    $typeInput = $mod->CreateInputDropdown($formDescriptor, 'fbrp_field_type',array_merge(array($mod->Lang('select_type')=>''),$mod->disp_field_types), -1,'', 'onchange="this.form.submit()"');
	  }
	else
	  {
	    $typeInput = $mod->CreateInputDropdown($formDescriptor, 'fbrp_field_type',array_merge(array($mod->Lang('select_type')=>''),$mod->field_types), -1,'', 'onchange="this.form.submit()"');
	  }
      }
    else
      {
	$typeInput = $this->GetDisplayType().$mod->CreateInputHidden($formDescriptor, 'fbrp_field_type', $this->Type);
      }
		
    $main = array(
		  array($mod->Lang('title_field_name'),
			$mod->CreateInputText($formDescriptor, 'fbrp_field_name', $this->GetName(), 50)),
		  array($mod->Lang('title_field_type'),$typeInput),
		  );
		
    $adv = array();

    // if we know our type, we can load up with additional options
    if ($this->Type != '')
      {
			
	// validation types?
	if (count($this->GetValidationTypes()) > 1)
	  {
	    $validInput = $mod->CreateInputDropdown($formDescriptor, 'fbrp_validation_type', $this->GetValidationTypes(), -1, $this->GetValidationType());
	  }
	else
	  {
	    $validInput = $mod->Lang('automatic');
	  }
				
	if (!$this->IsNonRequirableField())
	  {
	    array_push($main, array($mod->Lang('title_field_required'),$mod->CreateInputCheckbox($formDescriptor, 'fbrp_required', 1, $this->IsRequired()).$mod->Lang('title_field_required_long')));
	  }
				
	array_push($main, array($mod->Lang('title_field_validation'),$validInput));

	if( $this->HasLabel == 1 )
	  {
	    array_push($adv, array($mod->Lang('title_hide_label'),$mod->CreateInputCheckbox($formDescriptor, 'fbrp_hide_label', 1, $this->HideLabel()).$mod->Lang('title_hide_label_long')));
	  }

	$alias = $this->GetOption('field_alias','');
	if ($alias == '')
		{
		$alias = 'fld'.$this->GetId();
		}
	array_push($adv, array($mod->Lang('title_field_alias'),$mod->CreateInputText($formDescriptor, 'fbrp_opt_field_alias', $this->GetOption('field_alias'), 50)));			

	if ($this->DisplayInForm())
	  {
	    array_push($adv,array($mod->Lang('title_field_css_class'),$mod->CreateInputText($formDescriptor, 'fbrp_opt_css_class', $this->GetOption('css_class'), 50)));
		array_push($adv,array($mod->Lang('title_field_javascript'),
			$mod->CreateTextArea(false, $formDescriptor, $this->GetOption('javascript',''),
						   'fbrp_opt_javascript','module_fb_area_short').'<br />'.
			$mod->Lang('title_field_javascript_long')));
	  }
	
      }
    else
      {
	// no advanced options until we know our type
	array_push($adv,array($mod->Lang('tab_advanced'),$mod->Lang('notice_select_type')));
      }
				
    return array('main'=>$main, 'adv'=>$adv);
  }
	
	
  // override me.
  // I return an ugly data structure:
  // It's an associative array with two items, 'main' and 'adv' (for the
  // main and advanced setting tabs).
  // Each of these is an associative array of Title / Input values.
  // The Title will be displayed if it has a length;
  // the "Input" should be a Form input for that field attribute/option
  function PrePopulateAdminForm($formDescriptor)
  {
    return array();
  }

  // override me.
  // This gives you a chance to alter the array contents before
  // they get rendered. 
  function PostPopulateAdminForm(&$mainArray, &$advArray)
  {
  }


  // override me as necessary
  function PostAdminSubmitCleanup()
  {
  }

  // clear fields unused by invisible dispositions
  function HiddenDispositionFields(&$mainArray, &$advArray, $hideReq=true)
  {
    $mod = &$this->form_ptr->module_ptr;
    if ($hideReq)
    	{
    	// remove the "required" field
    	$reqIndex = -1;
    	for ($i=0;$i<count($mainArray);$i++)
      		{
			if ($mainArray[$i]->title == $mod->Lang('title_field_required'))
	  			{
	    		$reqIndex = $i;
	  			}
      		}
    	if ($reqIndex != -1)
      		{
			array_splice($mainArray, $reqIndex,1);
      		}
     	}
    // remove the "hide name" field
    $hideIndex = -1;
    for ($i=0;$i<count($advArray);$i++)
      {
	if ($advArray[$i]->title == $mod->Lang('title_hide_label'))
	  {
	    $hideIndex = $i;
	  }
      }
    if ($hideIndex != -1)
      {
	array_splice($advArray, $hideIndex,1);
      }
    // remove the "css" field
    $hideIndex = -1;
    for ($i=0;$i<count($advArray);$i++)
      {
	if ($advArray[$i]->title == $mod->Lang('title_field_css_class'))
	  {
	    $hideIndex = $i;
	  }
      }
    if ($hideIndex != -1)
      {
	array_splice($advArray, $hideIndex,1);
      }
    if (count($advArray) == 0)
      {
	$advArray[0]->title = $mod->Lang('tab_advanced');
	$advArray[0]->input = $mod->Lang('title_no_advanced_options');
      }
  }
	

  // override me. Returns an array: first value is a true or false (whether or not
  // the value is valid), the second is a message
  function Validate()
  {
  	$this->validated = true;
  	$this->validatedErrorText = '';
    return array($this->validated, $this->validatedErrorText);
  }


  // override me!
  function GetHumanReadableValue($as_string=true)
  {
    $mod = &$this->form_ptr->module_ptr;
    if ($this->Value !== false)
      {
		$ret = $this->Value;
      }
    else
      {
	  $ret = $this->form_ptr->GetAttr('unspecified',$mod->Lang('unspecified'));
	  }
	if ($as_string)
		{
		return $ret;
		}
	else
		{
		return array($ret);
		}
  }


  // override this if you have some unusual format for values,
  // especially if "false" is a valid value!
  function HasValue()
  {
    return ($this->Value !== false);
  }
	
  // probably don't need to override this
  function GetValue()
  {
    return $this->Value;
  }

  // override me? Returns the (possibly converted) value of the field.
  function GetArrayValue($index)
  {
    if ($this->Value !== false)
      {
	if (is_array($this->Value))
	  {
	    if (isset($this->Value[$index]))
	      {
		return $this->Value[$index];
	      }
	  }
	elseif ($index == 0)
	  {
	    return $this->Value;
	  }
      }
    return false;
  }

  // override me? Returns true if the value is contained in the Value array
  function FindArrayValue($value)
  {
    if ($this->Value !== false)
      {
	if (is_array($this->Value))
	  {
	    return array_search($value,$this->Value);
	  }
	elseif ($this->Value == $value)
	  {
	    return true;
	  }
      }
    return false;
  }

  function ResetValue()
  {
    $this->Value = false;
  }

  // override me, if necessary to convert type or something.
  function SetValue($valStr)
  {
    $fm = &$this->form_ptr;
    if ($this->Value === false)
      {
      if (is_array($valStr))
         {
         $this->Value = $valStr;
         for ($i=0;$i<count($this->Value);$i++)
            {
            while ( $this->Value[$i] != $fm->unmy_htmlentities($this->Value[$i]))
               {
               $this->Value[$i] = $fm->unmy_htmlentities($this->Value[$i]);
               }
            }
         }
      else
         {
         while ($this->Value != $fm->unmy_htmlentities($valStr))
            {
	         $this->Value = $fm->unmy_htmlentities($valStr);
	         }
	      }
      }
    else
      {
      while ($valStr != $fm->unmy_htmlentities($valStr))
         {
         $valStr = $fm->unmy_htmlentities($valStr);
         }
	if (! is_array($this->Value))
	  {
	    $this->Value = array($this->Value);
	  }
	array_push($this->Value,$valStr);
      }
  }

  // override me, as necessary
  function CompareTo($val)
  {
    return strcmp($val->GetHumanReadableValue(), $this->GetHumanReadableValue());
  }

  function RequiresValidation()
  {
    if ($this->ValidationType == 'none')
      {
	return false;
      }
    else
      {
	return true;
      }
  }

  function DoesFieldNameExist()
  {
    $mod = &$this->form_ptr->module_ptr;
		
    // field name in use??
    if ($mod->GetPreference('unique_fieldnames','1') == '1' &&
    	$this->form_ptr->HasFieldNamed($this->GetName()) != $this->Id)
      {
		return array(false,$mod->Lang('field_name_in_use',$this->GetName()).
		'<br />');
      }		
    return array(true,'');
  }


   function DoesFieldHaveName()
   {
    $mod = &$this->form_ptr->module_ptr;
  	if ($mod->GetPreference('require_fieldnames','1') == '1' &&
  		strlen($this->GetName()) < 1)
  		{
  		return array(false, $mod->Lang('field_no_name').'<br />');
  		}
	return array(true,'');   
   }

  // override me, if needed. Returns an array: first value is a true or
  // false (whether or not the value is valid), the second is a message
  function AdminValidate()
  {
  	list($ret, $message) = $this->DoesFieldHaveName();
	if ($ret)
		{
		list($ret, $message) = $this->DoesFieldNameExist();
		}
	return array($ret, $message);
  }


  // override me if you're a Form Disposition pseudo-field.
  // This method can do just
  // about anything you want it to, in order to handle form contents.
  // it returns an array, where the first element is true on success,
  // or false on failure, and the second element is explanatory
  // text for the failure
  function DisposeForm()
  {
    return array(true, '');
  }	

  function ExportXML($exportValues = false)
  {
	$xmlstr = "\t<field id=\"".$this->Id."\"\n";
	$xmlstr .= "\t\ttype=\"".$this->Type."\"\n";
	//$xmlstr .= "\t\tname=\"".htmlspecialchars($this->Name)."\"\n";
	$xmlstr .= "\t\tvalidation_type=\"".$this->ValidationType."\"\n";
	$xmlstr .= "\t\torder_by=\"".$this->OrderBy."\"\n";
	$xmlstr .= "\t\trequired=\"".$this->Required."\"\n";
	$xmlstr .= "\t\thide_label=\"".$this->HideLabel."\"\n";
	$xmlstr .= "\t\talias=\"".$this->GetOption('field_alias','')."\">\n";
	$xmlstr .= "\t\t\t<field_name><![CDATA[".$this->Name."]]></field_name>\n";
	$xmlstr .= $this->OptionsAsXML();
	if ($exportValues)
		{
			$xmlstr .= "\t\t\t<human_readble_value><![CDATA[".$this->GetHumanReadableValue()."]]></human_readble_value>\n";
		}

	$xmlstr .= "</field>\n";
	return $xmlstr;
  }


	// override as necessary
   function OptionFromXML($theArray)
	{
		if ($theArray['name'] != 'option')
			{
			return;
			}
		if (! isset($this->Options))
			{
			$this->Options = array();	
			}
		if (isset($this->Options[$theArray['attributes']['name']]))
			{
			if (! is_array($this->Options[$theArray['attributes']['name']]))
				{
				$this->Options[$theArray['attributes']['name']] = array($this->Options[$theArray['attributes']['name']]);
				}
			array_push($this->Options[$theArray['attributes']['name']], $theArray['content']);
			}
		else
			{
	//	$this->Options[$theArray['name']] = $theArray['attributes']['name'];
			$this->Options[$theArray['attributes']['name']] = $theArray['content'];
			}
	}

   // override as necessary
   function OptionsAsXML()
	{
		$xmlstr = "";
		foreach($this->Options as $name=>$value)
			{
			if (! is_array($value))
				{
				$value = array($value);
				}
			foreach ($value as $thisVal)
				{
				$xmlstr .= "\t\t\t<option name=\"$name\"><![CDATA[$thisVal]]></option>\n";
				}
			}
		if (isset($this->Value))
			{
			if (! is_array($this->Value))
				{
				$thisVal = array($this->Value);	
				}
			else
				{
				$thisVal = &$this->Value;
				}
			foreach ($thisVal as $thisValOut)
				{
				$xmlstr .= "\t\t\t<value>$thisValOut</value>\n";
				}
			}
		return  $xmlstr;
	}


  function ExportObject()
  {
	$obj = new stdClass();
	$obj->name = $this->Name;
	$obj->type = $this->Type;
	$obj->id = $this->Id;
	$obj->value = $this->GetHumanReadableValue(true);
	$obj->valueArray = $this->GetHumanReadableValue(false);
	return $obj;
  }


  function GetOptionNames()
  {
    return array_keys($this->Options);
  }

  function GetOption($optionName, $default='')
  {
    if (isset($this->Options[$optionName]))
      {
	return $this->Options[$optionName];
      }
    return $default;
  }

  function &GetOptionRef($optionName)
    {
      if (isset($this->Options[$optionName]))
	{
	  return $this->Options[$optionName];
	}
      $tmp = false;
      return $tmp;
    }

	
  function RemoveOptionElement($optionName, $index)
  {
    if (isset($this->Options[$optionName]))
      {
	if (is_array($this->Options[$optionName]))
	  {
	    if (isset($this->Options[$optionName][$index]))
	      {
		array_splice($this->Options[$optionName],$index,1);
	      }
	  }
      }
  }
	
  function GetOptionElement($optionName, $index, $default="")
  {
    if (isset($this->Options[$optionName]))
      {
	if (is_array($this->Options[$optionName]))
	  {
	    if (isset($this->Options[$optionName][$index]))
	      {
		return $this->Options[$optionName][$index];
	      }
	  }
	elseif ($index == 0)
	  {
	    return $this->Options[$optionName];
	  }
      }

    return $default;		
  }

  function SetOption($optionName, $optionValue)
  {
    $this->Options[$optionName] = $optionValue;
  }
  
  function PushOptionElement($optionName, $val)
  {
  	if (isset($this->Options[$optionName]))
  		{
  		if (is_array($this->Options[$optionName]))
  			{
  			array_push($this->Options[$optionName],$val);
  			}
  		else
  			{
  			$this->Options[$optionName] = array($this->Options[$optionName],$val);
  			}
  		}
  	else
  		{
  		$this->Options[$optionName] = $val;
  		}
  }

  function LoadField(&$params)
  {
    if ($this->Id > 0)
      {
	$this->Load($this->Id, $params, true);
      }
    return;
  }

  // customized version of API function CreateTextInput. This doesn't throw in an ID that's the same as the field name.
  function TextField($id, $name, $value='', $size='10', $maxlength='255', $addttext='')
{
  $value = cms_htmlentities(html_entity_decode($value));
  $id = cms_htmlentities(html_entity_decode($id));
  $name = cms_htmlentities(html_entity_decode($name));
  $size = ($size!=''?cms_htmlentities($size):10);
  $maxlength = ($maxlength!=''?cms_htmlentities($maxlength):255);

  $value = str_replace('"', '&quot;', $value);
  
  $text = '<input type="text" name="'.$id.$name.'" value="'.$value.'" size="'.$size.'" maxlength="'.$maxlength.'"';
  if ($addttext != '')
    {
      $text .= ' ' . $addttext;
    }
  $text .= " />\n";
  return $text;
}


  // loadDeep also loads all options for a field.
  function Load($id, &$params, $loadDeep=false)
  {
    $sql = 'SELECT * FROM ' . cms_db_prefix() . 'module_fb_field WHERE field_id=?';
    if($result = $this->form_ptr->module_ptr->dbHandle->GetRow($sql, array($this->Id)))
      {
	if (strlen($this->Name) < 1)
	  {
	    $this->Name = $result['name'];
	  }
	if (strlen($this->ValidationType) < 1)
	  {
	    $this->ValidationType = $result['validation_type'];
	  }
	$this->Type = $result['type'];
	$this->OrderBy = $result['order_by'];
	if ($this->Required == -1)
	  {
	    $this->Required = $result['required'];
	  }
	if ($this->HideLabel == -1)
	  {
	    $this->HideLabel = $result['hide_label'];
	  }
      }
    else
      {
	return false;
      }
    $this->loaded = true;
    if ($loadDeep)
      {
	$sql = 'SELECT name, value FROM ' . cms_db_prefix() .
	  'module_fb_field_opt WHERE field_id=? ORDER BY option_id';
	$rs = $this->form_ptr->module_ptr->dbHandle->Execute($sql,
							     array($this->Id));
	$tmpOpts = array();
	while ($rs && $results = $rs->FetchRow())
	  {
	    if (isset($tmpOpts[$results['name']]))
	      {
		if (! is_array($tmpOpts[$results['name']]))
		  {
		    $tmpOpts[$results['name']] = array($tmpOpts[$results['name']]);
		  }
		array_push($tmpOpts[$results['name']],$results['value']);
	      }
	    else
	      {
		$tmpOpts[$results['name']]=$results['value'];
	      }
	  }
	$this->Options = array_merge($tmpOpts,$this->Options);

	if (isset($params['value_'.$this->Name]) &&
	    (is_array($params['value_'.$this->Name]) ||
	     strlen($params['value_'.$this->Name]) > 0))
	  {
	    $this->SetValue($params['value_'.$this->Name]);
	  }
	
	if (isset($params['value_fld'.$this->Id]) &&
	    (is_array($params['value_fld'.$this->Id]) ||
	     strlen($params['value_fld'.$this->Id]) > 0))
	  {
	    $this->SetValue($params['value_fld'.$this->Id]);
	  }
      }


    return true;
  }


  function Store($storeDeep=false)
  {
    $mod =  $this->form_ptr->module_ptr;
    if ($this->Id == -1)
      {
	$this->Id = $mod->dbHandle->GenID(cms_db_prefix().'module_fb_field_seq');
	$sql = 'INSERT INTO ' .cms_db_prefix().
	  'module_fb_field (field_id, form_id, name, type, ' .
	  'required, validation_type, hide_label, order_by) '.
	  ' VALUES (?, ?, ?, ?, ?, ?, ?, ?)';
	$res = $mod->dbHandle->Execute($sql,
				       array($this->Id, $this->FormId, $this->Name,
					     $this->Type, ($this->Required?1:0), 
					     $this->ValidationType, $this->HideLabel, $this->OrderBy));
      }
    else
      {
	$sql = 'UPDATE ' . cms_db_prefix() .
	  'module_fb_field set name=?, type=?,'.
	  'required=?, validation_type=?, order_by=?, '.
	  'hide_label=? where field_id=?';
	$res = $mod->dbHandle->Execute($sql,
				       array($this->Name, $this->Type, ($this->Required?1:0),
					     $this->ValidationType,
					     $this->OrderBy, $this->HideLabel, $this->Id));
      }
            
    if ($storeDeep)
      {
	// drop old options
	$sql = 'DELETE FROM ' . cms_db_prefix() .
	  'module_fb_field_opt where field_id=?';
	$res = $mod->dbHandle->Execute($sql,
				       array($this->Id));

	foreach ($this->Options as $thisOptKey=>$thisOptValueList)
	  {
	    if (! is_array($thisOptValueList))
	      {
		$thisOptValueList = array($thisOptValueList);
	      }
	    foreach ($thisOptValueList as $thisOptValue)
	      {
		$optId = $mod->dbHandle->GenID(
					       cms_db_prefix().'module_fb_field_opt_seq');
		$sql = 'INSERT INTO ' . cms_db_prefix().
		  'module_fb_field_opt (option_id, field_id, form_id, '.
		  'name, value) VALUES (?, ?, ?, ?, ?)';
		$res = $mod->dbHandle->Execute($sql,
					       array($optId, $this->Id, $this->FormId, $thisOptKey,
						     $thisOptValue));
	      }
	  }
      }
    return $res;
  }

  function Delete()
  {
    if ($this->Id == -1)
      {
	return false;
      }
    $sql = 'DELETE FROM ' . cms_db_prefix() . 'module_fb_field where field_id=?';
    $res = $this->form_ptr->module_ptr->dbHandle->Execute($sql,
							  array($this->Id));
    $sql = 'DELETE FROM ' . cms_db_prefix() . 'module_fb_field_opt where field_id=?';
    $res = $this->form_ptr->module_ptr->dbHandle->Execute($sql,
							  array($this->Id));
    return true;
  }
}

?>
]]></data>
	</file>
	<file>
	  <filename>/classes/FieldsetEnd.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/FieldsetStart.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/FileUploadField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/Form.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/* 
   FormBuilder. Copyright (c) 2005-2008 Samuel Goldstein <sjg@cmsmodules.com>
   More info at http://dev.cmsmadesimple.org/projects/formbuilder
   
   A Module for CMS Made Simple, Copyright (c) 2008 by Ted Kulp (wishy@cmsmadesimple.org)
  This project's homepage is: http://www.cmsmadesimple.org
*/

class fbForm {

  var $module_ptr = -1;
  var $Id = -1;
  var $Name = '';
  var $Alias = '';
  var $loaded = 'not';
  var $formTotalPages = 0;
  var $Page;
  var $Attrs;
  var $Fields;
  var $formState;
  var $sampleTemplateCode;
  var $templateVariables;

  function fbForm(&$module_ptr, &$params, $loadDeep=false)
  {
    $this->module_ptr =& $module_ptr;
    $this->Fields = array();
    $this->Attrs = array();
    $this->formState = 'new';
    if (isset($params['form_id']))
      {
	$this->Id = $params['form_id'];
      }
    if (isset($params['fbrp_form_alias']))
      {
	$this->Alias = $params['fbrp_form_alias'];
      }
    if (isset($params['fbrp_form_name']))
      {
	$this->Name = $params['fbrp_form_name'];
      }

   $fieldExpandOp = false;

   foreach($params as $pKey=>$pVal)
      {
      if (substr($pKey,0,9) == 'fbrp_FeX_' || substr($pKey,0,9) == 'fbrp_FeD_')
         {
         // expanding or shrinking a field
         $fieldExpandOp = true;
         }
      }

    if ($fieldExpandOp)
      {
      $params['fbrp_done'] = 0;
      if (isset($params['fbrp_continue']))
         {
	      $this->Page = $params['fbrp_continue'] - 1;
         }
      else
         {
	      $this->Page = 1;
         }
      }
    else
      {
      if (isset($params['fbrp_continue']))
         {
	      $this->Page = $params['fbrp_continue'];
         }
      else
         {
	      $this->Page = 1;
         }
      if (isset($params['fbrp_prev']) && isset($params['fbrp_previous']))
         {
	      $this->Page = $params['fbrp_previous'];
	      $params['fbrp_done'] = 0;
         }
      }
    $this->formTotalPages = 1;
    if (isset($params['fbrp_done'])&& $params['fbrp_done']==1)
      {
	$this->formState = 'submit';
      }
    if (isset($params['fbrp_user_form_validate']) && $params['fbrp_user_form_validate']==true)
      {
	$this->formState = 'confirm';
      }
    if ($this->Id != -1)
      {
	if (isset($params['response_id']) && $this->formState == 'submit')
	  {
	    $this->formState = 'update';
	  }
	$this->Load($this->Id, $params, $loadDeep);
      }
    foreach ($params as $thisParamKey=>$thisParamVal)
      {
	if (substr($thisParamKey,0,11) == 'fbrp_forma_')
	  {
	    $thisParamKey = substr($thisParamKey,11);
	    $this->Attrs[$thisParamKey] = $thisParamVal;
	  }
	else if ($thisParamKey == 'fbrp_form_template' && $this->Id != -1)
	  {
	    $this->module_ptr->SetTemplate('fb_'.$this->Id,$thisParamVal);
	  }
      }

    $this->templateVariables = Array(
		'{$sub_form_name}'=>$this->module_ptr->Lang('title_form_name'),
		'{$sub_date}'=>$this->module_ptr->Lang('help_submission_date'),
		'{$sub_host}'=>$this->module_ptr->Lang('help_server_name'),
		'{$sub_source_ip}'=>$this->module_ptr->Lang('help_sub_source_ip'),
		'{$sub_url}'=>$this->module_ptr->Lang('help_sub_url'),
		'{$fb_version}'=>$this->module_ptr->Lang('help_fb_version'),
		'{$TAB}'=>$this->module_ptr->Lang('help_tab'),
	);
  }

  function SetAttributes($attrArray)
  {
    $this->Attrs = array_merge($this->Attrs,$attrArray);
  }

  function SetTemplate($template)
  {
    $this->Attrs['form_template'] = $template;
    $this->module_ptr->SetTemplate('fb_'.$this->Id,$template);
  }

  function GetId()
  {
    return $this->Id;
  }

  function SetId($id)
  {
    $this->Id = $id;
  }

  function GetName()
  {
    return $this->Name;
  }
	
  function GetFormState()
  {
    return $this->formState;
  }
	
  function GetPageCount()
  {
    return $this->formTotalPages;
  }
	
  function GetPageNumber()
  {
    return $this->Page;
  }

  function PageBack()
  {
    $this->Page--;
  }


  function SetName($name)
  {
    $this->Name = $name;
  }
	
  function GetAlias()
  {
    return $this->Alias;
  }

  function SetAlias($alias)
  {
    $this->Alias = $alias;
  }

  function DebugDisplay()
  {
    $tmp = $this->module_ptr;
    $this->module_ptr = '[mdptr]';
    $template_tmp = $this->GetAttr('form_template','');
    $this->SetAttr('form_template',strlen($template_tmp).' characters');
    $field_tmp = $this->Fields;
    $this->Fields = 'Field Array: '.count($field_tmp);
    debug_display($this);
    $this->SetAttr('form_template',$template_tmp);
    $this->Fields = $field_tmp;
    foreach($this->Fields as $fld)
      {
		$fld->DebugDisplay();
      }
    $this->module_ptr = $tmp;
  }

	
  function SetAttr($attrname, $val)
  {
    $this->Attrs[$attrname] = $val;
  }
	
  function GetAttr($attrname, $default="")
  {
    if (isset($this->Attrs[$attrname]))
      {
	return $this->Attrs[$attrname];
      }
    else
      {
	return $default;
      }
  }
	
  function GetFieldCount()
  {
    return count($this->Fields);
  }

  function HasFieldNamed($name)
  {
    $ret = -1;
    foreach($this->Fields as $fld)
		{
		if ($fld->GetName() == $name)
			{
			$ret = $fld->GetId();
			}
		}
    return $ret;
  }

  function AddTemplateVariable($name,$def)
  {
    $theKey = '{$'.$name.'}';
    $this->templateVariables[$theKey] = $def;
  }

  function MakeVar($string)
  {
    $maxvarlen = 24;
    $string = strtolower(preg_replace('/\s+/','_',$string));
    $string = strtolower(preg_replace('/\W/','_',$string));
    if (strlen($string) > $maxvarlen)
      {
	$string = substr($string,0,$maxvarlen);
	$pos = strrpos($string,'_');
	if ($pos !== false)
	  {
	    $string = substr($string,0,$pos);
	  }
      }
    return $string;
  }

  function createSampleTemplateJavascript($fieldName='opt_email_template', $button_text='', $suffix='')
  {
	$fldAlias = preg_replace('/[^\w\d]/','_',$fieldName).$suffix;
    $jsCode = "<script type=\"text/javascript\">\n
/* <![CDATA[ */
function populate".$fldAlias."(formname)
    {
    var fname = 'IDfbrp_".$fieldName."';
    formname[fname].value=|TEMPLATE|;
    }
/* ]]> */
</script>";
	$jsCode .= "<input type=\"button\" value=\"".
$button_text."\" onclick=\"javascript:populate".$fldAlias."(this.form)\" />";
  return $jsCode;
  }


  function createSampleTemplate($htmlish=false,$email=true, $oneline=false,$header=false)
  {
    $mod = &$this->module_ptr;
    $ret = "";
	if ($email)
		{
    	if ($htmlish)
    		{
			$ret .= "<h1>".$mod->Lang('email_default_template')."</h1>\n";
			}
	 	else
	 		{
			$ret .= $mod->Lang('email_default_template')."\n";
			}
    	foreach($this->templateVariables as $thisKey=>$thisVal)
      		{
			if ($htmlish)
				{
				$ret .= '<strong>'.$thisVal.'</strong>: '.$thisKey."<br />\n";
				}
			else
				{
				$ret .= $thisVal.': '.$thisKey."\n";
				}
      		}
     	if ($htmlish)
     	  	{
		  	$ret .= "\n<hr />\n";
	  	  	}
	  	else
	  	  	{
    	  	$ret .= "\n-------------------------------------------------\n";
    	  	}
    	}
	elseif (! $oneline)
		{
		if ($htmlish)
			{
			$ret .= '<h2>';
			}
		$ret .= $mod->Lang('thanks');
		if ($htmlish)
			{
			$ret .= '</h2>';
			}
		}
    $others = &$this->GetFields();
    for($i=0;$i<count($others);$i++)
      {
	if ($others[$i]->DisplayInSubmission())
	  {
	  if ($others[$i]->GetAlias() != '')
		{
		$fldref = '{$'. $others[$i]->GetAlias(). '}';
		}
	  else
		{
		$fldref = '{$fld_'. $others[$i]->GetId(). '}';
		}
	  if ($htmlish)
     	  {
  		  $ret .= '<strong>'.$others[$i]->GetName() . '</strong>: ' . $fldref. "<br />\n";
  		  }
  	  elseif ($oneline && !$header)
		  {
		  $ret .= $fldref. '{$TAB}';
		  }
	  elseif ($oneline && $header)
		 {
		 $ret .= $others[$i]->GetName().'{$TAB}';
		 }
	  else
  	  	  {
	      $ret .= $others[$i]->GetName() . ': ' .$fldref. "\n";
	      }
	  }
      }
    if ($oneline)
		{
		$ret = substr($ret,0,strlen($ret) - 6). "\n";
		}
    return $ret;
  }


//  function AdminTemplateHelp($formDescriptor,$fields='opt_email_template',
//  	$includeHTML=true, $includeText=true, $oneline = false, $headerName='')
  function AdminTemplateHelp($formDescriptor,$fieldStruct)
  {
    $mod = &$this->module_ptr;
    $ret = '<table class="module_fb_legend"><tr><th colspan="2">'.$mod->Lang('help_variables_for_template').'</th></tr>';
    $ret .= '<tr><th>'.$mod->Lang('help_variable_name').'</th><th>'.$mod->Lang('help_form_field').'</th></tr>';
    $odd = false;
    foreach($this->templateVariables as $thisKey=>$thisVal)
      {
		$ret .= '<tr><td class="'.($odd?'odd':'even').
		'">'.$thisKey.'</td><td class="'.($odd?'odd':'even').
		'">'.$thisVal.'</td></tr>';
      $odd = ! $odd;
      }

    $others = &$this->GetFields();
    for($i=0;$i<count($others);$i++)
      {
	if ($others[$i]->DisplayInSubmission())
	  {                
	    $ret .= '<tr><td class="'.($odd?'odd':'even').
	    '">{$'.$this->MakeVar($others[$i]->GetName()).
	    '} / {$fld_'.
	    $others[$i]->GetId().'}';
		if ($others[$i]->GetAlias() != '')
			{
			$ret .= ' / {$'.$others[$i]->GetAlias().'}';	
			}
	    $ret .= '</td><td class="'.($odd?'odd':'even').
	    '">' .$others[$i]->GetName() . '</td></tr>';
	  	$odd = ! $odd;
	  }
      }
       	
    $ret .= '<tr><td colspan="2">'.$mod->Lang('help_array_fields').'</td></tr>';
    $ret .= '<tr><td colspan="2">'.$mod->Lang('help_other_fields').'</td></tr>';

    $sampleTemplateCode = '';
    foreach ($fieldStruct as $key=>$val)
		{
		$html_button = (isset($val['html_button']) && $val['html_button']);
		$text_button = (isset($val['text_button']) && $val['text_button']);
		$is_oneline = (isset($val['is_oneline']) && $val['is_oneline']);
		$is_email = (isset($val['is_email']) && $val['is_email']);
		$is_header = (isset($val['is_header']) && $val['is_header']);
		if ($html_button)
			{
			$button_text = $mod->Lang('title_create_sample_html_template');
			}
		elseif ($is_header)
			{
			$button_text = $mod->Lang('title_create_sample_header_template');
			}
		else
			{
			$button_text = $mod->Lang('title_create_sample_template');
			}

		if ($html_button && $text_button)
			{
			$sample = $this->createSampleTemplate(false, $is_email, $is_oneline, $is_header);
			$sample = preg_replace('/\'/',"\\'",$sample);
			$sample = preg_replace('/\n/',"\\n'+\n'", $sample);
			$sampleTemplateCode .= preg_replace('/\|TEMPLATE\|/',"'".$sample."'",
			    	$this->createSampleTemplateJavascript($key, $mod->Lang('title_create_sample_template'),'text'));
			}
		
		$sample = $this->createSampleTemplate($html_button,$is_email, $is_oneline,$is_header);
		$sample = preg_replace('/\'/',"\\'",$sample);
		$sample = preg_replace('/\n/',"\\n'+\n'", $sample);
		$sampleTemplateCode .= preg_replace('/\|TEMPLATE\|/',"'".$sample."'",
	    	$this->createSampleTemplateJavascript($key, $button_text));
		}
/*    $escapedSample = preg_replace('/\'/',"\\'",$this->createSampleTemplate(false,true,$oneline));
    $escapedSampleHTML = preg_replace('/\'/',"\\'",$this->createSampleTemplate(true,true,$oneline));
    $escapedSample = preg_replace('/\n/',"\\n'+\n'", $escapedSample);
    $escapedSampleHTML = preg_replace('/\n/',"\\n'+\n'", $escapedSampleHTML);
    
    $sampleTemplateCode = preg_replace('/\|TEMPLATE\|/',"'".$escapedSample."'",
    	$this->createSampleTemplateJavascript($fieldName, $includeHTML, $includeText));
    $sampleTemplateCode = preg_replace('/\|HTMLTEMPLATE\|/',"'".$escapedSampleHTML."'",
    	$sampleTemplateCode); */
    $sampleTemplateCode = preg_replace('/ID/',$formDescriptor,
    	$sampleTemplateCode);
    $ret .= '<tr><td colspan="2">'.$sampleTemplateCode.'</td></tr>';
    $ret .= '</table>';
    return $ret;
  }


  function Validate()
  {
    $validated = true;
    $message = array();
    $formPageCount=1;
    $valPage = $this->Page - 1;
    for($i=0;$i<count($this->Fields);$i++)
      {
	if ($this->Fields[$i]->GetFieldType() == 'PageBreakField')
	  {
	    $formPageCount++;
	  }
	if ($valPage != $formPageCount)
	  {
	    continue;
	  }
	if (/*! $this->Fields[$i]->IsNonRequirableField() && */
	    $this->Fields[$i]->IsRequired() &&
	    $this->Fields[$i]->HasValue() == false)
	  {
	    array_push($message,
	    	$this->module_ptr->Lang('please_enter_a_value',$this->Fields[$i]->GetName()));
	    $validated = false;
	    $this->Fields[$i]->SetOption('is_valid',false);
	    $this->Fields[$i]->validationErrorText = 	$this->module_ptr->Lang('please_enter_a_value',$this->Fields[$i]->GetName());
	    $this->Fields[$i]->validated = false;
	  }
	else if ($this->Fields[$i]->GetValue() != $this->module_ptr->Lang('unspecified'))
	  { 
	    $res = $this->Fields[$i]->Validate();
	    if ($res[0] != true)
	      {
		array_push($message,$res[1]);
		$validated = false;
		$this->Fields[$i]->SetOption('is_valid',false);
	      }
	    else
	      {
		$this->Fields[$i]->SetOption('is_valid',true);
	      }
	  }
      }
    return array($validated, $message);
  }


  function HasDisposition()
  {
    $hasDisp = false;
    for($i=0;$i<count($this->Fields);$i++)
      {
	if ($this->Fields[$i]->IsDisposition())
	  {
	    $hasDisp = true;
	  }
      }
    return $hasDisp;
  }

  // return an array: element 0 is true for success, false for failure
  // element 1 is an array of reasons, in the event of failure.
  function Dispose($returnid)
  {
    // first, we run all field methods that will modify other fields
    $computes = array();
    for($i=0;$i<count($this->Fields);$i++)
      {
		if ($this->Fields[$i]->ModifiesOtherFields())
	  	{
	    	$this->Fields[$i]->ModifyOtherFields();
	  	}
	  if ($this->Fields[$i]->ComputeOnSubmission())
	  	{
	  		$computes[$i] = $this->Fields[$i]->ComputeOrder();
	  	}
      }
      
    asort($computes);
    foreach($computes as $cKey=>$cVal)
    	{
    	$this->Fields[$cKey]->Compute();
    	}

    $resArray = array();
    $retCode = true;
    // for each form disposition pseudo-field, dispose the form results
    for($i=0;$i<count($this->Fields);$i++)
      {
	if ($this->Fields[$i]->IsDisposition() && $this->Fields[$i]->DispositionIsPermitted())
	  {
	    $res = $this->Fields[$i]->DisposeForm($returnid);
	    if ($res[0] == false)
	      {
		$retCode = false;
		array_push($resArray,$res[1]);
	      }
	  }
      }

	// handle any last cleanup functions
    for($i=0;$i<count($this->Fields);$i++)
      {
		$this->Fields[$i]->PostDispositionAction();
	  }
    return array($retCode,$resArray);
  }

  function RenderFormHeader()
  {
    if ($this->module_ptr->GetPreference('show_version',0) == 1)
      {
	return "\n<!-- Start FormBuilder Module (".$this->module_ptr->GetVersion().") -->\n";
      }
  }

  function RenderFormFooter()
  {
    if ($this->module_ptr->GetPreference('show_version',0) == 1)
      {
	return "\n<!-- End FormBuilder Module -->\n";
      }
  }


  // returns a string.
  function RenderForm($id, &$params, $returnid)
  {
    $mod = $this->module_ptr;
    if ($this->Id == -1)
      {
	return "<!-- no form -->\n";
      }
    if ($this->loaded != 'full')
      {
	$this->Load($this->Id,$params,true);
      }

    $reqSymbol = $this->GetAttr('required_field_symbol','*');

    $mod->smarty->assign('title_page_x_of_y',$mod->Lang('title_page_x_of_y',array($this->Page,$this->formTotalPages)));
		
    $mod->smarty->assign('css_class',$this->GetAttr('css_class',''));
    $mod->smarty->assign('total_pages',$this->formTotalPages);
    $mod->smarty->assign('this_page',$this->Page);
    $mod->smarty->assign('form_name',$this->Name);
    $mod->smarty->assign('form_id',$this->Id);

    $hidden = $mod->CreateInputHidden($id, 'form_id', $this->Id);
	if (isset($params['lang']))
		{
		$hidden .= $mod->CreateInputHidden($id, 'lang', $params['lang']);
		}
    $hidden .= $mod->CreateInputHidden($id, 'fbrp_continue', ($this->Page + 1));
    if (isset($params['fbrp_browser_id']))
      {
	$hidden .= $mod->CreateInputHidden($id,'fbrp_browser_id',$params['fbrp_browser_id']);
      }
    if ($this->Page > 1)
      {
	$hidden .= $mod->CreateInputHidden($id, 'fbrp_previous', ($this->Page - 1));
      }
    if ($this->Page == $this->formTotalPages)
      {
	$hidden .= $mod->CreateInputHidden($id, 'fbrp_done', 1);
      }
    $fields = array();
    $formPageCount = 1;
    for ($i=0; $i < count($this->Fields); $i++)
      {
	$thisField = &$this->Fields[$i];
	if ($thisField->GetFieldType() == 'PageBreakField')
	  {
	    $formPageCount++;
	  }
	if ($formPageCount != $this->Page)
	  {
	    $testIndex = 'fbrp__'.$this->Fields[$i]->GetId();
	    if (!isset($params[$testIndex]))
	      {
		// do we need to write something?
	      }
	    elseif (is_array($params[$testIndex]))
	      {
		foreach ($params[$testIndex] as $val)
		  {
		    $hidden .= $mod->CreateInputHidden($id,
						       $testIndex.'[]',
						       /*htmlspecialchars($val,ENT_QUOTES)*/ $this->unmy_htmlentities($val));
		  }
	      }
	    else
	      {
		$hidden .= $mod->CreateInputHidden($id,
						   $testIndex,
						   /*htmlspecialchars($params[$testIndex],ENT_QUOTES)*/ $this->unmy_htmlentities($params[$testIndex]));
	      }
	    continue;
	  }
	$oneset = new stdClass();
	$oneset->display = $thisField->DisplayInForm()?1:0;
	$oneset->required = $thisField->IsRequired()?1:0;
	$oneset->required_symbol = $thisField->IsRequired()?$reqSymbol:'';
	$oneset->css_class = $thisField->GetOption('css_class');
//	$oneset->valid = $thisField->GetOption('is_valid',true)?1:0;
	$oneset->valid = $thisField->validated?1:0;
	$oneset->error = $thisField->GetOption('is_valid',true)?'':$thisField->validationErrorText;
	$oneset->hide_name = 0;
	if( (!$thisField->HasLabel()) || $thisField->HideLabel() )
	  {
	    $oneset->hide_name = 1;
	  }
	$oneset->has_label = $thisField->HasLabel();
	$oneset->needs_div = $thisField->NeedsDiv();
	$oneset->name = $thisField->GetName();
	$oneset->input = $thisField->GetFieldInput($id, $params, $returnid);
	$oneset->smarty_eval = $thisField->GetSmartyEval()?1:0;

	$oneset->input_id = $id.'fbrp__'.$thisField->GetID();
	$oneset->multiple_parts = $thisField->HasMultipleFormComponents()?1:0;
	$oneset->label_parts = $thisField->LabelSubComponents()?1:0;
	$oneset->type = $thisField->GetDisplayType();
	$mod->smarty->assign($thisField->GetName(),$oneset);
	if ($thisField->GetAlias() != '')
		{
		$mod->smarty->assign($thisField->GetAlias(),$oneset);
		}
	array_push($fields,$oneset);
      }

    $mod->smarty->assign_by_ref('fb_hidden',$hidden);
    $mod->smarty->assign_by_ref('fields',$fields);

    $jsStr = '';
    $jsTrigger = '';
    if ($this->GetAttr('input_button_safety','0') == '1')
      {
	$jsStr = '<script type="text/javascript">
	/* <![CDATA[ */
    var submitted = 0;
    function LockButton ()
       {
       var ret = false;
       if ( ! submitted )
          {
           var item = document.getElementById("fbsubmit'.$this->Id.'");
           if (item != null)
             {
             setTimeout(function() {item.disabled = true}, 0);
             }
           submitted = 1;
           ret = true;
          }
        return ret;
        }
/* ]]> */
</script>';
      $jsTrigger = " onclick='return LockButton()'";
      }

    $js = $this->GetAttr('submit_javascript');

    if ($this->Page > 1)
      {
	$mod->smarty->assign('prev',$mod->CreateInputSubmit($id, 'fbrp_prev',
							    $this->GetAttr('prev_button_text'),
							    'class="fbsubmit_prev" '.$js));
      }
    else
      {
	$mod->smarty->assign('prev','');
      }

    if ($this->Page < $formPageCount)
      {
	$mod->smarty->assign('submit',$mod->CreateInputSubmit($id, 'fbrp_submit',
							      $this->GetAttr('next_button_text'),
							      'class="fbsubmit_next" '.$js));
      }
    else
      {
      $captcha = &$mod->getModuleInstance('Captcha');
      if ($this->GetAttr('use_captcha','0')== '1' && $captcha != null)
         {
         $mod->smarty->assign('graphic_captcha',$captcha->getCaptcha());
         $mod->smarty->assign('title_captcha',$this->GetAttr('title_user_captcha',$mod->Lang('title_user_captcha')));
         $mod->smarty->assign('input_captcha',$mod->CreateInputText($id, 'fbrp_captcha_phrase',''));
         $mod->smarty->assign('has_captcha','1');
         }
      else
         {
         $mod->smarty->assign('has_captcha','0');
         }
	   $mod->smarty->assign('submit',$jsStr . $mod->CreateInputSubmit($id, 'fbrp_submit',
				$this->GetAttr('submit_button_text'),
				'class="fbsubmit" id="fbsubmit'.$this->Id.'"'.$jsTrigger.' '.$js));
      }
	  return $mod->ProcessTemplateFromDatabase('fb_'.$this->Id);
  }

  function LoadForm($loadDeep=false)
  {
    return $this->Load($this->Id, array(), $loadDeep);
  }

function unmy_htmlentities($val)
{
	if ($val == "")
	{
		return "";
	}
	$val = html_entity_decode($val);
	$val = str_replace("&amp;","&",$val);
	$val = str_replace("&#60;&#33;--","<!--",$val);
	$val = str_replace("--&#62;","-->",$val);
	$val = str_replace("&gt;",">", $val);
	$val = str_replace("&lt;","<",$val);
	$val = str_replace("&quot;","\"",$val);
	$val = str_replace("&#036;","\$",$val);
	$val = str_replace("&#33;","!",$val);
	$val = str_replace("&#39;","'",$val);

	// Uncomment if you need to convert unicode chars
	return $val;
}





  function Load($formId, &$params, $loadDeep=false)
  {

//error_log("entering Form Load with usage ".memory_get_usage());
    $sql = 'SELECT * FROM '.cms_db_prefix().'module_fb_form WHERE form_id=?';
    $rs = $this->module_ptr->dbHandle->Execute($sql, array($formId));
    if($rs && $rs->RecordCount() > 0)
      {
	$result = $rs->FetchRow();
	$this->Id = $result['form_id'];
	if (!isset($params['fbrp_form_name']) || empty($params['fbrp_form_name']))
	  {
	    $this->Name = $result['name'];
	  }
	if (!isset($params['fbrp_form_alias']) || empty($params['fbrp_form_alias']))
	  {
	    $this->Alias = $result['alias'];
	  }
      }
    else
      {
	return false;
      }
    $sql = 'SELECT name,value FROM '.cms_db_prefix().
      'module_fb_form_attr WHERE form_id=?';
    $rs = $this->module_ptr->dbHandle->Execute($sql, array($formId));
    while ($rs && $result=$rs->FetchRow())
      {
	$this->Attrs[$result['name']] = $result['value'];
      }
          
    $this->loaded = 'summary';

    if (isset($params['response_id']))
      {
	$loadDeep = true;
      }
			
    if ($loadDeep)
      {
	// if it's a stored form, load the results -- but we need to manually merge them,
	// since $params[] should override the database value (say we're resubmitting a form)
	if (isset($params['response_id']))
	  {
	    $loadParams = array('response_id'=>$params['response_id']);
	    $this->LoadResponseValues($loadParams);
	    foreach ($loadParams as $thisParamKey=>$thisParamValue)
	      {
		if (! isset($params[$thisParamKey]))
		  {
		    $params[$thisParamKey] = $thisParamValue;
		  }
	      }
	  }

	$sql = 'SELECT * FROM ' . cms_db_prefix().
	  'module_fb_field WHERE form_id=? ORDER BY order_by';
	$rs = $this->module_ptr->dbHandle->Execute($sql, array($formId));
	$result = array();
	if ($rs && $rs->RecordCount() > 0)
	  {
	    $result = $rs->GetArray();
	  }
	$fieldCount = 0;
	if (count($result) > 0)
	  {
	    foreach($result as $thisRes)
	      {
//error_log("Instantiating Field. usage ".memory_get_usage());

		$className = $this->MakeClassName($thisRes['type'], '');
		// create the field object
		if (
		    ( 
		     isset($thisRes['field_id']) &&
		      (
		       isset($params['fbrp__'.$thisRes['field_id']]) ||
		       isset($params['fbrp___'.$thisRes['field_id']])
		       )
		      ) ||
		    (isset($thisRes['field_id']) &&
		     isset($params['value_'.$thisRes['name']])) ||
		    (isset($thisRes['field_id']) &&
		     isset($params['value_fld'.$thisRes['field_id']])) ||
		    (
		     isset($params['field_id']) && isset($thisRes['field_id']) &&
		     $params['field_id'] == $thisRes['field_id']
		     )
		    )
		  {
		    $thisRes = array_merge($thisRes,$params);
		  }
		$this->Fields[$fieldCount] = &$this->NewField($thisRes);
		$fieldCount++;
	      }
	  }
	$this->loaded = 'full';
      }

		
    for ($i=0; $i < count($this->Fields); $i++)
      {
	if ($this->Fields[$i]->Type == 'PageBreakField')
	  {
	    $this->formTotalPages++;
	  }
      }

    return true;
  }

/* notable params:
  fbrp_xml_file -- source file for the XML
  xml_string -- source string for the XML
*/

  function ImportXML(&$params)
  {
  	// xml_parser_create, xml_parse_into_struct
  	$parser = xml_parser_create('');
   xml_parser_set_option( $parser, XML_OPTION_CASE_FOLDING, 0 );
   xml_parser_set_option( $parser, XML_OPTION_SKIP_WHITE, 0 ); // was 1
    if (isset($params['fbrp_xml_file']) && ! empty($params['fbrp_xml_file']))
		{
		xml_parse_into_struct($parser, file_get_contents($params['fbrp_xml_file']), $vals);
		}
	elseif (isset($params['xml_string']) && ! empty($params['xml_string']))
		{
		xml_parse_into_struct($parser, $params['xml_string'], $vals);
		}
	else
		{
		return false;
		}
	xml_parser_free($parser);
	$elements = array();
	$stack = array();
	$fieldMap = array();
	foreach ( $vals as $tag )
		{
		$index = count( $elements );
		if ( $tag['type'] == "complete" || $tag['type'] == "open" )
			{
			$elements[$index] = array();
			$elements[$index]['name'] = $tag['tag'];
			$elements[$index]['attributes'] = empty($tag['attributes']) ? "" : $tag['attributes'];
			$elements[$index]['content']    = empty($tag['value']) ? "" : $tag['value'];
			if ( $tag['type'] == "open" )
				{
				# push
				$elements[$index]['children'] = array();
				$stack[count($stack)] = &$elements;
				$elements = &$elements[$index]['children'];
				}
        }
		if ( $tag['type'] == "close" )
			{    # pop
			$elements = &$stack[count($stack) - 1];
			unset($stack[count($stack) - 1]);
			}
		}

	if (!isset($elements[0]) || !isset($elements[0]) || !isset($elements[0]['attributes']))
		{
		//parsing failed, or invalid file.
		return false;
		}
	$params['form_id'] = -1; // override any form_id values that may be around
	$formAttrs = &$elements[0]['attributes'];
	if ($this->inXML($formAttrs['alias']))
		{
		$this->SetAlias($formAttrs['alias']);
		}
	$foundfields = false;
	// populate the attributes and field name first. When we see a field, we save the form and then start adding the fields to it.
	foreach ($elements[0]['children'] as $thisChild)
		{
		if ($thisChild['name'] == 'form_name')
			{
			$this->SetName($thisChild['content']);
			}
		elseif ($thisChild['name'] == 'attribute')
			{
			$this->SetAttr($thisChild['attributes']['key'], $thisChild['content']);
			}
		else
			{
			// we got us a field
			if (! $foundfields)
				{
				// first field
				$foundfields = true;
				if( isset($params['fbrp_import_formname']) && 
				    trim($params['fbrp_import_formname']) != '')
				  {
				    $this->SetName(trim($params['fbrp_import_formname']));
				  }
				if( isset($params['fbrp_import_formalias']) &&
				    trim($params['fbrp_import_formname']) != '')
				  {
				    $this->SetAlias(trim($params['fbrp_import_formalias']));
				  }
				$this->Store();
				$params['form_id'] = $this->GetId();
				}
				//debug_display($thisChild);
			$fieldAttrs = &$thisChild['attributes'];
			$className = $this->MakeClassName($fieldAttrs['type'], '');
		    $newField = new $className($this, $params);
			$oldId = $fieldAttrs['id'];

			if ($this->inXML($fieldAttrs['alias']))
				{
				$newField->SetAlias($fieldAttrs['alias']);
				}
			$newField->SetValidationType($fieldAttrs['validation_type']);
			if ($this->inXML($fieldAttrs['order_by']))
				{
				$newField->SetOrder($fieldAttrs['order_by']);
				}
			if ($this->inXML($fieldAttrs['required']))
				{
				$newField->SetRequired($fieldAttrs['required']);
				}
			if ($this->inXML($fieldAttrs['hide_label']))
				{
				$newField->SetHideLabel($fieldAttrs['hide_label']);
				}
			foreach ($thisChild['children'] as $thisOpt)
				{	
				if ($thisOpt['name'] == 'field_name')
					{
					$newField->SetName($thisOpt['content']);
					}
				else
					{
					$newField->OptionFromXML($thisOpt);
					}
				}
			$newField->Store(true);
			$fieldMap[$newField->GetId()] = $oldId;
				
			}
		}
/*	foreach ($elements[0]['children'] as $thisChild)
		{
		if ($thisChild['name'] == 'field')
			{
			}
		}
*/	
	if (isset($params['fbrp_xml_file']) && ! empty($params['fbrp_xml_file']))
		{
		// need to update mappings in templates.
		
		}
	
	return true;	
  }

  function inXML(&$var)
  {
  		if (isset($var) && strlen($var) > 0)
  			{
			return true;
			}
		else
			{
			return false;
			}
  }

  // storeDeep also stores all fields and options for a form
  function Store($storeDeep=false)
  {
    if ($this->Id == -1)
      {
	$this->Id = $this->module_ptr->dbHandle->GenID(cms_db_prefix().
						       'module_fb_form_seq');
	$sql = 'INSERT INTO ' . cms_db_prefix().
	  'module_fb_form (form_id, name, alias) '.
	  'VALUES (?, ?, ?)';
	$res = $this->module_ptr->dbHandle->Execute($sql,
						    array($this->Id, $this->Name, $this->Alias));
      }
    else
      {
	$sql = 'UPDATE ' . cms_db_prefix().
	  'module_fb_form set name=?, alias=? where form_id=?';
	$res = $this->module_ptr->dbHandle->Execute($sql,
						    array($this->Name, $this->Alias, $this->Id));
      }
    // save out the attrs
    $sql = 'DELETE FROM '.cms_db_prefix().
      'module_fb_form_attr WHERE form_id=?';
    $res = $this->module_ptr->dbHandle->Execute($sql, array($this->Id));
    foreach ($this->Attrs as $thisAttrKey=>$thisAttrValue)
      {
	$formAttrId = $this->module_ptr->dbHandle->GenID(cms_db_prefix().
							 'module_fb_form_attr_seq');
	$sql = 'INSERT INTO ' . cms_db_prefix().
	  'module_fb_form_attr (form_attr_id, form_id, name, value) '.
	  'VALUES (?, ?, ?, ?)';
	$res = $this->module_ptr->dbHandle->Execute($sql,
						    array($formAttrId, $this->Id, $thisAttrKey,
							  $thisAttrValue));
	if ($thisAttrKey == 'form_template')
	  {
	    $this->module_ptr->SetTemplate('fb_'.$this->Id,$thisAttrValue);
	  }
      }
		
    return $res;
  }

  function Delete()
  {
    if ($this->Id == -1)
      {
	return false;
      }
    if ($this->loaded != 'full')
      {
	$this->Load($this->Id,array(),true);
      }
    foreach ($this->Fields as $field)
      {
	$field->Delete();
      }
    $this->module_ptr->DeleteTemplate('fb_'.$this->Id);
    $sql = 'DELETE FROM ' . cms_db_prefix() . 'module_fb_form where form_id=?';
    $res = $this->module_ptr->dbHandle->Execute($sql, array($this->Id));
    $sql = 'DELETE FROM ' . cms_db_prefix() . 'module_fb_form_attr where form_id=?';
    $res = $this->module_ptr->dbHandle->Execute($sql, array($this->Id));
    return true;
  }

  // returns a class name, and makes sure the file where the class is
  // defined has been loaded.
  function MakeClassName($type, $classDirPrefix)
  {
    // perform rudimentary security, since Type could come in from a form
    $type = preg_replace("/[\W]|\.\./", "_", $type);
    if ($type == '' || strlen($type) < 1)
      {
	$type = 'Field';
      }
    $classFile='';
    if (strlen($classDirPrefix) > 0)
      {
	$classFile = $classDirPrefix .'/'.$type.'.class.php';
      }
    else
      {
	$classFile = $type.'.class.php';
      }
    require_once dirname(__FILE__).'/'.$classFile;
    // class names are prepended with "fb" to prevent namespace clash.
    return ( 'fb'.$type );
  }

  function AddEditForm($id, $returnid, $message='')
  {
    global $gCms;
    $mod = &$this->module_ptr;
    $mod->smarty->assign('message',$message);
    $mod->smarty->assign('formstart',
			 $mod->CreateFormStart($id, 'admin_store_form', $returnid));
    $mod->smarty->assign('formid',
			 $mod->CreateInputHidden($id, 'form_id', $this->Id));
    $mod->smarty->assign('tab_start',$mod->StartTabHeaders().
         $mod->SetTabHeader('maintab',$mod->Lang('tab_main')).
         $mod->SetTabHeader('submittab',$mod->Lang('tab_submit')).
         $mod->SetTabHeader('symboltab',$mod->Lang('tab_symbol')).
         $mod->SetTabHeader('captchatab',$mod->Lang('tab_captcha')).
         $mod->SetTabHeader('templatelayout',$mod->Lang('tab_templatelayout')).
         $mod->SetTabHeader('submittemplate',$mod->Lang('tab_submissiontemplate')).
			$mod->EndTabHeaders() . $mod->StartTabContent());
	  
    $mod->smarty->assign('tabs_end',$mod->EndTabContent());
    $mod->smarty->assign('maintab_start',$mod->StartTab("maintab"));
    $mod->smarty->assign('submittab_start',$mod->StartTab("submittab"));
    $mod->smarty->assign('symboltab_start',$mod->StartTab("symboltab"));
    $mod->smarty->assign('templatetab_start',$mod->StartTab("templatelayout"));
    $mod->smarty->assign('submittemplatetab_start',$mod->StartTab("submittemplate"));
    $mod->smarty->assign('captchatab_start',$mod->StartTab("captchatab"));
    $mod->smarty->assign('tab_end',$mod->EndTab());
    $mod->smarty->assign('form_end',$mod->CreateFormEnd());
    $mod->smarty->assign('title_form_name',$mod->Lang('title_form_name'));
    $mod->smarty->assign('input_form_name',
			 $mod->CreateInputText($id, 'fbrp_form_name',
					       $this->Name, 50));
	
	
	$mod->smarty->assign('template_are_you_sure',$mod->Lang('template_are_you_sure'));
	$mod->smarty->assign('title_load_template',$mod->Lang('title_load_template'));
	$modLink = $mod->CreateLink($id, 'admin_get_template', $returnid, '', array(), '', true);
	list($mod_path, $mod_param) = explode('?',$modLink);
	$mod->smarty->assign('mod_path',$mod_path);
	$mod->smarty->assign('mod_param',$mod_param);
	
	$templateList = array(''=>'',$mod->Lang('default_template')=>'RenderFormDefault.tpl',
		$mod->Lang('table_left_template')=>'RenderFormTableTitleLeft.tpl',
		$mod->Lang('table_top_template')=>'RenderFormTableTitleTop.tpl');
		
	$allForms = $mod->GetForms();
	foreach ($allForms as $thisForm)
		{
		if ($thisForm['form_id'] != $this->Id)
			{
			$templateList[$mod->Lang('form_template_name',$thisForm['name'])] =
				$thisForm['form_id'];
			}
		}
	
	$mod->smarty->assign('input_load_template',$mod->CreateInputDropdown($id,
		'fbrp_fb_template_load', $templateList, -1, '', 'id="fb_template_load" onchange="getTemplate()"'));
	$mod->smarty->assign('help_template_variables',$mod->Lang('template_variable_help'));
    $mod->smarty->assign('title_form_unspecified',$mod->Lang('title_form_unspecified'));
    $mod->smarty->assign('input_form_unspecified',
			 $mod->CreateInputText($id, 'fbrp_forma_unspecified',
					       $this->GetAttr('unspecified',$mod->Lang('unspecified')), 50));
    $mod->smarty->assign('title_form_status',
			 $mod->Lang('title_form_status'));
    $mod->smarty->assign('text_ready',
			 $mod->Lang('title_ready_for_deployment'));
    $mod->smarty->assign('title_form_alias',$mod->Lang('title_form_alias'));
    $mod->smarty->assign('input_form_alias',
			 $mod->CreateInputText($id, 'fbrp_form_alias',
					       $this->Alias, 50));
    $mod->smarty->assign('title_form_css_class',
			 $mod->Lang('title_form_css_class'));
    $mod->smarty->assign('input_form_css_class',
			 $mod->CreateInputText($id, 'fbrp_forma_css_class',
					       $this->GetAttr('css_class','formbuilderform'), 50,50));
    $mod->smarty->assign('title_form_fields',
			 $mod->Lang('title_form_fields'));
	$mod->smarty->assign('title_form_main',
			 $mod->Lang('title_form_main'));
    if( $mod->GetPreference('show_fieldids',0) != 0 )
      {
	  $mod->smarty->assign('title_field_id',
			     $mod->Lang('title_field_id'));
      }
    if( $mod->GetPreference('show_fieldaliases',0) != 0 )
      {
	  $mod->smarty->assign('title_field_alias',
			     $mod->Lang('title_field_alias'));
      }


    $mod->smarty->assign('title_field_name',
			 $mod->Lang('title_field_name'));
    $mod->smarty->assign('title_field_type',
			 $mod->Lang('title_field_type'));
    $mod->smarty->assign('title_field_type',
			 $mod->Lang('title_field_type'));
    $mod->smarty->assign('title_form_template',
			 $mod->Lang('title_form_template'));
    $mod->smarty->assign('title_list_delimiter',
			 $mod->Lang('title_list_delimiter'));
    $mod->smarty->assign('title_redirect_page',
			 $mod->Lang('title_redirect_page'));
			 
    $mod->smarty->assign('title_submit_action',
			 $mod->Lang('title_submit_action'));
    $mod->smarty->assign('title_submit_response',
			 $mod->Lang('title_submit_response'));

    $mod->smarty->assign('title_inline_form',
			 $mod->Lang('title_inline_form'));

    $mod->smarty->assign('title_submit_actions',
			 $mod->Lang('title_submit_actions'));
    $mod->smarty->assign('title_submit_labels',
			 $mod->Lang('title_submit_labels'));
	    $mod->smarty->assign('title_submit_javascript',
				 $mod->Lang('title_submit_javascript'));
    $mod->smarty->assign('title_submit_help',
$mod->cms->variables['admintheme']->DisplayImage('icons/system/info.gif','true','','','systemicon').
			 $mod->Lang('title_submit_help'));
	$mod->smarty->assign('title_submit_response_help',
$mod->cms->variables['admintheme']->DisplayImage('icons/system/info.gif','true','','','systemicon').
			$mod->Lang('title_submit_response_help'));

    $submitActions = array($mod->Lang('display_text')=>'text',
         $mod->Lang('redirect_to_page')=>'redir');
    $mod->smarty->assign('input_submit_action',
          $mod->CreateInputRadioGroup($id, 'fbrp_forma_submit_action', $submitActions, $this->GetAttr('submit_action','text')));

    $captcha = &$mod->getModuleInstance('Captcha');
    if ($captcha == null)
         {
         $mod->smarty->assign('title_install_captcha',
			   $mod->Lang('title_captcha_not_installed'));
         $mod->smarty->assign('captcha_installed',0);
         }
    else
         {
         $mod->smarty->assign('title_use_captcha',
			   $mod->Lang('title_use_captcha'));
         $mod->smarty->assign('captcha_installed',1);

         $mod->smarty->assign('input_use_captcha',$mod->CreateInputHidden($id,'fbrp_forma_use_captcha','0').
			   $mod->CreateInputCheckbox($id,'fbrp_forma_use_captcha','1',$this->GetAttr('use_captcha','0')).
			   $mod->Lang('title_use_captcha_help'));
			}
    $mod->smarty->assign('title_information',$mod->Lang('information'));
    $mod->smarty->assign('title_order',$mod->Lang('order'));
    $mod->smarty->assign('title_field_required_abbrev',$mod->Lang('title_field_required_abbrev'));
    $mod->smarty->assign('hasdisposition',$this->HasDisposition()?1:0);
    $maxOrder = 1;
    if($this->Id > 0)
      {
	$mod->smarty->assign('submit_button',
			     $mod->CreateInputSubmit($id, 'fbrp_submit',
						     $mod->Lang('save_and_continue')));
	$mod->smarty->assign('fb_hidden',
			     $mod->CreateInputHidden($id, 'fbrp_form_op',$mod->Lang('updated')));
	$mod->smarty->assign('adding',0);
	$mod->smarty->assign('save_button',
			     $mod->CreateInputSubmit($id, 'fbrp_submit', $mod->Lang('save')));
	$fieldList = array();
	$currow = "row1";
	$count = 1;
	$last = $this->GetFieldCount();
	foreach ($this->Fields as $thisField)
	  {
	    $oneset = new stdClass();
	    $oneset->rowclass = $currow;
	    $oneset->name = $mod->CreateLink($id, 'admin_add_edit_field', '', $thisField->GetName(), array('field_id'=>$thisField->GetId(),'form_id'=>$this->Id));
	    if( $mod->GetPreference('show_fieldids',0) != 0 )
	      {
		$oneset->id = $mod->CreateLink($id, 'admin_add_edit_field', '', $thisField->GetId(), array('field_id'=>$thisField->GetId(),'form_id'=>$this->Id));
	      }
	    $oneset->type = $thisField->GetDisplayType();
	    $oneset->alias = $thisField->GetAlias();
	    if (/*$thisField->IsDisposition() ||*/
		!$thisField->DisplayInForm() ||
		$thisField->IsNonRequirableField())
	      {
		$oneset->disposition = '.';
	      }
	    else if ($thisField->IsRequired())
	      {
		$oneset->disposition = $mod->CreateLink($id, 'admin_update_field_required', '', $mod->cms->variables['admintheme']->DisplayImage('icons/system/true.gif','true','','','systemicon'), array('form_id'=>$this->Id,'fbrp_active'=>'off','field_id'=>$thisField->GetId()));
	      }
	    else
	      {
		$oneset->disposition = $mod->CreateLink($id, 'admin_update_field_required', '', $mod->cms->variables['admintheme']->DisplayImage('icons/system/false.gif','false','','','systemicon'), array('form_id'=>$this->Id,'fbrp_active'=>'on','field_id'=>$thisField->GetId()));
	      }
	    $oneset->field_status = $thisField->StatusInfo();
	    if ($count > 1)
	      {
		$oneset->up = $mod->CreateLink($id, 'admin_update_field_order', '', $mod->cms->variables['admintheme']->DisplayImage('icons/system/arrow-u.gif','up','','','systemicon'), array('form_id'=>$this->Id,'fbrp_dir'=>'up','field_id'=>$thisField->GetId()));
	      }
	    else
	      {
		$oneset->up = '&nbsp;';
	      }
	    if ($count < $last)
	      {
		$oneset->down=$mod->CreateLink($id, 'admin_update_field_order', '', $mod->cms->variables['admintheme']->DisplayImage('icons/system/arrow-d.gif','down','','','systemicon'), array('form_id'=>$this->Id,'fbrp_dir'=>'down','field_id'=>$thisField->GetId()));
	      }
	    else
	      {
		$oneset->down = '&nbsp;';
	      }
	    $oneset->editlink = $mod->CreateLink($id, 'admin_add_edit_field', '', $mod->cms->variables['admintheme']->DisplayImage('icons/system/edit.gif',$mod->Lang('edit'),'','','systemicon'), array('field_id'=>$thisField->GetId(),'form_id'=>$this->Id));
	    $oneset->deletelink = $mod->CreateLink($id, 'admin_delete_field', '', $mod->cms->variables['admintheme']->DisplayImage('icons/system/delete.gif',$mod->Lang('delete'),'','','systemicon'), array('field_id'=>$thisField->GetId(),'form_id'=>$this->Id),$mod->Lang('are_you_sure_delete_field',htmlspecialchars($thisField->GetName())));
	    ($currow == "row1"?$currow="row2":$currow="row1");
	    $count++;
	    if ($thisField->GetOrder() >= $maxOrder)
	      {
		$maxOrder = $thisField->GetOrder() + 1;
	      }
	    array_push($fieldList, $oneset);
	  }
	$mod->smarty->assign('fields',$fieldList);
	$mod->smarty->assign('add_field_link',
			     $mod->CreateLink($id, 'admin_add_edit_field', $returnid,$mod->cms->variables['admintheme']->DisplayImage('icons/system/newobject.gif',$mod->Lang('title_add_new_field'),'','','systemicon'),array('form_id'=>$this->Id, 'fbrp_order_by'=>$maxOrder), '', false) . $mod->CreateLink($id, 'admin_add_edit_field', $returnid,$mod->Lang('title_add_new_field'),array('form_id'=>$this->Id, 'fbrp_order_by'=>$maxOrder), '', false));
	$mod->smarty->assign('order_field_link',
			     $mod->CreateLink($id, 'admin_reorder_form', $returnid,$mod->cms->variables['admintheme']->DisplayImage('icons/system/reorder.gif',$mod->Lang('title_reorder_form'),'','','systemicon'),array('form_id'=>$this->Id), '', false) . $mod->CreateLink($id, 'admin_reorder_form', $returnid,$mod->Lang('title_reorder_form'),array('form_id'=>$this->Id), '', false));
			     			     
	if ($mod->GetPreference('enable_fastadd',1) == 1)
	  {
	    $mod->smarty->assign('fastadd',1);
	    $mod->smarty->assign('title_fastadd',$mod->Lang('title_fastadd'));
	    $typeInput = "<script type=\"text/javascript\">
/* <![CDATA[ */
function fast_add(field_type)
{
	var type=field_type.options[field_type.selectedIndex].value;
	var link = '".$mod->CreateLink($id, 'admin_add_edit_field', $returnid,'',array('form_id'=>$this->Id, 'fbrp_order_by'=>$maxOrder), '', true,true)."&".$id."fbrp_field_type='+type;
	this.location=link;
	return true;
}
/* ]]> */
</script>";
	    $typeInput = str_replace('&amp;','&',$typeInput); 
	    $mod->initialize();
	    if ($mod->GetPreference('show_field_level','basic') == 'basic')
			{
			$mod->smarty->assign('input_fastadd',$typeInput.$mod->CreateInputDropdown($id, 'fbrp_field_type',array_merge(array($mod->Lang('select_type')=>''),$mod->std_field_types), -1,'', 'onchange="fast_add(this)"').
				$mod->Lang('title_switch_advanced').
				$mod->CreateLink($id, 'admin_add_edit_form', $returnid,$mod->Lang('title_switch_advanced_link'),array('form_id'=>$this->Id, 'fbrp_set_field_level'=>'advanced')));
			}
		else
			{
			$mod->smarty->assign('input_fastadd',$typeInput.$mod->CreateInputDropdown($id, 'fbrp_field_type',array_merge(array($mod->Lang('select_type')=>''),$mod->field_types), -1,'', 'onchange="fast_add(this)"').
			$mod->Lang('title_switch_basic').
			$mod->CreateLink($id, 'admin_add_edit_form', $returnid,$mod->Lang('title_switch_basic_link'),array('form_id'=>$this->Id, 'fbrp_set_field_level'=>'basic')));
			}
	  }							
      }
    else
      {
	$mod->smarty->assign('save_button','');
	$mod->smarty->assign('submit_button',
			     $mod->CreateInputSubmit($id, 'fbrp_submit', $mod->Lang('add')));
	$mod->smarty->assign('fb_hidden',
			     $mod->CreateInputHidden($id, 'fbrp_form_op',$mod->Lang('added')));
	$mod->smarty->assign('adding',1);
      }
    $mod->smarty->assign('link_notready',"<strong>".$mod->Lang('title_not_ready1')."</strong> ".$mod->Lang('title_not_ready2')." ".$mod->CreateLink($id, 'admin_add_edit_field', $returnid,$mod->Lang('title_not_ready_link'),array('form_id'=>$this->Id, 'fbrp_order_by'=>$maxOrder,'fbrp_dispose_only'=>1), '', false, false,'class="module_fb_link"')." ".$mod->Lang('title_not_ready3')
			 );

   
    $mod->smarty->assign('input_inline_form',$mod->CreateInputHidden($id,'fbrp_forma_inline','0').
			   $mod->CreateInputCheckbox($id,'fbrp_forma_inline','1',$this->GetAttr('inline','0')).
			   $mod->Lang('title_inline_form_help'));

    $mod->smarty->assign('title_form_submit_button',
			 $mod->Lang('title_form_submit_button'));
    $mod->smarty->assign('input_form_submit_button',
			 $mod->CreateInputText($id, 'fbrp_forma_submit_button_text',
					       $this->GetAttr('submit_button_text',$mod->Lang('button_submit')), 35, 35));
    $mod->smarty->assign('title_submit_button_safety',
			 $mod->Lang('title_submit_button_safety_help'));
    $mod->smarty->assign('input_submit_button_safety',$mod->CreateInputHidden($id,'fbrp_forma_input_button_safety','0').
			 $mod->CreateInputCheckbox($id,'fbrp_forma_input_button_safety','1',$this->GetAttr('input_button_safety','0')).
			 $mod->Lang('title_submit_button_safety'));
    $mod->smarty->assign('title_form_prev_button',
			 $mod->Lang('title_form_prev_button'));
    $mod->smarty->assign('input_form_prev_button',
			 $mod->CreateInputText($id, 'fbrp_forma_prev_button_text',
					       $this->GetAttr('prev_button_text',$mod->Lang('button_previous')), 35, 35));

    $mod->smarty->assign('input_title_user_captcha',
			 $mod->CreateInputText($id, 'fbrp_forma_title_user_captcha',
                      $this->GetAttr('title_user_captcha',$mod->Lang('title_user_captcha')),35,80));
    $mod->smarty->assign('title_title_user_captcha',$mod->Lang('title_title_user_captcha'));

    $mod->smarty->assign('input_title_user_captcha_error',
			 $mod->CreateInputText($id, 'fbrp_forma_captcha_wrong',
                      $this->GetAttr('captcha_wrong',$mod->Lang('wrong_captcha')),35,80));
    $mod->smarty->assign('title_user_captcha_error',$mod->Lang('title_user_captcha_error'));

    $mod->smarty->assign('title_form_next_button',
			 $mod->Lang('title_form_next_button'));
    $mod->smarty->assign('input_form_next_button',
			 $mod->CreateInputText($id, 'fbrp_forma_next_button_text',
					       $this->GetAttr('next_button_text',$mod->Lang('button_continue')), 35, 35));
    $mod->smarty->assign('title_form_required_symbol',
			 $mod->Lang('title_form_required_symbol'));
    $mod->smarty->assign('input_form_required_symbol',
			 $mod->CreateInputText($id, 'fbrp_forma_required_field_symbol',
					       $this->GetAttr('required_field_symbol','*'), 50));
    $mod->smarty->assign('input_list_delimiter',
			 $mod->CreateInputText($id, 'fbrp_forma_list_delimiter',
					       $this->GetAttr('list_delimiter',','), 50));

    $contentops =& $gCms->GetContentOperations();
    $mod->smarty->assign('input_redirect_page',$contentops->CreateHierarchyDropdown('',$this->GetAttr('redirect_page','0'), $id.'fbrp_forma_redirect_page'));

    $mod->smarty->assign('input_form_template',
			 $mod->CreateTextArea(false, $id,
					      $this->GetAttr('form_template',$this->DefaultTemplate()), 'fbrp_forma_form_template','','fb_form_template'));

	$mod->smarty->assign('input_submit_javascript',
		$mod->CreateTextArea(false, $id,
				$this->GetAttr('submit_javascript',''), 'fbrp_forma_submit_javascript','module_fb_area_short','fb_submit_javascript').
				'<br />'.$mod->Lang('title_submit_javascript_long'));

					      
    $mod->smarty->assign('input_submit_response',
			 $mod->CreateTextArea(false, $id,
					      $this->GetAttr('submit_response',''), 'fbrp_forma_submit_response','module_fb_area_wide'));

	$parms = array();
	$parms['forma_submit_response']['html_button'] = true;
	$parms['forma_submit_response']['txt_button'] = false;
	$parms['forma_submit_response']['is_one_line'] = false;
	$parms['forma_submit_response']['is_email'] = false;
	$mod->smarty->assign('help_submit_response',
		$this->AdminTemplateHelp($id,$parms));
    return $mod->ProcessTemplate('AddEditForm.tpl');
  }

    function &NewField(&$params)
      {
	//$aefield = new fbFieldBase($this,$params);
	$aefield = false;
        if (isset($params['field_id']) && $params['field_id'] != -1 )
	  {
            // we're loading an extant field
	    $sql = 'SELECT type FROM ' . cms_db_prefix() . 'module_fb_field WHERE field_id=?';
	    $rs = $this->module_ptr->dbHandle->Execute($sql, array( $params['field_id']));
	    if($rs && $result = $rs->FetchRow())
	      {				
		if ($result['type'] != '')
		  {
		    $className = $this->MakeClassName($result['type'] , '');
		    $aefield = new $className($this, $params);
		    $aefield->LoadField($params);
		  }
	      }
	  }
	if ($aefield === false)
	  {
	    // new field
	    if (! isset($params['fbrp_field_type']))
	      {
		// unknown field type
		$aefield = new fbFieldBase($this,$params);
	      }
	    else
	      {
		// specified field type via params
            	$className = $this->MakeClassName($params['fbrp_field_type'], '');
            	$aefield = new $className($this, $params);
	      }
	  }
	return $aefield;
      }



  function AddEditField($id, &$aefield, $dispose_only, $returnid, $message='')
  {
    $mod = $this->module_ptr;
		
    $mod->smarty->assign('message',$message);
    $mod->smarty->assign('backtoform_nav',$mod->CreateLink($id, 'admin_add_edit_form', $returnid, $mod->Lang('link_back_to_form'), array('form_id'=>$this->Id)));
    $mainList = array();
    $advList = array();
    $baseList = $aefield->PrePopulateBaseAdminForm($id, $dispose_only);
    if ($aefield->GetFieldType() == '')
      {
	// still need type
	$mod->smarty->assign('start_form',$mod->CreateFormStart($id, 'admin_add_edit_field', $returnid));			
	$fieldList = array('main'=>array(),'adv'=>array());
      }
    else
      {
	// we have our type
	$mod->smarty->assign('start_form',$mod->CreateFormStart($id, 'admin_add_edit_field', $returnid));	
	$fieldList = $aefield->PrePopulateAdminForm($id);
      }
    $mod->smarty->assign('end_form', $mod->CreateFormEnd());
    $mod->smarty->assign('tab_start',$mod->StartTabHeaders().
			 $mod->SetTabHeader('maintab',$mod->Lang('tab_main')).
			 $mod->SetTabHeader('advancedtab',$mod->Lang('tab_advanced')).
			 $mod->EndTabHeaders() . $mod->StartTabContent());
    $mod->smarty->assign('tabs_end',$mod->EndTabContent());
    $mod->smarty->assign('maintab_start',$mod->StartTab("maintab"));
    $mod->smarty->assign('advancedtab_start',$mod->StartTab("advancedtab"));
    $mod->smarty->assign('tab_end',$mod->EndTab());
    $mod->smarty->assign('notice_select_type',$mod->Lang('notice_select_type'));

    if($aefield->GetId() != -1)
      {
	$mod->smarty->assign('op',$mod->CreateInputHidden($id, 'fbrp_op',$mod->Lang('updated')));
	$mod->smarty->assign('submit',$mod->CreateInputSubmit($id, 'fbrp_aef_upd', $mod->Lang('update')));
      }
    else
      {
	$mod->smarty->assign('op',$mod->CreateInputHidden($id, 'fbrp_op', $mod->Lang('added')));
	$mod->smarty->assign('submit',$mod->CreateInputSubmit($id, 'fbrp_aef_add', $mod->Lang('add')));
      }

    if ($aefield->HasAddOp())
      {
	$mod->smarty->assign('add',$mod->CreateInputSubmit($id,'fbrp_aef_optadd',$aefield->GetOptionAddButton()));
      }
    else
      {
	$mod->smarty->assign('add','');
      }
    if ($aefield->HasDeleteOp())
      {
	$mod->smarty->assign('del',$mod->CreateInputSubmit($id,'fbrp_aef_optdel',$aefield->GetOptionDeleteButton()));
      }
    else
      {
	$mod->smarty->assign('del','');
      }


    $mod->smarty->assign('fb_hidden', $mod->CreateInputHidden($id, 'form_id', $this->Id) . $mod->CreateInputHidden($id, 'field_id', $aefield->GetId()) . $mod->CreateInputHidden($id, 'fbrp_order_by', $aefield->GetOrder()).
			 $mod->CreateInputHidden($id,'fbrp_set_from_form','1'));

    if (/*!$aefield->IsDisposition() && */ !$aefield->IsNonRequirableField())
      {
	$mod->smarty->assign('requirable',1);
      }
    else
      {
	$mod->smarty->assign('requirable',0);
      }
			
    if (isset($baseList['main']))
      {
	foreach ($baseList['main'] as $item)
	  {
	    $titleStr=$item[0];
	    $inputStr=$item[1];
	    $oneset = new stdClass();
	    $oneset->title = $titleStr;
	    if (is_array($inputStr))
	      {
		$oneset->input = $inputStr[0];
		$oneset->help = $inputStr[1];
	      }
	    else
	      {
		$oneset->input = $inputStr;
		$oneset->help='';
	      }
	    array_push($mainList,$oneset);
	  }
      }	
    if (isset($baseList['adv']))
      {
	foreach ($baseList['adv'] as $item)
	  {
	    $titleStr = $item[0];
	    $inputStr = $item[1];
	    $oneset = new stdClass();
	    $oneset->title = $titleStr;
	    if (is_array($inputStr))
	      {
		$oneset->input = $inputStr[0];
		$oneset->help = $inputStr[1];
	      }
	    else
	      {
		$oneset->input = $inputStr;
		$oneset->help='';
	      }
	    array_push($advList,$oneset);
	  }
      }	
    if (isset($fieldList['main']))
      {
	foreach ($fieldList['main'] as $item)
	  {
	    $titleStr=$item[0];
	    $inputStr=$item[1];
	    $oneset = new stdClass();
	    $oneset->title = $titleStr;
	    if (is_array($inputStr))
	      {
		$oneset->input = $inputStr[0];
		$oneset->help = $inputStr[1];
	      }
	    else
	      {
		$oneset->input = $inputStr;
		$oneset->help='';
	      }
	    array_push($mainList,$oneset);
	  }
      }
    if (isset($fieldList['adv']))
      {
	foreach ($fieldList['adv'] as $item)
	  {
	    $titleStr=$item[0];
	    $inputStr=$item[1];
	    $oneset = new stdClass();
	    $oneset->title = $titleStr;
	    if (is_array($inputStr))
	      {
		$oneset->input = $inputStr[0];
		$oneset->help = $inputStr[1];
	      }
	    else
	      {
		$oneset->input = $inputStr;
		$oneset->help='';
	      }
	    array_push($advList,$oneset);
	  }
      }
		
    $aefield->PostPopulateAdminForm($mainList, $advList);
    $mod->smarty->assign('mainList',$mainList);
    $mod->smarty->assign('advList',$advList);
    return $mod->ProcessTemplate('AddEditField.tpl');
  }

  function MakeAlias($string, $isForm=false)
  {
    $string = trim(htmlspecialchars($string));
    if ($isForm)
      {
	return strtolower($string);
      }
    else
      {
	return 'fb'.strtolower($string);
      }
  }
    
  function SwapFieldsByIndex($src_field_index, $dest_field_index)
  {
    $srcField = &$this->GetFieldByIndex($src_field_index);
    $destField = &$this->GetFieldByIndex($dest_field_index);
    $tmpOrderBy = $destField->GetOrder();
    $destField->SetOrder($srcField->GetOrder());
    $srcField->SetOrder($tmpOrderBy);
    //it seems this makes php4 go crazy fixed by reloading form before showing it again
    #        $this->Fields[$dest_field_index] = $srcField;
    #        $this->Fields[$src_field_index] = $destField;
    $srcField->Store();
    $destField->Store();
  }

  function &GetFields()
    {
      return $this->Fields;
    }

  function &GetFieldById($field_id)
    {
      $index = -1;
      for ($i=0;$i<count($this->Fields);$i++)
	{
	  if ($this->Fields[$i]->GetId() == $field_id)
	    {
	      $index = $i;
	    }
	}
      if ($index != -1)
	{
	  return $this->Fields[$index];
	}
      else
	{
	  return false;
	}
    }

  function &GetFieldByIndex($field_index)
    {
      return $this->Fields[$field_index];
    }


  function GetFieldIndexFromId($field_id)
  {
    $index = -1;
    for ($i=0;$i<count($this->Fields);$i++)
      {
	if ($this->Fields[$i]->GetId() == $field_id)
	  {
	    $index = $i;
	  }
      }
    return $index;
  }


  function DefaultTemplate()
  {
    return file_get_contents(dirname(__FILE__).'/../templates/RenderFormDefault.tpl');
  }

  function DeleteField($field_id)
  {
    $index = $this->GetFieldIndexFromId($field_id);
    if ($index != -1)
      {
	$this->Fields[$index]->Delete();
	array_splice($this->Fields,$index,1);
      }
  } 

  function ResetFields()
  {
    for($i=0;$i<count($this->Fields);$i++)
      {
	$this->Fields[$i]->ResetValue();
      }
  }
    
  // this will instantiate the form, and load the results
  function LoadResponse($response_id)
  {
    $db = &$this->module_ptr->dbHandle;
    // loading a response -- at this point, we check that the response
    // is for the correct form_id!
    $sql = 'SELECT form_id FROM ' . cms_db_prefix().
      'module_fb_resp where resp_id=?';
    if($result = $db->GetRow($sql, array($response_id)))
      {
	if ($result['form_id'] != $this->GetId())
	  {
	    return false;
	  }
		    
	$this->ResetFields();

	$sql = 'SELECT * FROM '.cms_db_prefix().
	  'module_fb_resp_val WHERE resp_id=? order by resp_val_id';
	$dbresult = $db->Execute($sql, array($response_id));
	while ($dbresult && $row = $dbresult->FetchRow())
	  {
	    $index = $this->GetFieldIndexFromId($row['field_id']);
            if($index != -1 &&  is_object($this->Fields[$index]) )
             {
	       $this->Fields[$index]->SetValue($row['value']);
             }
	  }
      }
    else
      {
	return false;
      }
  }   

  function LoadResponseValues(&$params)
  {
    $db = $this->module_ptr->dbHandle;
    // loading a response -- at this point, we check that the response
    // is for the correct form_id!
    $sql = 'SELECT form_id FROM ' . cms_db_prefix().
      'module_fb_resp where resp_id=?';
    if($result = $db->GetRow($sql, array($params['response_id'])))
      {
	if ($result['form_id'] != $this->GetId())
	  {
	    return false;
	  }
	$sql = 'SELECT * FROM '.cms_db_prefix().
	  'module_fb_resp_val WHERE resp_id=? order by resp_val_id';
	$dbresult = $db->Execute($sql, array($params['response_id']));
	while ($dbresult && $row = $dbresult->FetchRow())
	  { // was '__'		        	
	    if (isset($params['fbrp__'.$row['field_id']]) &&
		! is_array($params['fbrp__'.$row['field_id']]))
	      {
		$params['fbrp__'.$row['field_id']] = array($params['fbrp__'.$row['field_id']]);
		array_push($params['fbrp__'.$row['field_id']], $row['value']);
	      }
	    elseif (isset($params['fbrp__'.$row['field_id']]))
	      {
		array_push($params['fbrp__'.$row['field_id']], $row['value']);
	      }
	    else
	      {
		$params['fbrp__'.$row['field_id']] = $row['value'];
	      }
	  }
      }
    else
      {
	return false;
      }
  }   

  function DeleteResponse($response_id)
  {
    $db = $this->module_ptr->dbHandle;
    $sql = 'DELETE FROM ' . cms_db_prefix().
      'module_fb_resp_val where resp_id=?';
    $res = $db->Execute($sql, array($response_id));
    $sql = 'DELETE FROM '.cms_db_prefix().
      'module_fb_resp where resp_id=?';
    $res = $db->Execute($sql, array($response_id));	
  }

  function CheckResponse($form_id, $response_id, $code)
  {
    $db = $this->module_ptr->dbHandle;
    $sql = 'SELECT secret_code FROM ' . cms_db_prefix().
      'module_fb_resp where form_id=? and resp_id=?';
    if($result = $db->GetRow($sql, array($form_id,$response_id)))
      {
	if ($result['secret_code'] == $code)
	  {
	    return true;
	  }
      }
    return false;
  }


  function StoreResponse($response_id=-1,$approver='')
  {
    $db = $this->module_ptr->dbHandle;
    $fields = &$this->GetFields();
    $secret_code = '';
    $newrec = false;
    if ($response_id == -1)
      {
	$newrec = true;
      }
    if ($newrec)
      {
	// saving a new response
	$secret_code = substr(md5(session_id().'_'.time()),0,7);
	$response_id = $db->GenID(cms_db_prefix(). 'module_fb_resp_seq');
	$sql = 'INSERT INTO ' . cms_db_prefix().
	  'module_fb_resp (resp_id, form_id, submitted, secret_code)' .
	  ' VALUES (?, ?, ?, ?)';
	$res = $db->Execute($sql,
			    array($response_id,
				  $this->GetId(),
				  $this->clean_datetime($db->DBTimeStamp(time())),
				  $secret_code));
      }
    else if ($approver != '')
      {
	$sql = 'UPDATE ' . cms_db_prefix().
	  'module_fb_resp set user_approved=? where resp_id=?';
	$res = $db->Execute($sql,
			    array($this->clean_datetime($db->DBTimeStamp(time())),$response_id));
	audit(-1, (isset($name)?$name:""), $this->module_ptr->Lang('user_approved_submission',array($response_id,$approver)));
      }
    if (! $newrec)
      {
	// updating an old response, so we purge old values
	$sql = 'DELETE FROM ' . cms_db_prefix().
	  'module_fb_resp_val where resp_id=?';
	$res = $db->Execute($sql, array($response_id));
      }
    $sql = 'INSERT INTO ' . cms_db_prefix().
      'module_fb_resp_val (resp_val_id, resp_id, field_id, value)' .
      'VALUES (?, ?, ?, ?)';
    foreach ($fields as $thisField)
      {
	// set the response_id to be the attribute of the database disposition
	if (($thisField->GetFieldType() == 'DispositionDatabase')||
		($thisField->GetFieldType() == 'DispositionFormBrowser'))
	  {
	    $thisField->SetValue($response_id);
	  }
	elseif (! $thisField->DisplayInSubmission())
	  {
	    // skip if not a displayable field.
	    continue;
	  }
	if (! is_array($thisField->GetValue()))
	  {
	    $store = array();
	    array_push($store,$thisField->GetValue());
	  }
	else
	  {
	    $store = $thisField->GetValue();
	  }
	foreach ($store as $thisFieldVal)
	  {
	    if ($thisFieldVal !== false)
	      {
		$resp_val_id = $db->GenID(cms_db_prefix().
					  'module_fb_resp_val_seq');
		$res = $db->Execute($sql, array($resp_val_id,$response_id,
						$thisField->GetId(),$thisFieldVal));
	      }
	  } 
      }
    return array($response_id,$secret_code);
  }   
    

  function StoreResponseXML($response_id=-1,$approver='',$sortfield1,$sortfield2,$sortfield3,$sortfield4,$sortfield5)
  {
    $db = &$this->module_ptr->dbHandle;
    $secret_code = '';
    $newrec = false;
	$xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
	$xml .= "<response form_id=\"".$this->Id."\"\n";
	foreach($this->Fields as $thisField)
		{
			$xml .= $thisField->ExportXML(true);
		}
	$xml .= "</response>\n";

    if ($response_id == -1)
      {
	  $newrec = true;
      }

    if ($newrec)
      {
		// saving a new response
		$secret_code = substr(md5(session_id().'_'.time()),0,7);
		$response_id = $db->GenID(cms_db_prefix(). 'module_fb_formbrowser_seq');
		$sql = 'INSERT INTO ' . cms_db_prefix().
	  'module_fb_formbrowser (fbr_id, form_id, submitted, secret_code, index_key_1, index_key_2, index_key_3, index_key_4, index_key_5, response) VALUES (?,?,?,?,?,?,?,?,?,?)';
		$res = $db->Execute($sql,
			array($response_id,
				$this->GetId(),
				$this->clean_datetime($db->DBTimeStamp(time())),
				$secret_code,
				$sortfield1,$sortfield2,$sortfield3,$sortfield4,$sortfield5,
				$xml
			));
      }
    else if ($approver != '')
      {
		$sql = 'UPDATE ' . cms_db_prefix().
			'module_fb_formrowser set user_approved=? where fbr_id=?';
		$res = $db->Execute($sql,
			    array($this->clean_datetime($db->DBTimeStamp(time())),$response_id));
		audit(-1, (isset($name)?$name:""), $this->module_ptr->Lang('user_approved_submission',array($response_id,$approver)));
      }
    if (! $newrec)
      {
	  $sql = 'UPDATE ' . cms_db_prefix().
			'module_fb_formbrowser set index_key_1=?, index_key_2=?, index_key_3=?, index_key_4=?, index_key_5=?, response=? where fbr_id=?';
	  $res = $db->Execute($sql,
			    array($sortfield1,$sortfield2,$sortfield3,$sortfield4,$sortfield5,$xml,$response_id));
      }
    return array($response_id,$secret_code);
  }   


  function clean_datetime($dt)
  {
    return substr($dt,1,strlen($dt)-2);
  }
  
  function ExportXML($exportValues = false)
  {
	$xmlstr = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
	$xmlstr .= "<form id=\"".$this->Id."\"\n";
	$xmlstr .= "\talias=\"".$this->Alias."\">\n";
	$xmlstr .= "\t\t<form_name><![CDATA[".$this->Name."]]></form_name>\n";
   foreach ($this->Attrs as $thisAttrKey=>$thisAttrValue)
      {
		$xmlstr .= "\t\t<attribute key=\"$thisAttrKey\"><![CDATA[$thisAttrValue]]></attribute>\n";
		}
	foreach($this->Fields as $thisField)
		{
			$xmlstr .= $thisField->ExportXML($exportValues);
		}
	$xmlstr .= "</form>\n";
	return $xmlstr;
  }
  
  function setFinishedFormSmarty()
	{
		$mod = &$this->module_ptr;
	   
	    $theFields = &$this->GetFields();
	    $unspec = $this->GetAttr('unspecified',$mod->Lang('unspecified'));

		$formInfo = array();
		
	    for($i=0;$i<count($theFields);$i++)
	      {
			$replVal = $unspec;
			$replVals = array();
			if ($theFields[$i]->DisplayInSubmission())
		  		{
		    		$replVal = $theFields[$i]->GetHumanReadableValue();
		    		if ($htmlemail)
		        		{
						// allow <BR> as delimiter or in content
						$replVal = preg_replace('/<br(\s)*(\/)*>/i','|BR|',$replVal);
	            		$replVal = htmlspecialchars($replVal);
						$replVal = preg_replace('/\|BR\|/','<br />',$replVal);
	            		}
		    		if ($replVal == '')
		      			{
						$replVal = $unspec;
		      			}
		  		}
		
		 	$mod->smarty->assign($this->MakeVar($theFields[$i]->GetName()),$replVal);
		 	$mod->smarty->assign('fld_'.$theFields[$i]->GetId(),$replVal);
			$fldobj = $theFields[$i]->ExportObject();
		 	$mod->smarty->assign($this->MakeVar($theFields[$i]->GetName()).'_obj',$fldobj);
		 	$mod->smarty->assign('fld_'.$theFields[$i]->GetId().'_obj',$fldobj);
			if ($theFields[$i]->GetAlias() != '')
				{
		    	$mod->smarty->assign($theFields[$i]->GetAlias(),$replVal);
		    	$mod->smarty->assign($theFields[$i]->GetAlias().'_obj',$fldobj);
				}
	      }
		// general form details
		$mod->smarty->assign('sub_form_name',$this->GetName());
	    $mod->smarty->assign('sub_date',date('r'));
	    $mod->smarty->assign('sub_host',$_SERVER['SERVER_NAME']);
	    $mod->smarty->assign('sub_source_ip',$_SERVER['REMOTE_ADDR']);
	  	$mod->smarty->assign('sub_url',(empty($_SERVER['HTTP_REFERER'])?$mod->Lang('no_referrer_info'):$_SERVER['HTTP_REFERER']));
	    $mod->smarty->assign('fb_version',$mod->GetVersion());
	    $mod->smarty->assign('TAB',"\t");
	} 

	function manageFileUploads()
	{
		global $gCms;
		$theFields = &$this->GetFields();
		$mod = &$this->module_ptr;

	    for($i=0;$i<count($theFields);$i++)
	      {
	  		if (strtolower(get_class($theFields[$i])) == 'fbfileuploadfield' )
	    		{
	 		      // Handle file uploads
			      // if the uploads module is found, and the option is checked in
			      // the field, then the file is added to the uploads module
			      // and a link is added to the results
			      // if the option is not checked, then the file is merely uploaded to
				  // the "uploads" directory
			      //
	      		$_id = $theFields[$i]->GetValue();
	      		if( isset( $_FILES[$_id] ) && $_FILES[$_id]['size'] > 0 )
	        		{
	    			$thisFile =& $_FILES[$_id];
	    			if( $theFields[$i]->GetOption('sendto_uploads') )
	      				{
	        			// we have a file we can send to the uploads
	        			$uploads =& $mod->GetModuleInstance('Uploads');
	        			if( !$uploads )
	          				{
	      					// no uploads module
	      					audit(-1, $mod->GetName(), $mod->Lang('submit_error'),$mail->GetErrorInfo());
	            			return array($res, $mod->Lang('nouploads_error'));
	          				}

	        			$parms = array();
	        			$parms['input_author'] = $mod->Lang('anonymous');
	        			$parms['input_summary'] = $mod->Lang('title_uploadmodule_summary');
	        			$parms['category_id'] = $theFields[$i]->GetOption('uploads_category');
	        			$parms['field_name'] = $_id;
	        			$res = $uploads->AttemptUpload(-1,$parms,-1);
	        			if( $res[0] == false )
	          				{
	      					// failed upload kills the send.
	      					audit(-1, $mod->GetName(), $mod->Lang('submit_error',$res[1]));
	      					return array($res[0], $mod->Lang('uploads_error',$res[1]));
	          				}

	        			$uploads_destpage = $theFields[$i]->GetOption('uploads_destpage');
	        			$url = $uploads->CreateLink (-1, 'getfile', $uploads_destpage, '',
	             				array ('upload_id' => $row['upload_id']), '', true);
						$theFields[$i]->ResetValue();
	        			$theFields[$i]->SetValue($url);
	      				}
	    			else
	      				{
	        			// Handle the upload ourselves
						$src = $thisFile['tmp_name'];
						// this is safe[?] since we validated in FileUploadField's validate method.
						$dest = $gCms->config['uploads_path'].'/'.$thisFile['name'];
						if (! move_uploaded_file($src,$dest))
							{
							audit(-1, $mod->GetName(), $mod->Lang('submit_error',''));
		      				return array(false, $mod->Lang('uploads_error',''));
							}
						else
							{
							$url = $gCms->config['uploads_url'].'/'.$thisFile['name'];
							$theFields[$i]->ResetValue();
							$theFields[$i]->SetValue(array($dest,$url));
							}
	      				}
	        		}
	    		}
	      	}
		return array(true,'');
	}


}

?>
]]></data>
	</file>
	<file>
	  <filename>/classes/FromEmailAddressAgainField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/FromEmailAddressField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCgpjbGFzcyBmYkZyb21FbWFpbEFkZHJlc3NGaWVsZCBleHRlbmRzIGZiRmllbGRCYXNlIHsKCglmdW5jdGlvbiBmYkZyb21FbWFpbEFkZHJlc3NGaWVsZCgmJGZvcm1fcHRyLCAmJHBhcmFtcykKCXsKICAgICAgICAkdGhpcy0+ZmJGaWVsZEJhc2UoJGZvcm1fcHRyLCAkcGFyYW1zKTsKICAgICAgICAkbW9kID0gJiRmb3JtX3B0ci0+bW9kdWxlX3B0cjsKCQkkdGhpcy0+VHlwZSA9ICdGcm9tRW1haWxBZGRyZXNzRmllbGQnOwoJCSR0aGlzLT5EaXNwbGF5SW5Gb3JtID0gdHJ1ZTsKCQkkdGhpcy0+VmFsaWRhdGlvblR5cGVzID0gYXJyYXkoCiAgICAgICAgICAgICRtb2QtPkxhbmcoJ3ZhbGlkYXRpb25fZW1haWxfYWRkcmVzcycpPT4nZW1haWwnLAogICAgICAgICAgICApOwogICAgICAgICR0aGlzLT5WYWxpZGF0aW9uVHlwZSA9ICdlbWFpbCc7CgkgICAkdGhpcy0+bW9kaWZpZXNPdGhlckZpZWxkcyA9IHRydWU7Cgl9CgoJZnVuY3Rpb24gR2V0RmllbGRJbnB1dCgkaWQsICYkcGFyYW1zLCAkcmV0dXJuaWQpCgl7CgkJJG1vZCA9ICYkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CgkJJGpzID0gJHRoaXMtPkdldE9wdGlvbignamF2YXNjcmlwdCcsJycpOwoJCQoJCXJldHVybiAkbW9kLT5DcmVhdGVJbnB1dFRleHQoJGlkLCAnZmJycF9fJy4kdGhpcy0+SWQsCgkJCWh0bWxzcGVjaWFsY2hhcnMoJHRoaXMtPlZhbHVlLCBFTlRfUVVPVEVTKSwKICAgICAgICAgICAyNSwxMjgsJGpzKTsKCX0KCQoJZnVuY3Rpb24gTW9kaWZ5T3RoZXJGaWVsZHMoKQoJewoJCSRtb2QgPSAmJHRoaXMtPmZvcm1fcHRyLT5tb2R1bGVfcHRyOwoJCSRvdGhlcnMgPSAmJHRoaXMtPmZvcm1fcHRyLT5HZXRGaWVsZHMoKTsKCQlpZiAoJHRoaXMtPlZhbHVlICE9PSBmYWxzZSkKCQkJewoJCQlmb3IoJGk9MDskaTxjb3VudCgkb3RoZXJzKTskaSsrKQoJCQkJewoJCQkJJHJlcGxWYWwgPSAnJzsKCQkJCWlmICgkb3RoZXJzWyRpXS0+SXNEaXNwb3NpdGlvbigpICYmIGlzX3N1YmNsYXNzX29mKCRvdGhlcnNbJGldLCdmYkRpc3Bvc2l0aW9uRW1haWxCYXNlJykpCgkJCQkJewoJCQkJCSRvdGhlcnNbJGldLT5TZXRPcHRpb24oJ2VtYWlsX2Zyb21fYWRkcmVzcycsJHRoaXMtPlZhbHVlKTsKCQkJCQl9CgkJCQl9CgkJCX0KCX0KCglmdW5jdGlvbiBTdGF0dXNJbmZvKCkKCXsKCQlyZXR1cm4gJyc7Cgl9CgoJZnVuY3Rpb24gVmFsaWRhdGUoKQoJewoJCSR0aGlzLT52YWxpZGF0ZWQgPSB0cnVlOwoJCSR0aGlzLT52YWxpZGF0aW9uRXJyb3JUZXh0ID0gJyc7CgkJJG1vZCA9ICYkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CgkJc3dpdGNoICgkdGhpcy0+VmFsaWRhdGlvblR5cGUpCgkJICB7CgkJICAJICAgY2FzZSAnZW1haWwnOgogICAgICAgICAgICAgICAgICBpZiAoJHRoaXMtPlZhbHVlICE9PSBmYWxzZSAmJgogICAgICAgICAgICAgICAgICAgICAgISBwcmVnX21hdGNoKCgkbW9kLT5HZXRQcmVmZXJlbmNlKCdyZWxheGVkX2VtYWlsX3JlZ2V4JywnMCcpPT0wPyRtb2QtPmVtYWlsX3JlZ2V4OiRtb2QtPmVtYWlsX3JlZ2V4X3JlbGF4ZWQpLCAkdGhpcy0+VmFsdWUpKQogICAgICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAkdGhpcy0+dmFsaWRhdGVkID0gZmFsc2U7CiAgICAgICAgICAgICAgICAgICAgJHRoaXMtPnZhbGlkYXRpb25FcnJvclRleHQgPSAkbW9kLT5MYW5nKCdwbGVhc2VfZW50ZXJfYW5fZW1haWwnLCR0aGlzLT5OYW1lKTsKICAgICAgICAgICAgICAgICAgICB9CgkJICAJICAgICAgIGJyZWFrOwoJCSAgfQoJCXJldHVybiBhcnJheSgkdGhpcy0+dmFsaWRhdGVkLCAkdGhpcy0+dmFsaWRhdGlvbkVycm9yVGV4dCk7Cgl9Cn0KCj8+Cg==]]></data>
	</file>
	<file>
	  <filename>/classes/FromEmailNameField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCgpjbGFzcyBmYkZyb21FbWFpbE5hbWVGaWVsZCBleHRlbmRzIGZiRmllbGRCYXNlIHsKCglmdW5jdGlvbiBmYkZyb21FbWFpbE5hbWVGaWVsZCgmJGZvcm1fcHRyLCAmJHBhcmFtcykKCXsKICAgICAgICAkdGhpcy0+ZmJGaWVsZEJhc2UoJGZvcm1fcHRyLCAkcGFyYW1zKTsKICAgICAgICAkbW9kID0gJiRmb3JtX3B0ci0+bW9kdWxlX3B0cjsKCQkkdGhpcy0+VHlwZSA9ICdGcm9tRW1haWxOYW1lRmllbGQnOwoJCSR0aGlzLT5EaXNwbGF5SW5Gb3JtID0gdHJ1ZTsKCQkkdGhpcy0+VmFsaWRhdGlvblR5cGVzID0gYXJyYXkoCiAgICAgICAgICAgICk7CgkgICAkdGhpcy0+bW9kaWZpZXNPdGhlckZpZWxkcyA9IHRydWU7Cgl9CgoJZnVuY3Rpb24gR2V0RmllbGRJbnB1dCgkaWQsICYkcGFyYW1zLCAkcmV0dXJuaWQpCgl7CgkJJG1vZCA9ICYkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CgkJJGpzID0gJHRoaXMtPkdldE9wdGlvbignamF2YXNjcmlwdCcsJycpOwoJCQoJCXJldHVybiAkbW9kLT5DcmVhdGVJbnB1dFRleHQoJGlkLCAnZmJycF9fJy4kdGhpcy0+SWQsCgkJCWh0bWxzcGVjaWFsY2hhcnMoJHRoaXMtPlZhbHVlLCBFTlRfUVVPVEVTKSwKICAgICAgICAgICAyNSwxMjgsJGpzKTsKCX0KCQoJZnVuY3Rpb24gTW9kaWZ5T3RoZXJGaWVsZHMoKQoJewoJCSRtb2QgPSAmJHRoaXMtPmZvcm1fcHRyLT5tb2R1bGVfcHRyOwoJCSRvdGhlcnMgPSAmJHRoaXMtPmZvcm1fcHRyLT5HZXRGaWVsZHMoKTsKCQlpZiAoJHRoaXMtPlZhbHVlICE9PSBmYWxzZSkKCQkJewkJCgkJCWZvcigkaT0wOyRpPGNvdW50KCRvdGhlcnMpOyRpKyspCgkJCQl7CgkJCQkkcmVwbFZhbCA9ICcnOwoJCQkJaWYgKCRvdGhlcnNbJGldLT5Jc0Rpc3Bvc2l0aW9uKCkgJiYgaXNfc3ViY2xhc3Nfb2YoJG90aGVyc1skaV0sJ2ZiRGlzcG9zaXRpb25FbWFpbEJhc2UnKSkKCQkJCQl7CgkJCQkJJG90aGVyc1skaV0tPlNldE9wdGlvbignZW1haWxfZnJvbV9uYW1lJywkdGhpcy0+VmFsdWUpOwoJCQkJCX0KCQkJCX0KCQkJfQoJfQoKCWZ1bmN0aW9uIFN0YXR1c0luZm8oKQoJewoJCXJldHVybiAnJzsKCX0KCn0KCj8+Cg==]]></data>
	</file>
	<file>
	  <filename>/classes/FromEmailSubjectField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCgpjbGFzcyBmYkZyb21FbWFpbFN1YmplY3RGaWVsZCBleHRlbmRzIGZiRmllbGRCYXNlIHsKCglmdW5jdGlvbiBmYkZyb21FbWFpbFN1YmplY3RGaWVsZCgmJGZvcm1fcHRyLCAmJHBhcmFtcykKCXsKICAgICAgICAkdGhpcy0+ZmJGaWVsZEJhc2UoJGZvcm1fcHRyLCAkcGFyYW1zKTsKICAgICAgICAkbW9kID0gJiRmb3JtX3B0ci0+bW9kdWxlX3B0cjsKCQkkdGhpcy0+VHlwZSA9ICdGcm9tRW1haWxTdWJqZWN0RmllbGQnOwoJCSR0aGlzLT5EaXNwbGF5SW5Gb3JtID0gdHJ1ZTsKCQkkdGhpcy0+VmFsaWRhdGlvblR5cGVzID0gYXJyYXkoCiAgICAgICAgICAgICk7CgkgICAkdGhpcy0+bW9kaWZpZXNPdGhlckZpZWxkcyA9IHRydWU7Cgl9CgoJZnVuY3Rpb24gR2V0RmllbGRJbnB1dCgkaWQsICYkcGFyYW1zLCAkcmV0dXJuaWQpCgl7CgkJJG1vZCA9ICYkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CgkJJGpzID0gJHRoaXMtPkdldE9wdGlvbignamF2YXNjcmlwdCcsJycpOwoJCQoJCXJldHVybiAkbW9kLT5DcmVhdGVJbnB1dFRleHQoJGlkLCAnZmJycF9fJy4kdGhpcy0+SWQsCgkJCWh0bWxzcGVjaWFsY2hhcnMoJHRoaXMtPlZhbHVlLCBFTlRfUVVPVEVTKSwKICAgICAgICAgICAyNSwxMjgsJGpzKTsKCX0KCQoJZnVuY3Rpb24gTW9kaWZ5T3RoZXJGaWVsZHMoKQoJewoJCSRtb2QgPSAmJHRoaXMtPmZvcm1fcHRyLT5tb2R1bGVfcHRyOwoJCSRvdGhlcnMgPSAmJHRoaXMtPmZvcm1fcHRyLT5HZXRGaWVsZHMoKTsKCQlpZiAoJHRoaXMtPlZhbHVlICE9PSBmYWxzZSkKCQkJewkJCgkJCWZvcigkaT0wOyRpPGNvdW50KCRvdGhlcnMpOyRpKyspCgkJCQl7CgkJCQkkcmVwbFZhbCA9ICcnOwoJCQkJaWYgKCRvdGhlcnNbJGldLT5Jc0Rpc3Bvc2l0aW9uKCkgJiYgaXNfc3ViY2xhc3Nfb2YoJG90aGVyc1skaV0sJ2ZiRGlzcG9zaXRpb25FbWFpbEJhc2UnKSkKCQkJCQl7CgkJCQkJJG90aGVyc1skaV0tPlNldE9wdGlvbignZW1haWxfc3ViamVjdCcsJHRoaXMtPlZhbHVlKTsKCQkJCQl9CgkJCQl9CgkJCX0KCX0KCglmdW5jdGlvbiBTdGF0dXNJbmZvKCkKCXsKCQlyZXR1cm4gJyc7Cgl9Cgp9Cgo/Pgo=]]></data>
	</file>
	<file>
	  <filename>/classes/HiddenField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/LinkField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/MultiselectField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCgpjbGFzcyBmYk11bHRpc2VsZWN0RmllbGQgZXh0ZW5kcyBmYkZpZWxkQmFzZSB7CgoJdmFyICRvcHRpb25Db3VudDsKCXZhciAkb3B0aW9uQWRkOwoKCWZ1bmN0aW9uIGZiTXVsdGlzZWxlY3RGaWVsZCgmJGZvcm1fcHRyLCAmJHBhcmFtcykKCXsKICAgICAgICR0aGlzLT5mYkZpZWxkQmFzZSgkZm9ybV9wdHIsICRwYXJhbXMpOwogICAgICAgICRtb2QgPSAmJGZvcm1fcHRyLT5tb2R1bGVfcHRyOwoJCSR0aGlzLT5UeXBlID0gJ011bHRpc2VsZWN0RmllbGQnOwoJCSR0aGlzLT5EaXNwbGF5SW5Gb3JtID0gdHJ1ZTsKCQkkdGhpcy0+Tm9uUmVxdWlyYWJsZUZpZWxkID0gZmFsc2U7CgkJJHRoaXMtPkhhc0FkZE9wID0gdHJ1ZTsKCQkkdGhpcy0+SGFzRGVsZXRlT3AgPSB0cnVlOwoJCSR0aGlzLT5WYWxpZGF0aW9uVHlwZXMgPSBhcnJheSgKICAgICAgICAgICAgKTsKICAgICAgICAkdGhpcy0+b3B0aW9uQWRkID0gMDsKICAgICAgICAkdGhpcy0+c29ydGFibGUgPSBmYWxzZTsKCX0KCglmdW5jdGlvbiBHZXRPcHRpb25BZGRCdXR0b24oKQoJewoJCSRtb2QgPSAmJHRoaXMtPmZvcm1fcHRyLT5tb2R1bGVfcHRyOwoJCXJldHVybiAkbW9kLT5MYW5nKCdhZGRfb3B0aW9ucycpOwoJfQoKCWZ1bmN0aW9uIEdldE9wdGlvbkRlbGV0ZUJ1dHRvbigpCgl7CgkJJG1vZCA9ICYkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CgkJcmV0dXJuICRtb2QtPkxhbmcoJ2RlbGV0ZV9vcHRpb25zJyk7Cgl9CgoJZnVuY3Rpb24gRG9PcHRpb25BZGQoJiRwYXJhbXMpCgl7CgkJJHRoaXMtPm9wdGlvbkFkZCA9IDI7Cgl9CgoJZnVuY3Rpb24gRG9PcHRpb25EZWxldGUoJiRwYXJhbXMpCgl7CgkJJGRlbGNvdW50ID0gMDsKCQlmb3JlYWNoICgkcGFyYW1zIGFzICR0aGlzS2V5PT4kdGhpc1ZhbCkKCQkJewoJCQlpZiAoc3Vic3RyKCR0aGlzS2V5LDAsOSkgPT0gJ2ZicnBfZGVsXycpCgkJCQl7CgkJCQkkdGhpcy0+UmVtb3ZlT3B0aW9uRWxlbWVudCgnb3B0aW9uX25hbWUnLCAkdGhpc1ZhbCAtICRkZWxjb3VudCk7CgkJCQkkdGhpcy0+UmVtb3ZlT3B0aW9uRWxlbWVudCgnb3B0aW9uX3ZhbHVlJywgJHRoaXNWYWwgLSAkZGVsY291bnQpOwoJCQkJJGRlbGNvdW50Kys7CgkJCQl9CgkJCX0KCX0KCglmdW5jdGlvbiBjb3VudEl0ZW1zKCkKCXsKCQkJJHRtcCA9ICYkdGhpcy0+R2V0T3B0aW9uUmVmKCdvcHRpb25fbmFtZScpOwoJCQlpZiAoaXNfYXJyYXkoJHRtcCkpCgkJCQl7CgkgICAgICAgIAkkdGhpcy0+b3B0aW9uQ291bnQgPSBjb3VudCgkdG1wKTsKCSAgICAgICAgCX0KCSAgICAgICAgZWxzZWlmICgkdG1wICE9PSBmYWxzZSkKCSAgICAgICAgCXsKCSAgICAgICAgCSR0aGlzLT5vcHRpb25Db3VudCA9IDE7CgkgICAgICAgIAl9CgkgICAgICAgIGVsc2UKCSAgICAgICAgCXsKCSAgICAgICAgCSR0aGlzLT5vcHRpb25Db3VudCA9IDA7CgkgICAgICAgIAl9Cgl9CgoJZnVuY3Rpb24gR2V0RmllbGRJbnB1dCgkaWQsICYkcGFyYW1zLCAkcmV0dXJuaWQpCgl7CgkJJG1vZCA9ICYkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CgkJJGpzID0gJHRoaXMtPkdldE9wdGlvbignamF2YXNjcmlwdCcsJycpOwoKCQkvLyB3aHkgYWxsIHRoaXM/IEFzc29jaWF0aXZlIGFycmF5cyBhcmUgbm90IGd1YXJhbnRlZWQgdG8gcHJlc2VydmUKCQkvLyBvcmRlciwgZXhjZXB0IGluICJjaHJvbm9sb2dpY2FsIiBjcmVhdGlvbiBvcmRlci4KCQkkc29ydGVkID1hcnJheSgpOwoJCSRzdWJqZWN0cyA9ICYkdGhpcy0+R2V0T3B0aW9uUmVmKCdvcHRpb25fbmFtZScpOwoKCQlpZiAoY291bnQoJHN1YmplY3RzKSA+IDEpCgkJCXsKCQkJZm9yKCRpPTA7JGk8Y291bnQoJHN1YmplY3RzKTskaSsrKQoJCQkJewoJCQkJJHNvcnRlZFskc3ViamVjdHNbJGldXT0oJGkrMSk7CgkJCQl9CgkJCX0KCQllbHNlCgkJCXsKCQkJJHNvcnRlZFskc3ViamVjdHNdID0gJzEnOwoJCQl9CgkJaWYgKCR0aGlzLT5WYWx1ZSA9PT0gZmFsc2UpCgkJCXsKCQkJJHZhbCA9IGFycmF5KCk7CgkJCX0KCQllbHNlaWYgKCFpc19hcnJheSgkdGhpcy0+VmFsdWUpKQoJCQl7CgkJCSR2YWwgPSBhcnJheSgkdGhpcy0+VmFsdWUpOwoJCQl9CgkJZWxzZQoJCQl7CgkJCSR2YWwgPSAkdGhpcy0+VmFsdWU7CgkJCX0KCQlyZXR1cm4gJG1vZC0+Q3JlYXRlSW5wdXRTZWxlY3RMaXN0KCRpZCwgJ2ZicnBfXycuJHRoaXMtPklkLidbXScsICRzb3J0ZWQsJHZhbCwgJHRoaXMtPkdldE9wdGlvbignbGluZXMnLCczJyksCiAgICAgICAgICdpZD0iJy4kaWQuICdfJy4kdGhpcy0+SWQuJyIgJy4kanMpOwoJfQoKCgogICAgZnVuY3Rpb24gU3RhdHVzSW5mbygpCgl7CgkJJG1vZCA9ICYkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CgkJJG9wdCA9ICR0aGlzLT5HZXRPcHRpb24oJ29wdGlvbl9uYW1lJywnJyk7CgkJCgkJaWYgKGlzX2FycmF5KCRvcHQpKQoJCSAgewoJCSAgICAgICRudW0gPSBjb3VudCgkb3B0KTsKCQkgIH0KCQllbHNlaWYgKCRvcHQgIT0gJycpCgkJCXsKCQkJJG51bSA9IDE7CgkJCX0KCQllbHNlCgkJICB7CiAgICAgICAgICAkbnVtID0gMDsKICAgICAgICAgIH0KICAgICAgICAgJHJldD0gJG1vZC0+TGFuZygnb3B0aW9ucycsJG51bSk7CiAgICAgICAgcmV0dXJuICRyZXQ7Cgl9CgkKCWZ1bmN0aW9uIFByZVBvcHVsYXRlQWRtaW5Gb3JtKCRmb3JtRGVzY3JpcHRvcikKCXsKCQkkbW9kID0gJiR0aGlzLT5mb3JtX3B0ci0+bW9kdWxlX3B0cjsKCgkJJHRoaXMtPmNvdW50SXRlbXMoKTsKCQlpZiAoJHRoaXMtPm9wdGlvbkFkZCA+IDApCgkJCXsKCQkJJHRoaXMtPm9wdGlvbkNvdW50ICs9ICR0aGlzLT5vcHRpb25BZGQ7CgkJCSR0aGlzLT5vcHRpb25BZGQgPSAwOwoJCQl9CgkJJGRlc3RzID0gJzx0YWJsZSBjbGFzcz0ibW9kdWxlX2ZiX3RhYmxlIj48dHI+PHRoPicuJG1vZC0+TGFuZygndGl0bGVfb3B0aW9uX25hbWUnKS4nPC90aD48dGg+Jy4KCQkJJG1vZC0+TGFuZygndGl0bGVfb3B0aW9uX3ZhbHVlJykuJzwvdGg+PHRoPicuCgkJCSRtb2QtPkxhbmcoJ3RpdGxlX2RlbGV0ZScpLic8L3RoPjwvdHI+JzsKCgoJCWZvciAoJGk9MDskaTwoJHRoaXMtPm9wdGlvbkNvdW50PjE/JHRoaXMtPm9wdGlvbkNvdW50OjEpOyRpKyspCgkJCXsKCQkJJGRlc3RzIC49ICAnPHRyPjx0ZD4nLgogICAgICAgICAgICAJCSRtb2QtPkNyZWF0ZUlucHV0VGV4dCgkZm9ybURlc2NyaXB0b3IsICdmYnJwX29wdF9vcHRpb25fbmFtZVtdJywkdGhpcy0+R2V0T3B0aW9uRWxlbWVudCgnb3B0aW9uX25hbWUnLCRpKSwyNSwxMjgpLgogICAgICAgICAgICAJCSc8L3RkPjx0ZD4nLgogICAgICAgICAgICAJCSRtb2QtPkNyZWF0ZUlucHV0VGV4dCgkZm9ybURlc2NyaXB0b3IsICdmYnJwX29wdF9vcHRpb25fdmFsdWVbXScsJHRoaXMtPkdldE9wdGlvbkVsZW1lbnQoJ29wdGlvbl92YWx1ZScsJGkpLDI1LDEyOCkuCiAgICAgICAgICAgIAkJJzwvdGQ+PHRkPicuCiAgICAgICAgICAgIAkJJG1vZC0+Q3JlYXRlSW5wdXRDaGVja2JveCgkZm9ybURlc2NyaXB0b3IsICdmYnJwX2RlbF8nLiRpLCAkaSwtMSkuCiAgICAgICAgICAgICAJCSc8L3RkPjwvdHI+JzsKCQkJfQoJCSRkZXN0cyAuPSAnPC90YWJsZT4nOwoJCSRtYWluID0gYXJyYXkoKTsKCQkkYWR2ID0gYXJyYXkoKTsKCQlhcnJheV9wdXNoKCRtYWluLGFycmF5KCRtb2QtPkxhbmcoJ3RpdGxlX2xpbmVzX3RvX3Nob3cnKSwkbW9kLT5DcmVhdGVJbnB1dFRleHQoJGZvcm1EZXNjcmlwdG9yLCAnZmJycF9vcHRfbGluZXMnLCR0aGlzLT5HZXRPcHRpb24oJ2xpbmVzJywnMycpLDEwLDEwKSkpOwoJCWFycmF5X3B1c2goJG1haW4sYXJyYXkoJG1vZC0+TGFuZygndGl0bGVfbXVsdGlzZWxlY3RfZGV0YWlscycpLCRkZXN0cykpOwoJCXJldHVybiBhcnJheSgnbWFpbic9PiRtYWluLCdhZHYnPT4kYWR2KTsKCX0KCglmdW5jdGlvbiBHZXRIdW1hblJlYWRhYmxlVmFsdWUoJGFzX3N0cmluZz10cnVlKQoJewoJCSRtb2QgPSAmJHRoaXMtPmZvcm1fcHRyLT5tb2R1bGVfcHRyOwoJCSRmb3JtID0gJiR0aGlzLT5mb3JtX3B0cjsKCQkkdmFscyA9ICYkdGhpcy0+R2V0T3B0aW9uUmVmKCdvcHRpb25fdmFsdWUnKTsKCQlpZiAoJHRoaXMtPkhhc1ZhbHVlKCkpCgkJCXsKCQkJJGZpZWxkUmV0ID0gYXJyYXkoKTsKCQkJaWYgKCEgaXNfYXJyYXkoJHRoaXMtPlZhbHVlKSkKCQkJCXsKCQkJCSR0aGlzLT5WYWx1ZSA9IGFycmF5KCR0aGlzLT5WYWx1ZSk7CgkJCQl9CgkJCWZvcmVhY2ggKCR0aGlzLT5WYWx1ZSBhcyAkdGhpc09uZSkKCQkJCXsKCQkJCWFycmF5X3B1c2goJGZpZWxkUmV0LCR2YWxzWyR0aGlzT25lIC0gMV0pOwoJCQkJfQoJCQlpZiAoJGFzX3N0cmluZykKCQkJCXsKCQkJCXJldHVybiBqb2luKCRmb3JtLT5HZXRBdHRyKCdsaXN0X2RlbGltaXRlcicsJywnKSwkZmllbGRSZXQpOwoJCQkJfQoJCQllbHNlCgkJCQl7CgkJCQlyZXR1cm4gYXJyYXkoJGZpZWxkUmV0KTsKCQkJCX0JCQkKCQkJfQoJCWVsc2UKCQkJewoJCQlpZiAoJGFzX3N0cmluZykKCQkJCXsKCQkJCXJldHVybiAkbW9kLT5MYW5nKCd1bnNwZWNpZmllZCcpOwoJCQkJfQoJCQllbHNlCgkJCQl7CgkJCQlyZXR1cm4gYXJyYXkoJG1vZC0+TGFuZygndW5zcGVjaWZpZWQnKSk7CgkJCQl9CgkJCX0KCQoJfQkKfQo/Pgo=]]></data>
	</file>
	<file>
	  <filename>/classes/PageBreakField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/ProvincePickerField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLy8gRmVlZGJhY2sgRm9ybS4gMDIvMjAwNSBTakcgPGZlZWRiYWNrZm9ybV9jbXNtb2R1bGVAZm9nYm91bmQubmV0PgovLyBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCAoYykyMDA1IGJ5IFRlZCBLdWxwICh3aXNoeUBjbXNtYWRlc2ltcGxlLm9yZykKLy8gVGhpcyBwcm9qZWN0J3MgaG9tZXBhZ2UgaXM6IGh0dHA6Ly93d3cuY21zbWFkZXNpbXBsZS5vcmcKCmNsYXNzIGZiUHJvdmluY2VQaWNrZXJGaWVsZCBleHRlbmRzIGZiRmllbGRCYXNlIHsKCgl2YXIgJFByb3ZpbmNlczsKCQoJZnVuY3Rpb24gZmJQcm92aW5jZVBpY2tlckZpZWxkKCYkZm9ybV9wdHIsICYkcGFyYW1zKQoJewogICAgICAgICR0aGlzLT5mYkZpZWxkQmFzZSgkZm9ybV9wdHIsICRwYXJhbXMpOwogICAgICAgICRtb2QgPSAmJGZvcm1fcHRyLT5tb2R1bGVfcHRyOwoJCSR0aGlzLT5UeXBlID0gJ1Byb3ZpbmNlUGlja2VyRmllbGQnOwoJCSR0aGlzLT5EaXNwbGF5SW5Gb3JtID0gdHJ1ZTsKCQkkdGhpcy0+VmFsaWRhdGlvblR5cGVzID0gYXJyYXkoCiAgICAgICAgICAgICk7CgogICAgICAgICR0aGlzLT5Qcm92aW5jZXMgPSBhcnJheSgKICAgICAgICAiTm8gRGVmYXVsdCI9PicnLCJBbGJlcnRhIj0+IkFCIiwgIkJyaXRpc2ggQ29sdW1iaWEiPT4iQkMiLCAiTWFuaXRvYmEiPT4iTUIiLCAiTmV3IEJydW5zd2ljayI9PiJOQiIsIAogICAgICAgICJOZXdmb3VuZGxhbmQgYW5kIExhYnJhZG9yIj0+Ik5MIiwgIk5vcnRod2VzdCBUZXJyaXRvcmllcyI9PiJOVCIsICJOb3ZhIFNjb3RpYSI9PiJOUyIsICJOdW5hdnV0Ij0+Ik5VIiwgCiAgICAgICAgIk9udGFyaW8iPT4iT04iLCAiUHJpbmNlIEVkd2FyZCBJc2xhbmQiPT4iUEUiLCAiUXVlYmVjIj0+IlFDIiwgIlNhc2thdGNoZXdhbiI9PiJTSyIsICJZdWtvbiI9PiJZVCIpOwoKCX0KCgogICAgZnVuY3Rpb24gU3RhdHVzSW5mbygpCgl7CgkJcmV0dXJuICcnOwoJfQoKCWZ1bmN0aW9uIEdldEh1bWFuUmVhZGFibGVWYWx1ZSgkYXNfc3RyaW5nPXRydWUpCgl7CgkJJHJldCA9IGFycmF5X3NlYXJjaCgkdGhpcy0+VmFsdWUsJHRoaXMtPlByb3ZpbmNlcyk7CgkJaWYgKCRhc19zdHJpbmcpCgkJCXsKCQkJcmV0dXJuICRyZXQ7CgkJCX0KCQllbHNlCgkJCXsKCQkJcmV0dXJuIGFycmF5KCRyZXQpOwoJCQl9Cgl9CgoKCWZ1bmN0aW9uIEdldEZpZWxkSW5wdXQoJGlkLCAmJHBhcmFtcywgJHJldHVybmlkKQoJewoJCSRtb2QgPSAmJHRoaXMtPmZvcm1fcHRyLT5tb2R1bGVfcHRyOwoJCSRqcyA9ICR0aGlzLT5HZXRPcHRpb24oJ2phdmFzY3JpcHQnLCcnKTsKCgkJdW5zZXQoJHRoaXMtPlByb3ZpbmNlc1skbW9kLT5MYW5nKCdub19kZWZhdWx0JyldKTsKCQlpZiAoJHRoaXMtPkdldE9wdGlvbignc2VsZWN0X29uZScsJycpICE9ICcnKQoJCQl7CgkJCSR0aGlzLT5Qcm92aW5jZXMgPSBhcnJheV9tZXJnZShhcnJheSgkdGhpcy0+R2V0T3B0aW9uKCdzZWxlY3Rfb25lJywnJyk9PicnKSwkdGhpcy0+UHJvdmluY2VzKTsKCQkJfQoJCWVsc2UKCQkJewoJCQkkdGhpcy0+UHJvdmluY2VzID0gYXJyYXlfbWVyZ2UoYXJyYXkoJG1vZC0+TGFuZygnc2VsZWN0X29uZScpPT4nJyksJHRoaXMtPlByb3ZpbmNlcyk7CgkJCX0KCgoJCWlmICghICR0aGlzLT5IYXNWYWx1ZSgpICYmICR0aGlzLT5HZXRPcHRpb24oJ2RlZmF1bHQnLCcnKSAhPSAnJykKCQkgIHsKCQkgICR0aGlzLT5TZXRWYWx1ZSgkdGhpcy0+R2V0T3B0aW9uKCdkZWZhdWx0JywnJykpOwoJCSAgfQoKCQlyZXR1cm4gJG1vZC0+Q3JlYXRlSW5wdXREcm9wZG93bigkaWQsICdmYnJwX18nLiR0aGlzLT5JZCwgJHRoaXMtPlByb3ZpbmNlcywgLTEsICR0aGlzLT5WYWx1ZSwnaWQ9IicuJGlkLiAnXycuJHRoaXMtPklkLiciICcuJGpzKTsKCX0KCglmdW5jdGlvbiBQcmVQb3B1bGF0ZUFkbWluRm9ybSgkZm9ybURlc2NyaXB0b3IpCgl7CgkJJG1vZCA9ICYkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CgkJa3NvcnQoJHRoaXMtPlByb3ZpbmNlcyk7CgoJCSRtYWluID0gYXJyYXkoCgkJCWFycmF5KCRtb2QtPkxhbmcoJ3RpdGxlX3NlbGVjdF9kZWZhdWx0X3Byb3ZpbmNlJyksCiAgICAgICAgICAgIAkJJG1vZC0+Q3JlYXRlSW5wdXREcm9wZG93bigkZm9ybURlc2NyaXB0b3IsICdmYnJwX29wdF9kZWZhdWx0JywKICAgICAgICAgICAgCQkkdGhpcy0+UHJvdmluY2VzLCAtMSwgJHRoaXMtPkdldE9wdGlvbignZGVmYXVsdCcsJycpKSksCgkJCWFycmF5KCRtb2QtPkxhbmcoJ3RpdGxlX3NlbGVjdF9vbmVfbWVzc2FnZScpLAogICAgICAgICAgICAJCSRtb2QtPkNyZWF0ZUlucHV0VGV4dCgkZm9ybURlc2NyaXB0b3IsICdmYnJwX29wdF9zZWxlY3Rfb25lJywKICAgICAgICAgICAgCQkkdGhpcy0+R2V0T3B0aW9uKCdzZWxlY3Rfb25lJywkbW9kLT5MYW5nKCdzZWxlY3Rfb25lJykpKSkKCQkpOwoJCXJldHVybiBhcnJheSgnbWFpbic9PiRtYWluLGFycmF5KCkpOwoJfQoKCn0KCj8+Cg==]]></data>
	</file>
	<file>
	  <filename>/classes/PulldownField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/RadioGroupField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/StatePickerField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/StaticTextField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/SystemLinkField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/TextAreaField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlndGggKGMpMjAwNiBieSBUZWQgS3VscCAod2lzaHlAY21zbWFkZXNpbXBsZS5vcmcpCiAgVGhpcyBwcm9qZWN0J3MgaG9tZXBhZ2UgaXM6IGh0dHA6Ly93d3cuY21zbWFkZXNpbXBsZS5vcmcKKi8KCmNsYXNzIGZiVGV4dEFyZWFGaWVsZCBleHRlbmRzIGZiRmllbGRCYXNlIHsKCglmdW5jdGlvbiBmYlRleHRBcmVhRmllbGQoJiRmb3JtX3B0ciwgJiRwYXJhbXMpCgl7CiAgICAgICR0aGlzLT5mYkZpZWxkQmFzZSgkZm9ybV9wdHIsICRwYXJhbXMpOwoJCSRtb2QgPSAmJGZvcm1fcHRyLT5tb2R1bGVfcHRyOwoJCSR0aGlzLT5UeXBlID0gJ1RleHRBcmVhRmllbGQnOwoJCSR0aGlzLT5EaXNwbGF5SW5Gb3JtID0gdHJ1ZTsKCQkkdGhpcy0+VmFsaWRhdGlvblR5cGVzID0gYXJyYXkoCiAgICAgICAgICAgICRtb2QtPkxhbmcoJ3ZhbGlkYXRpb25fbm9uZScpPT4nbm9uZScsCiAgICAgICAgICAgICk7CgoJfQoKCWZ1bmN0aW9uIEdldEZpZWxkSW5wdXQoJGlkLCAmJHBhcmFtcywgJHJldHVybmlkKQoJeyAgICAgICAgICAgIAoJICAgJG1vZCA9ICYkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CQogICAgICAgJHJldCA9ICRtb2QtPkNyZWF0ZVRleHRBcmVhKAoJCQkJICAoJHRoaXMtPkdldE9wdGlvbignd3lzaXd5ZycsJzAnKSA9PSAnMSc/dHJ1ZTpmYWxzZSksCgkJCQkgICAkaWQsCgkJCQkgICgkdGhpcy0+VmFsdWU/JHRoaXMtPlZhbHVlOiR0aGlzLT5HZXRPcHRpb24oJ2RlZmF1bHQnKSksCgkJCQkgICAnZmJycF9fJy4kdGhpcy0+SWQsCgkJCQkgICcnLAoJCQkJICAkaWQuJ2ZicnBfXycuJHRoaXMtPklkLAoJCQkJICAnJywKCQkJCSAgJycsCiAgICAgICAgICAgICAgIAkgICR0aGlzLT5HZXRPcHRpb24oJ2NvbHMnLCc4MCcpLAoJCQkJICAkdGhpcy0+R2V0T3B0aW9uKCdyb3dzJywnMTUnKSk7CgkJaWYgKCR0aGlzLT5HZXRPcHRpb24oJ2NsZWFyX2RlZmF1bHQnLCcwJyk9PScxJykKCQkJewoJCQkkcmV0IC49ICc8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+JzsKCQkJJHJldCAuPSAiXG52YXIgZiA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCciLiRpZC4iZmJycF9fIi4kdGhpcy0+SWQuIicpO1xuIjsKCQkJJHJldCAuPSAiaWYgKGYpXG57XG5mLm9uY2xpY2s9ZnVuY3Rpb24oKXtcbmlmICh0aGlzLnZhbHVlPT0nIjsKCQkJJHJldCAuPSBwcmVnX3JlcGxhY2UoJy8oXHIpP1xuLycsJ1xcbicsJHRoaXMtPkdldE9wdGlvbignZGVmYXVsdCcpKS4iJykge3RoaXMudmFsdWU9Jyc7fVxufVxuIjsKCQkJJHJldCAuPSAifVxuOyI7CgkJCSRyZXQgLj0gIjwvc2NyaXB0PlxuIjsKCQkJfQoKCQlyZXR1cm4gJHJldDsKCS8vQ3JlYXRlVGV4dEFyZWEoJGVuYWJsZXd5c2l3eWcsICRpZCwgJHRleHQsICRuYW1lLCAkY2xhc3NuYW1lPScnLCAkaHRtbGlkPScnLCAkZW5jb2Rpbmc9JycsICRzdHlsZXNoZWV0PScnLCAkd2lkdGg9JzgwJywgJGNvbHM9JzE1JywkZm9yY2V3eXNpd3lnPSIiLCR3YW50ZWRzeW50YXg9IiIpCgogICB9CgoKCWZ1bmN0aW9uIFN0YXR1c0luZm8oKQoJewoJICAgJG1vZCA9ICYkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CgkJJHJldCA9ICcnOwoJCWlmIChzdHJsZW4oJHRoaXMtPlZhbGlkYXRpb25UeXBlKT4wKQoJCSAgewoJCSAgCSRyZXQgPSBhcnJheV9zZWFyY2goJHRoaXMtPlZhbGlkYXRpb25UeXBlLCR0aGlzLT5WYWxpZGF0aW9uVHlwZXMpOwoJCSAgfQoJCSBpZiAoJHRoaXMtPkdldE9wdGlvbignd3lzaXd5ZycsJzAnKSA9PSAnMScpCgkJIAl7CgkJIAkkcmV0IC49ICcgd3lzaXd5Zyc7CgkJIAl9CgkJIGVsc2UKCQkgCXsKCQkgCSRyZXQgLj0gJyBub24td3lzaXd5Zyc7CgkJIAl9CgkJICRyZXQgLj0gICcsICcuJG1vZC0+TGFuZygncm93cycsJHRoaXMtPkdldE9wdGlvbigncm93cycsJzE1JykpOwoJCSAkcmV0IC49ICAnLCAnLiRtb2QtPkxhbmcoJ2NvbHMnLCR0aGlzLT5HZXRPcHRpb24oJ2NvbHMnLCc4MCcpKTsKCQkgcmV0dXJuICRyZXQ7Cgl9CgoKCWZ1bmN0aW9uIFByZVBvcHVsYXRlQWRtaW5Gb3JtKCRmb3JtRGVzY3JpcHRvcikKCXsKCSAgICRtb2QgPSAmJHRoaXMtPmZvcm1fcHRyLT5tb2R1bGVfcHRyOwoJICAgJG1haW4gPSBhcnJheSgKICAgICAgICAgCWFycmF5KCRtb2QtPkxhbmcoJ3RpdGxlX3VzZV93eXNpd3lnJyksCiAgICAgICAgICAgIAkJJG1vZC0+Q3JlYXRlSW5wdXRDaGVja2JveCgkZm9ybURlc2NyaXB0b3IsICdmYnJwX29wdF93eXNpd3lnJywKICAgICAgICAgICAgCQknMScsJHRoaXMtPkdldE9wdGlvbignd3lzaXd5ZycsJzAnKSkpLAoJCQlhcnJheSgkbW9kLT5MYW5nKCd0aXRsZV90ZXh0YXJlYV9yb3dzJyksCiAgICAgICAgICAgIAkJJG1vZC0+Q3JlYXRlSW5wdXRUZXh0KCRmb3JtRGVzY3JpcHRvciwgJ2ZicnBfb3B0X3Jvd3MnLAogICAgICAgICAgICAJCSR0aGlzLT5HZXRPcHRpb24oJ3Jvd3MnLCcxNScpLDUsNSkpLAoJCQlhcnJheSgkbW9kLT5MYW5nKCd0aXRsZV90ZXh0YXJlYV9jb2xzJyksCiAgICAgICAgICAgIAkJJG1vZC0+Q3JlYXRlSW5wdXRUZXh0KCRmb3JtRGVzY3JpcHRvciwgJ2ZicnBfb3B0X2NvbHMnLAogICAgICAgICAgICAJCSR0aGlzLT5HZXRPcHRpb24oJ2NvbHMnLCc4MCcpLDUsNSkpCiAgICAgICAgICAgICApOwoJICAgJGFkdiA9IGFycmF5KGFycmF5KCRtb2QtPkxhbmcoJ3RpdGxlX2ZpZWxkX2RlZmF1bHRfdmFsdWUnKSwKCQkJCSAgJG1vZC0+Q3JlYXRlVGV4dEFyZWEoZmFsc2UsCgkJCQkJCQkJICAgJGZvcm1EZXNjcmlwdG9yLCAkdGhpcy0+R2V0T3B0aW9uKCdkZWZhdWx0JyksCgkJCQkJCQkJICAgJ2ZicnBfb3B0X2RlZmF1bHQnCgkJCQkgICAgICAgICAgICAgICApKSwKCQkJCQkKCQkJCQkKCQkJCQkKICAgICAgCQkJICBhcnJheSgkbW9kLT5MYW5nKCd0aXRsZV9jbGVhcl9kZWZhdWx0JyksCgkJIAkJIAlhcnJheSgkbW9kLT5DcmVhdGVJbnB1dEhpZGRlbigkZm9ybURlc2NyaXB0b3IsJ2ZicnBfb3B0X2NsZWFyX2RlZmF1bHQnLCcwJykuJG1vZC0+Q3JlYXRlSW5wdXRDaGVja2JveCgkZm9ybURlc2NyaXB0b3IsICdmYnJwX29wdF9jbGVhcl9kZWZhdWx0JywKICAgICAgICAgICAgCQknMScsJHRoaXMtPkdldE9wdGlvbignY2xlYXJfZGVmYXVsdCcsJzAnKSksJG1vZC0+TGFuZygndGl0bGVfY2xlYXJfZGVmYXVsdF9oZWxwJykKCQkJCQkpKSk7CgogICAgICAgICByZXR1cm4gYXJyYXkoJ21haW4nPT4kbWFpbiwnYWR2Jz0+JGFkdik7Cgl9CgkKCWZ1bmN0aW9uIFBvc3RQb3B1bGF0ZUFkbWluRm9ybSgmJG1haW5BcnJheSwgJiRhZHZBcnJheSkKCXsKCQkkbW9kID0gJiR0aGlzLT5mb3JtX3B0ci0+bW9kdWxlX3B0cjsKCQkvLyByZW1vdmUgdGhlICJqYXZhc2NyaXB0IiBmaWVsZAoJCSRoaWRlSW5kZXggPSAtMTsKCQlmb3IgKCRpPTA7JGk8Y291bnQoJGFkdkFycmF5KTskaSsrKQoJCQl7CgkJCWlmICgkYWR2QXJyYXlbJGldLT50aXRsZSA9PSAkbW9kLT5MYW5nKCd0aXRsZV9maWVsZF9qYXZhc2NyaXB0JykpCgkJCQl7CgkJCQkkaGlkZUluZGV4ID0gJGk7CgkJCQl9CgkJCX0KCQlpZiAoJGhpZGVJbmRleCAhPSAtMSkKCQkJewoJCQlhcnJheV9zcGxpY2UoJGFkdkFycmF5LCAkaGlkZUluZGV4LDEpOwoJCQl9CgkJaWYgKGNvdW50KCRhZHZBcnJheSkgPT0gMCkKCQkJewoJCQkkYWR2QXJyYXlbMF0tPnRpdGxlID0gJG1vZC0+TGFuZygndGFiX2FkdmFuY2VkJyk7CgkJCSRhZHZBcnJheVswXS0+aW5wdXQgPSAkbW9kLT5MYW5nKCd0aXRsZV9ub19hZHZhbmNlZF9vcHRpb25zJyk7CgkJCX0KCX0KCgp9Cgo/Pgo=]]></data>
	</file>
	<file>
	  <filename>/classes/TextField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/TextFieldExpandable.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/* 
   FormBuilder. Copyright (c) 2005-2006 Samuel Goldstein <sjg@cmsmodules.com>
   More info at http://dev.cmsmadesimple.org/projects/formbuilder
   
   A Module for CMS Made Simple, Copyright (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
  This project's homepage is: http://www.cmsmadesimple.org
*/

class fbTextFieldExpandable extends fbFieldBase {

	function fbTextFieldExpandable(&$form_ptr, &$params)
	{
        $this->fbFieldBase($form_ptr, $params);
        $mod = &$form_ptr->module_ptr;
		$this->Type = 'TextFieldExpandable';
		$this->DisplayInForm = true;
		$this->HasUserAddOp = true;
		$this->HasUserDeleteOp = true;
		$this->ValidationTypes = array(
            $mod->Lang('validation_none')=>'none',
            $mod->Lang('validation_numeric')=>'numeric',
            $mod->Lang('validation_integer')=>'integer',
            $mod->Lang('validation_email_address')=>'email',
            $mod->Lang('validation_regex_match')=>'regex_match',
            $mod->Lang('validation_regex_nomatch')=>'regex_nomatch'
            );
      $this->hasMultipleFormComponents = true;

	}


	function GetFieldInput($id, &$params, $returnid)
	{
	  $mod = &$this->form_ptr->module_ptr;
	 //debug_display($this->Value);
	  $js = $this->GetOption('javascript','');
	

     if (! is_array($this->Value))
	      {
	      $vals = 1;
	      }
	  else
	      {
	      $vals = count($this->Value);
	      }
      foreach ($params as $pKey=>$pVal)
         {
         if (substr($pKey,0,9) == 'fbrp_FeX_')
            {
            $pts = explode('_',$pKey);
            if ($pts[2] == $this->Id)
               {
               // expand
               $this->Value[$vals]='';
               $vals++;
               }
            }
         else if (substr($pKey,0,9) == 'fbrp_FeD_')
            {
            $pts = explode('_',$pKey);
            if ($pts[2] == $this->Id)
               {
               // delete row
               if (isset($this->Value[$pts[2]]))
                  {
                  array_splice($this->Value, $pts[2], 1);
                  }
               $vals--;
               }
            }
         }

	  $ret = array();
	  for ($i=0;$i<$vals;$i++)
	    {
	    $thisRow = new stdClass();
        $thisRow->name = '';
        $thisRow->title = '';
	    $thisRow->input = $mod->CreateInputText($id, 'fbrp__'.$this->Id.'[]',
				       $this->Value[$i],
            $this->GetOption('length')<25?$this->GetOption('length'):25,
            $this->GetOption('length'),$js);
        $thisRow->op = $mod->CreateInputSubmit($id, 'fbrp_FeD_'.$this->Id.'_'.$i, $this->GetOption('del_button','X'));
        array_push($ret, $thisRow);
        }
      $thisRow = new stdClass();
      $thisRow->name = '';
      $thisRow->title = '';
      $thisRow->input = '';
      $thisRow->op = $mod->CreateInputSubmit($id, 'fbrp_FeX_'.$this->Id, $this->GetOption('add_button','+'));
      array_push($ret, $thisRow);
      return $ret;
	}

	function StatusInfo()
	{
	  $mod = &$this->form_ptr->module_ptr;
	  $ret = $mod->Lang('abbreviation_length',$this->GetOption('length','80'));
		if (strlen($this->ValidationType)>0)
		  {
		  	$ret .= ", ".array_search($this->ValidationType,$this->ValidationTypes);
		  }
		 return $ret;
	}

	function GetHumanReadableValue($as_string = true)
	{
		$form = &$this->form_ptr;
      if (! is_array($this->Value))
	      {
	      $this->Value = array($this->Value);
	      }
	if ($as_string)
		{
		return join($form->GetAttr('list_delimiter',','),$this->Value);
		}
	else
		{
		return array($ret);
		}
	}



	function PrePopulateAdminForm($formDescriptor)
	{
		$mod = &$this->form_ptr->module_ptr;
		$main = array(
			array($mod->Lang('title_maximum_length'),
			      $mod->CreateInputText($formDescriptor, 
						    'fbrp_opt_length',
			         $this->GetOption('length','80'),25,25)),
			array($mod->Lang('title_add_button_text'),
			      $mod->CreateInputText($formDescriptor,
						    'fbrp_opt_add_button',
			         $this->GetOption('add_button','+'),15,25)),
			array($mod->Lang('title_del_button_text'),
			      $mod->CreateInputText($formDescriptor,
						    'fbrp_opt_del_button',
			         $this->GetOption('del_button','X'),15,25))
		);
		$adv = array(
			array($mod->Lang('title_field_regex'),
			      array($mod->CreateInputText($formDescriptor, 
							  'fbrp_opt_regex',
							  $this->GetOption('regex'),25,255),$mod->Lang('title_regex_help')))	
		);
		return array('main'=>$main,'adv'=>$adv);
	}


	function Validate()
	{
		$this->validated = true;
		$this->validationErrorText = '';
		$mod = &$this->form_ptr->module_ptr;
		if (! is_array($this->Value))
		    {
		    $this->Value = array($this->Value);
		    }
		foreach ($this->Value as $thisVal)
		    {
		    switch ($this->ValidationType)
		    {
		  	   case 'none':
		  	       break;
		  	   case 'numeric':
                  if ($thisVal !== false &&
                      ! preg_match("/^([\d\.\,])+$/i", $thisVal))
                      {
                      $this->validated = false;
                      $this->validationErrorText = $mod->Lang('please_enter_a_number',$this->Name);
                      }
		  	       break;
		  	   case 'integer':
                  if ($thisVal !== false &&
                  	! preg_match("/^([\d])+$/i", $thisVal) ||
                      intval($thisVal) != $thisVal)
                    {
                    $this->validated = false;
                    $this->validationErrorText = $mod->Lang('please_enter_an_integer',$this->Name);
                    }
		  	       break;
		  	   case 'email':
                  if ($thisVal !== false &&
                      ! preg_match(($mod->GetPreference('relaxed_email_regex','0')==0?$mod->email_regex:$mod->email_regex_relaxed), $thisVal))
                    {
                    $this->validated = false;
                    $this->validationErrorText = $mod->Lang('please_enter_an_email',$this->Name);
                    }
		  	       break;
		  	   case 'regex_match':
                  if ($thisVal !== false &&
                      ! preg_match($this->GetOption('regex','/.*/'), $thisVal))
                    {
                    $this->validated = false;
                    $this->validationErrorText = $mod->Lang('please_enter_valid',$this->Name);
                    }
		  	   	   break;
		  	   case 'regex_nomatch':
                  if ($thisVal !== false &&
                       preg_match($this->GetOption('regex','/.*/'), $thisVal))
                    {
                    $this->validated = false;
                    $this->validationErrorText = $mod->Lang('please_enter_valid',$this->Name);
                    }
		  	   	   break;
		  }
		if ($this->GetOption('length',0) > 0 && strlen($thisVal) > $this->GetOption('length',0))
			{
			$this->validated = false;
			$this->validationErrorText = $mod->Lang('please_enter_no_longer',$this->GetOption('length',0));
			}
		}
		return array($this->validated, $this->validationErrorText);
	}
}

?>
]]></data>
	</file>
	<file>
	  <filename>/classes/TimePickerField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCgpjbGFzcyBmYlRpbWVQaWNrZXJGaWVsZCBleHRlbmRzIGZiRmllbGRCYXNlIHsKCgl2YXIgJGZsYWcxMmhvdXI7CgkKCWZ1bmN0aW9uIGZiVGltZVBpY2tlckZpZWxkKCYkZm9ybV9wdHIsICYkcGFyYW1zKQoJewogICAgICAgICR0aGlzLT5mYkZpZWxkQmFzZSgkZm9ybV9wdHIsICRwYXJhbXMpOwogICAgICAgICRtb2QgPSAmJGZvcm1fcHRyLT5tb2R1bGVfcHRyOwoJCSR0aGlzLT5UeXBlID0gJ1RpbWVQaWNrZXJGaWVsZCc7CgkJJHRoaXMtPkRpc3BsYXlJbkZvcm0gPSB0cnVlOwoJCSR0aGlzLT5WYWxpZGF0aW9uVHlwZXMgPSBhcnJheSgKICAgICAgICAgICAgJG1vZC0+TGFuZygndmFsaWRhdGlvbl9ub25lJyk9Pidub25lJywKICAgICAgICAgICAgKTsKICAgICAgJHRoaXMtPmZsYWcxMmhvdXIgPSBhcnJheSgKCQkgIAkkbW9kLT5MYW5nKCd0aXRsZV9iZWZvcmVfbm9vbicpPT4kbW9kLT5MYW5nKCd0aXRsZV9iZWZvcmVfbm9vbicpLAogICAgICAgIAkkbW9kLT5MYW5nKCd0aXRsZV9hZnRlcl9ub29uJyk9PiRtb2QtPkxhbmcoJ3RpdGxlX2FmdGVyX25vb24nKSk7CiAgICAkdGhpcy0+aGFzTXVsdGlwbGVGb3JtQ29tcG9uZW50cyA9IHRydWU7CiAgICAkdGhpcy0+bGFiZWxTdWJDb21wb25lbnRzID0gZmFsc2U7Cgl9CgoKICAgIGZ1bmN0aW9uIFN0YXR1c0luZm8oKQoJewogICAgICAkbW9kID0gJiR0aGlzLT5mb3JtX3B0ci0+bW9kdWxlX3B0cjsKCQlyZXR1cm4gKCR0aGlzLT5HZXRPcHRpb24oJzI0X2hvdXInLCcwJykgPT0gJzAnPyRtb2QtPkxhbmcoJzEyX2hvdXInKTokbW9kLT5MYW5nKCcyNF9ob3VyJykpOwoJfQoKCglmdW5jdGlvbiBHZXRGaWVsZElucHV0KCRpZCwgJiRwYXJhbXMsICRyZXR1cm5pZCkKCXsKCQkkbW9kID0gJiR0aGlzLT5mb3JtX3B0ci0+bW9kdWxlX3B0cjsKCQkkanMgPSAkdGhpcy0+R2V0T3B0aW9uKCdqYXZhc2NyaXB0JywnJyk7CgkJCiAgICAgICAkbm93ID0gbG9jYWx0aW1lKHRpbWUoKSx0cnVlKTsKICAgICAgICRNaW5zID0gYXJyYXkoKTsKICAgICAgICRIb3VycyA9IGFycmF5KCk7CiAgICAgICAkcmV0ID0gYXJyYXkoKTsKICAgICAgIGZvciAoJGk9MDskaTw2MDskaSsrKQogICAgICAgCXsKCQkJJG1vID0gc3ByaW50ZigiJTAyZCIsJGkpOwoJCQkkTWluc1skbW9dPSRtbzsKCQkJfQogICAgICAgaWYgKCR0aGlzLT5HZXRPcHRpb24oJzI0X2hvdXInLCcwJykgPT0gJzAnKQogICAgICAgCQl7CiAgICAgICAJCWZvciAoJGk9MTskaTwxMzskaSsrKQogICAgICAgCQl7CgkJCQkJJG1vID0gc3ByaW50ZigiJTAyZCIsJGkpOwoJCQkJCSRIb3Vyc1skbW9dPSRtbzsKCQkJCX0KCQkJaWYgKCR0aGlzLT5IYXNWYWx1ZSgpKQoJCQkJewoJCQkJJG5vd1sndG1faG91ciddID0gJHRoaXMtPkdldEFycmF5VmFsdWUoMCk7CgkJCQkkbm93WydtZXJpZCddID0gJHRoaXMtPkdldEFycmF5VmFsdWUoMik7CgkJCQkkbm93Wyd0bV9taW4nXSA9ICR0aGlzLT5HZXRBcnJheVZhbHVlKDEpOwoJCQkJfQoJCQllbHNlCgkJCQl7CgkJCQkkbm93WydtZXJpZCddID0gJG1vZC0+TGFuZygndGl0bGVfYmVmb3JlX25vb24nKTsKCQkJCWlmICgkbm93Wyd0bV9ob3VyJ10gPiAxMikKCQkJCQl7CgkJCQkJJG5vd1sndG1faG91ciddIC09IDEyOwoJCQkJCSRub3dbJ21lcmlkJ10gPSAkbW9kLT5MYW5nKCd0aXRsZV9hZnRlcl9ub29uJyk7CgkJCQkJfQoJCQkJZWxzZWlmICgkbm93Wyd0bV9ob3VyJ10gPT0gMCkKCQkJCQl7CgkJCQkJJG5vd1sndG1faG91ciddID0gMTI7CgkJCQkJfQoJCQkJfQoKICAgICAgICAgICAgJGhyID0gbmV3IHN0ZENsYXNzKCk7CiAgICAgICAgICAgICRoci0+aW5wdXQgPSAkbW9kLT5DcmVhdGVJbnB1dERyb3Bkb3duKCRpZCwgJ2ZicnBfXycuJHRoaXMtPklkLidbXScsCiAgICAgICAJCQkkSG91cnMsIC0xLCAkbm93Wyd0bV9ob3VyJ10sJ2lkPSInLiRpZC4nXycuJHRoaXMtPklkLidfMSIgJy4kanMpOwogICAgICAgCQkkaHItPnRpdGxlID0gJG1vZC0+TGFuZygnaG91cicpOwogICAgICAgCQkkaHItPm5hbWUgPSAnPGxhYmVsIGZvcj0iJy4kaWQuJ18nLiR0aGlzLT5JZC4nXzEiPicuJG1vZC0+TGFuZygnaG91cicpLic8L2xhYmVsPic7CiAgICAgICAJCWFycmF5X3B1c2goJHJldCwgJGhyKTsKICAgICAgIAkJCiAgICAgICAgICAgICRtaW4gPSBuZXcgc3RkQ2xhc3MoKTsKICAgICAgICAgICAgJG1pbi0+aW5wdXQgPSAkbW9kLT5DcmVhdGVJbnB1dERyb3Bkb3duKCRpZCwgJ2ZicnBfXycuJHRoaXMtPklkLidbXScsCiAgICAgICAJCQkkTWlucywgLTEsICRub3dbJ3RtX21pbiddLCdpZD0iJy4kaWQuJ18nLiR0aGlzLT5JZC4nXzIiICcuJGpzKTsKICAgICAgIAkJJG1pbi0+dGl0bGUgPSAkbW9kLT5MYW5nKCdtaW4nKTsKICAgICAgIAkJJG1pbi0+bmFtZSA9ICc8bGFiZWwgZm9yPSInLiRpZC4nXycuJHRoaXMtPklkLidfMiI+Jy4kbW9kLT5MYW5nKCdtaW4nKS4nPC9sYWJlbD4nOwogICAgICAgCQlhcnJheV9wdXNoKCRyZXQsICRtaW4pOwoKICAgICAgICAgICAgJG1lciA9IG5ldyBzdGRDbGFzcygpOwogICAgICAgICAgICAkbWVyLT5pbnB1dCA9ICRtb2QtPkNyZWF0ZUlucHV0RHJvcGRvd24oJGlkLCAnZmJycF9fJy4kdGhpcy0+SWQuJ1tdJywKICAgICAgIAkJCSR0aGlzLT5mbGFnMTJob3VyLCAtMSwgJG5vd1snbWVyaWQnXSwgJ2lkPSInLiRpZC4nXycuJHRoaXMtPklkLidfMyIgJy4kanMpOwogICAgICAgICAgICAkbWVyLT5uYW1lID0gJzxsYWJlbCBmb3I9IicuJGlkLidfJy4kdGhpcy0+SWQuJ18zIj4nLiRtb2QtPkxhbmcoJ21lcmlkJykuJzwvbGFiZWw+JzsKICAgICAgICAgICAgJG1lci0+dGl0bGUgPSAkbW9kLT5MYW5nKCdtZXJpZCcpOwogICAgICAgICAgICBhcnJheV9wdXNoKCRyZXQsJG1lcik7CiAgICAgICAgICAgIHJldHVybiAkcmV0OwogICAgICAgCQl9CiAgICAgICBlbHNlCiAgICAgICAJCXsKICAgICAgIAkJZm9yICgkaT0wOyRpPDI0OyRpKyspCiAgICAgICAJCXsKCQkJCQkkbW8gPSBzcHJpbnRmKCIlMDJkIiwkaSk7CgkJCQkJJEhvdXJzWyRtb109JG1vOwoJCQkJfQoKCQkJaWYgKCR0aGlzLT5IYXNWYWx1ZSgpKQoJCQkJewoJCQkJJG5vd1sndG1faG91ciddID0gJHRoaXMtPkdldEFycmF5VmFsdWUoMCk7CgkJCQkkbm93Wyd0bV9taW4nXSA9ICR0aGlzLT5HZXRBcnJheVZhbHVlKDEpOwoJCQkJfQogICAgICAgICAgICAkaHIgPSBuZXcgc3RkQ2xhc3MoKTsKICAgICAgICAgICAgJGhyLT5pbnB1dCA9ICRtb2QtPkNyZWF0ZUlucHV0RHJvcGRvd24oJGlkLCAnZmJycF9fJy4kdGhpcy0+SWQuJ1tdJywKICAgICAgIAkJCSRIb3VycywgLTEsICRub3dbJ3RtX2hvdXInXSwnaWQ9IicuJGlkLidfJy4kdGhpcy0+SWQuJ18xIiAnLiRqcyk7CiAgICAgICAJCSRoci0+dGl0bGUgPSAkbW9kLT5MYW5nKCdob3VyJyk7CiAgICAgICAJCSRoci0+bmFtZSA9ICc8bGFiZWwgZm9yPSInLiRpZC4nXycuJHRoaXMtPklkLidfMSI+Jy4kbW9kLT5MYW5nKCdob3VyJykuJzwvbGFiZWw+JzsKICAgICAgIAkJYXJyYXlfcHVzaCgkcmV0LCAkaHIpOwogICAgICAgCQkKICAgICAgICAgICAgJG1pbiA9IG5ldyBzdGRDbGFzcygpOwogICAgICAgICAgICAkbWluLT5pbnB1dCA9ICRtb2QtPkNyZWF0ZUlucHV0RHJvcGRvd24oJGlkLCAnZmJycF9fJy4kdGhpcy0+SWQuJ1tdJywKICAgICAgIAkJCSRNaW5zLCAtMSwgJG5vd1sndG1fbWluJ10sJ2lkPSInLiRpZC4nXycuJHRoaXMtPklkLidfMiIgJy4kanMpOwogICAgICAgCQkkbWluLT50aXRsZSA9ICRtb2QtPkxhbmcoJ21pbicpOwogICAgICAgCQkkbWluLT5uYW1lID0gJzxsYWJlbCBmb3I9IicuJGlkLidfJy4kdGhpcy0+SWQuJ18yIj4nLiRtb2QtPkxhbmcoJ21pbicpLic8L2xhYmVsPic7CiAgICAgICAJCWFycmF5X3B1c2goJHJldCwgJG1pbik7CgogICAgICAgICAgICByZXR1cm4gJHJldDsKICAgICAgIAkJfQoKCgl9CgogICBmdW5jdGlvbiBDb21wYXJlVG8oJHZhbCkKICAgewogICAgICAkdHQgPSAwOwogICAgICAkb3QgPSAwOwogICAgICBpZiAoJHRoaXMtPkhhc1ZhbHVlKCkpCgkJCXsKCQkJJHR0ID0gJHRoaXMtPkdldEFycmF5VmFsdWUoMCkgKiA2MCArICR0aGlzLT5HZXRBcnJheVZhbHVlKDEpOwoJCQl9CgkJJG8gPSAkdmFsLT5HZXRWYWx1ZSgpOwogICAgICBpZiAoJG8tPkhhc1ZhbHVlKCkpCgkJCXsKCQkJJG90ID0gJG8tPkdldEFycmF5VmFsdWUoMCkgKiA2MCArICRvLT5HZXRBcnJheVZhbHVlKDEpOwoJCQl9CiAgICAgIGlmICgkdHQgPT0gJG90KQogICAgICAgICB7CiAgICAgICAgIHJldHVybiAwOwogICAgICAgICB9CiAgICAgIHJldHVybiAoJHR0IDwgJG90KSA/IC0xIDogMTsKICAgfQoKCWZ1bmN0aW9uIEdldEh1bWFuUmVhZGFibGVWYWx1ZSgkYXNfc3RyaW5nPXRydWUpCgl7CgkJJG1vZCA9ICYkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CgkJaWYgKCR0aGlzLT5IYXNWYWx1ZSgpKQoJCQl7CgkJCWlmICgkdGhpcy0+R2V0T3B0aW9uKCcyNF9ob3VyJywnMCcpID09ICcwJykKCQkJCXsKCQkJCSRyZXQgPSAkdGhpcy0+R2V0QXJyYXlWYWx1ZSgwKS4nOicuCgkJCQkJJHRoaXMtPkdldEFycmF5VmFsdWUoMSkuJyAnLgoJCQkJCSR0aGlzLT5HZXRBcnJheVZhbHVlKDIpOwoJCQkJfQoJCQllbHNlCgkJCQl7CgkJCQkkcmV0ID0gJHRoaXMtPkdldEFycmF5VmFsdWUoMCkuJzonLgoJCQkJCSR0aGlzLT5HZXRBcnJheVZhbHVlKDEpOwoJCQkJfQoJCQl9CgkJZWxzZQoJCQl7CgkJCSRyZXQgPSAkbW9kLT5MYW5nKCd1bnNwZWNpZmllZCcpOwoJCQl9CgkJaWYgKCRhc19zdHJpbmcpCgkJCXsKCQkJcmV0dXJuICRyZXQ7CgkJCX0KCQllbHNlCgkJCXsKCQkJcmV0dXJuIGFycmF5KCRyZXQpOwoJCQl9Cgl9CgoJZnVuY3Rpb24gUHJlUG9wdWxhdGVBZG1pbkZvcm0oJGZvcm1EZXNjcmlwdG9yKQoJewoJCSRtb2QgPSAmJHRoaXMtPmZvcm1fcHRyLT5tb2R1bGVfcHRyOwoJCSRtYWluID0gYXJyYXkoCgkJCWFycmF5KCRtb2QtPkxhbmcoJ3RpdGxlXzI0X2hvdXInKSwKICAgICAgICAgICAgCQkkbW9kLT5DcmVhdGVJbnB1dENoZWNrYm94KCRmb3JtRGVzY3JpcHRvciwgJ2ZicnBfb3B0XzI0X2hvdXInLAogICAgICAgICAgICAJCScxJywkdGhpcy0+R2V0T3B0aW9uKCcyNF9ob3VyJywnMCcpKSkpOwoJCXJldHVybiBhcnJheSgnbWFpbic9PiRtYWluLGFycmF5KCkpOwoJfQoKfQoKPz4K]]></data>
	</file>
	<file>
	  <filename>/classes/UniqueIntegerField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/FormBuilder.module.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: FormBuilder
# Version: 0.6, released 2008
#
# Copyright (c) 2007, Samuel Goldstein <sjg@cmsmodules.com>
# For Information, Support, Bug Reports, etc, please visit the
# CMS Made Simple Forge:
# http://dev.cmsmadesimple.org/projects/formbuilder/
#
#-------------------------------------------------------------------------
# CMS - CMS Made Simple is (c) 2006 by Ted Kulp (wishy@cmsmadesimple.org)
# This project's homepage is: http://www.cmsmadesimple.org
#-------------------------------------------------------------------------
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
# Or read it online: http://www.gnu.org/licenses/licenses.html#GPL
#
#-------------------------------------------------------------------------
class FormBuilder extends CMSModule
{

	var $field_types;
	var $disp_field_types;
	var $std_field_types;
	var $all_validation_types;
	var $module_ptr;
	var $module_id;
	var $email_regex;
	var $email_regex_relaxed;
	var $dbHandle;

	function FormBuilder()
	{
		global $gCms;
		$this->CMSModule();
//error_log("Module Load: ".memory_get_usage());
		
		$this->module_ptr = &$this;
		$this->dbHandle = &$gCms->GetDb();
		$this->module_id = '';
		$this->email_regex = "/^([\w\d\.\-\_])+\@([\w\d\.\-\_]+)\.(\w+)$/i";
		$this->email_regex_relaxed="/^([\w\d\.\-\_])+\@([\w\d\.\-\_])+$/i";
		require_once dirname(__FILE__).'/classes/Form.class.php';
		require_once dirname(__FILE__).'/classes/FieldBase.class.php';
		//$this->RegisterModulePlugin();
//error_log("leaving module instantiation with: ".memory_get_usage());
		
	}


	function initialize()
	{
//error_log("entering initialize with ".memory_get_usage());
		$dir=opendir(dirname(__FILE__).'/classes');
   		$this->field_types = array();
   		while($filespec=readdir($dir))
   			{
       		if(strpos($filespec,'Field') === false && strpos($filespec,'Disposition') === false)
       			{
       			continue;
       			}
       		$shortname = substr($filespec,0,strpos($filespec,'.'));
       		if (substr($shortname,-4) == 'Base')
       			{
       			continue;
       			}
       		$this->field_types[$this->Lang('field_type_'.$shortname)] = $shortname;
			}        
		
        foreach ($this->field_types as $tName=>$tType)
        	{
        	if (substr($tType,0,11) == 'Disposition')
        		{
        		$this->disp_field_types[$tName]=$tType;
        		}
        	}
		$this->all_validation_types = array();
		ksort($this->field_types);
		$this->std_field_types = array(
			$this->Lang('field_type_TextField')=>'TextField',
			$this->Lang('field_type_TextAreaField')=>'TextAreaField',
			$this->Lang('field_type_CheckboxField')=>'CheckboxField',
			$this->Lang('field_type_CheckboxGroupField')=>'CheckboxGroupField',
			$this->Lang('field_type_PulldownField')=>'PulldownField',
			$this->Lang('field_type_RadioGroupField')=>'RadioGroupField',
			$this->Lang('field_type_DispositionEmail')=>'DispositionEmail',
			$this->Lang('field_type_DispositionFile')=>'DispositionFile',
			$this->Lang('field_type_PageBreakField')=>'PageBreakField',
			$this->Lang('field_type_StaticTextField')=>'StaticTextField');
		ksort($this->std_field_types);		
		
		
//error_log("leaving initialize with ".memory_get_usage());

	}

	function AllowAutoInstall()
	{
	  return FALSE;
	}

	function AllowAutoUpgrade()
	{
	  return FALSE;
	}

	function GetName()
	{
		return 'FormBuilder';
	}
	
	function GetFriendlyName()
	{
		return $this->Lang('friendlyname');
	}

	function GetVersion()
	{
		return '0.5.5';
	}

	function GetAuthor()
	{
		return 'SjG';
	}

	function GetAuthorEmail()
	{
		return 'sjg@cmsmodules.com';
	}

    function GetAdminDescription()
    {
		return $this->Lang('admindesc');
    }

	function GetChangeLog()
	{
		return $this->Lang('changelog');
	}

	function IsPluginModule()
	{
		return true;
	}

	function HasAdmin()
	{
		return true;
	}

	function VisibleToAdminUser()
	{
		return $this->CheckPermission('Modify Forms');
	}

    function AdminStyle()
    {
      return "\n.module_fb_table {font-size: 10px;}\n.module_fb_area_wide {width: 500px;}\n.module_fb_legend{font-size: 9px; margin: 6px; border: 1px solid black;}.module_fb_area_short {width: 500px; height: 100px;}\n.module_fb_link {text-decoration: underline;}\n.module_fb_fieldset {margin-bottom:2em;}\n.odd {background-color: #fff;text-align:left;vertical-alignment: top;}\n.even {background-color: #ddd;text-align:left;vertical-alignment: top;}\n";
    }

	function SetParameters()
	{
    	$this->RestrictUnknownParams();
    	$this->CreateParameter('fbrp_*','null',$this->Lang('formbuilder_params_general'));
		$this->SetParameterType(CLEAN_REGEXP.'/fbrp_.*/',CLEAN_STRING);
		$this->CreateParameter('form_id','null',$this->Lang('formbuilder_params_form_id'));
    	$this->SetParameterType('form_id',CLEAN_INT);
		$this->CreateParameter('form','null',$this->Lang('formbuilder_params_form_name'));
    	$this->SetParameterType('form',CLEAN_STRING);
    	
		$this->CreateParameter('field_id','null',$this->Lang('formbuilder_params_field_id'));
    	$this->SetParameterType('field_id',CLEAN_INT);

		$this->CreateParameter('value_*','null',$this->Lang('formbuilder_params_passed_from_tag'));
		$this->SetParameterType(CLEAN_REGEXP.'/value_.*/',CLEAN_STRING);

		$this->CreateParameter('response_id','null',$this->Lang('formbuilder_params_response_id'));
    	$this->SetParameterType('response_id',CLEAN_INT);
  	}

    function DoAction($name,$id,$params,$returnid='')
    {
      $this->module_id = $id;
      parent::DoAction($name,$id,$params,$returnid);
    }

	function GetDependencies()
	{
		return array('CMSMailer'=>'1.73');
	}

	// may be too stringent, but better safe than sorry.
	function MinimumCMSVersion()
	{
		return '1.1';
	}

	function InstallPostMessage()
	{
		return $this->Lang('post_install');
	}


	function CheckAccess($permission='Modify Forms')
	{
		$access = $this->CheckPermission($permission);
		if (!$access)  {
			echo "<p class=\"error\">".$this->Lang('you_need_permission',$permission)."</p>";
			return false;
		}
		else return true;
	}

	/*
	DO NOT allow parameters to be used for passing the order_by! It is not escaped before
	database access. If we let ADODB quote it, the SQL is not valid (not that MySQL cares,
	but Postgres does).
	*/
	function GetForms($order_by='name')
	{
        global $gCms;
		$db =& $gCms->GetDb();
		$sql = "SELECT * FROM ".cms_db_prefix().'module_fb_form ORDER BY '.$order_by;
	    $result = array();
	    $rs = $db->Execute($sql);
	    if($rs && $rs->RecordCount() > 0)
	    	{
	        $result = $rs->GetArray();
	    	}
	    return $result;
	}	

    function GetFormIDFromAlias($form_alias)
	{
        global $gCms;
		$db =& $gCms->GetDb();
		$sql = 'SELECT form_id from '.cms_db_prefix().'module_fb_form WHERE alias = ?';
		$rs = $db->Execute($sql, array($form_alias));
		if($rs && $rs->RecordCount() > 0)
		{
			$result = $rs->FetchRow();
		}
		return $result['form_id'];
	}

	function GetFormNameFromID($form_id)
	{
        global $gCms;
		$db =& $gCms->GetDb();
		$sql = 'SELECT name from '.cms_db_prefix().'module_fb_form WHERE form_id = ?';
		$rs = $db->Execute($sql, array($form_id));
		if($rs && $rs->RecordCount() > 0)
		{
			$result = $rs->FetchRow();
		}
		return $result['name'];
	}

	function GetFormByID($form_id, $loadDeep=false)
	{
			$params = array('form_id'=>$form_id);
		    $form = new fbForm($this, $params, $loadDeep);
		    return $form;
	}

	function GetFormByParams(&$params, $loadDeep=false)
	{
		    $form = new fbForm($this, $params, $loadDeep);
		    return $form;
	}

	
	function GetHelp($lang = 'en_US')
	{
		return $this->Lang('help');
	}


	function GetResponse($form_id,$response_id,$field_list=array(), $dateFmt='d F y')
	{
		$names = array();
		$values = array();
		global $gCms;
		$db =& $gCms->GetDb();

       	$dbresult = $db->Execute('SELECT * FROM '.cms_db_prefix().
        			'module_fb_resp WHERE resp_id=?', array($response_id));

		$oneset = new stdClass();
		if ($dbresult && $row = $dbresult->FetchRow())
			{			
			$oneset->id = $row['resp_id'];
			$oneset->user_approved = (empty($row['user_approved'])?'':date($dateFmt,$db->UnixTimeStamp($row['user_approved']))); 
 			$oneset->admin_approved = (empty($row['admin_approved'])?'':date($dateFmt,$db->UnixTimeStamp($row['admin_approved'])));
			$oneset->submitted = date($dateFmt,$db->UnixTimeStamp($row['submitted']));
			$oneset->fields = array();
			$oneset->names = array();
		    }

		$paramSet = array('form_id'=>$form_id, 'response_id'=>$response_id);
		$fm = $this->GetFormByParams($paramSet, true);
		$fields = &$fm->GetFields();
		for($j=0;$j<count($fields);$j++)
			{
			if ($fields[$j]->DisplayInSubmission())
				{
				if (isset($field_list[$fields[$j]->GetId()])
					&& $field_list[$fields[$j]->GetId()] > -1)
					{
						$oneset->names[$field_list[$fields[$j]->GetId()]] = $fields[$j]->GetName();
                	$oneset->values[$field_list[$fields[$j]->GetId()]] = $fields[$j]->GetHumanReadableValue();
               }
            }
        	}
        	
		return $oneset;
	}
// Start ALBY
function GetResponses($form_id, $start_point, $number, $admin_approved=false, $user_approved=false, $field_list=array(), $dateFmt='d F y', &$params)
// End ALBY
	{
		global $gCms;
		$db =& $gCms->GetDb();
		$names = array();
		$values = array();
		$sql = 'FROM '.cms_db_prefix().
        			'module_fb_resp WHERE form_id=?';
        if ($user_approved)
        	{
        	 $sql .= ' and user_approved is not null';
        	 }
        if ($admin_approved)
        	{
        	$sql .= ' and admin_approved is not null';
        	}
// Start ALBY
if( (! empty($params['fbrp_response_search'])) && (is_array($params['fbrp_response_search'])) )
 $sql .= ' AND resp_id IN ('. implode(',', $params['fbrp_response_search']) .')';
// End ALBY
        $sql .= ' order by submitted';
        $dbcount = $db->Execute('SELECT COUNT(*) as num '.$sql,array($form_id));
   
        $records = 0;
        if ($dbcount && $row = $dbcount->FetchRow())
        	{   
        	$records = $row['num'];
        	}
       	$dbresult = $db->SelectLimit('SELECT * '.$sql, $number, $start_point, array($form_id));

		while ($dbresult && $row = $dbresult->FetchRow())
			{
			$oneset = new stdClass();
			$oneset->id = $row['resp_id'];
			$oneset->user_approved = (empty($row['user_approved'])?'':date($dateFmt,$db->UnixTimeStamp($row['user_approved']))); 
 			$oneset->admin_approved = (empty($row['admin_approved'])?'':date($dateFmt,$db->UnixTimeStamp($row['admin_approved']))); 
			$oneset->submitted = date($dateFmt,$db->UnixTimeStamp($row['submitted']));
			$oneset->fields = array();
		    array_push($values,$oneset);
		    }
		$populate_names = true;
		$fm = -1;
		$all_fields = false;
		if (count($field_list) == 0)
			{
			$all_fields = true;
			}
		for($i=0;$i<count($values);$i++)
			{
			$paramSet = array('form_id'=>$form_id, 'response_id'=>$values[$i]->id);
			if (gettype($fm) == "integer") // fix this, for better efficiency!
				{
				$fm = $this->GetFormByParams($paramSet, true);
				}
			else
				{
				$fm->LoadResponse($values[$i]->id);
				}
			$fields = &$fm->GetFields();
			$ind = 0;
			for($j=0;$j<count($fields);$j++)
				{
				if ($fields[$j]->DisplayInSubmission())
					{
					if (isset($field_list[$fields[$j]->GetId()])
						&& $field_list[$fields[$j]->GetId()] > -1)
						{
						if ($populate_names)
							{
							$names[$field_list[$fields[$j]->GetId()]] = $fields[$j]->GetName();
							}
                		$values[$i]->fields[$field_list[$fields[$j]->GetId()]] = $fields[$j]->GetHumanReadableValue();
                		}
					else if ($all_fields)
						{
						if ($populate_names)
							{
							$names[$ind] = $fields[$j]->GetName();
							}
						$values[$i]->fields[$ind] = $fields[$j]->GetHumanReadableValue();
						$ind++;
						}
                	}
        		}
        	$populate_names = false;
			}
		return array($records, $names, $values);
	}


	function GetSortedResponses($form_id, $start_point, $number, $admin_approved=false, $user_approved=false, $field_list=array(), $dateFmt='d F y', &$params)
	{
		global $gCms;
		$db =& $gCms->GetDb();
		$names = array();
		$values = array();
		$sql = 'FROM '.cms_db_prefix().
        			'module_fb_resp WHERE form_id=?';
        if ($user_approved)
        	{
        	 $sql .= ' and user_approved is not null';
        	 }
        if ($admin_approved)
        	{
        	$sql .= ' and admin_approved is not null';
        	}
// Start ALBY
if( (! empty($params['fbrp_response_search'])) && (is_array($params['fbrp_response_search'])) )
 $sql .= ' AND resp_id IN ('. implode(',', $params['fbrp_response_search']) .')';
// End ALBY
        
		if (! isset($params['fbrp_sort_field']) || $params['fbrp_sort_field']=='submitdate')
			{
			if (isset($params['fbrp_sort_dir']) && $params['fbrp_sort_dir'] == 'd')
				{
				$sql .= ' order by submitted desc';	
				}
			else
				{
				$sql .= ' order by submitted asc';
				}
			}
        $dbcount = $db->Execute('SELECT COUNT(*) as num '.$sql,array($form_id));
   
        $records = 0;
        if ($dbcount && $row = $dbcount->FetchRow())
        	{   
        	$records = $row['num'];
        	}
       	$dbresult = $db->Execute('SELECT * '.$sql, array($form_id));

		while ($dbresult && $row = $dbresult->FetchRow())
			{
			$oneset = new stdClass();
			$oneset->id = $row['resp_id'];
			$oneset->user_approved = (empty($row['user_approved'])?'':date($dateFmt,$db->UnixTimeStamp($row['user_approved']))); 
 			$oneset->admin_approved = (empty($row['admin_approved'])?'':date($dateFmt,$db->UnixTimeStamp($row['admin_approved']))); 
			$oneset->submitted = date($dateFmt,$db->UnixTimeStamp($row['submitted']));
			$oneset->fields = array();
		    array_push($values,$oneset);
		    }
		$populate_names = true;
		$fm = -1;
		for($i=0;$i<count($values);$i++)
			{
			$paramSet = array('form_id'=>$form_id, 'response_id'=>$values[$i]->id);
			if (gettype($fm) == "integer") // fix this, for better efficiency!
				{
				$fm = $this->GetFormByParams($paramSet, true);
				}
			else
				{
				$fm->LoadResponse($values[$i]->id);
				}
			$fields = &$fm->GetFields();
			for($j=0;$j<count($fields);$j++)
				{
				if ($fields[$j]->DisplayInSubmission())
					{
					if (isset($field_list[$fields[$j]->GetId()])
						&& $field_list[$fields[$j]->GetId()] > -1)
						{
						if ($populate_names)
							{
							$names[$field_list[$fields[$j]->GetId()]] = $fields[$j]->GetName();
							}
                		$values[$i]->fields[$field_list[$fields[$j]->GetId()]] = $fields[$j]->GetHumanReadableValue();
                		}
                	}
        		}
        	$populate_names = false;
			}
			
		if (isset($params['fbrp_sort_field']) || isset($params['fbrp_sort_field_id']))
			{
			$sf = -1;
			if (isset($params['fbrp_sort_field_id']))
				{
				$sf = $field_list[$params['fbrp_sort_field_id']];
				}
			else
				{
				for($j=0;$j<count($fields);$j++)
					{
					if (!strcasecmp($fields[$j]->GetName(),$params['fbrp_sort_field']))
						{
						$sf = $field_list[$fields[$j]->GetId()];
						}
					}
				}
			if ($sf != -1)
				{
				// kludge, because sort instantiation breaks under PHP 4, and I can't pass extra params to the sort
				for($j=0;$j<count($values);$j++)
					{
					$values[$j]->sf = $sf;
					}
				if (isset($params['fbrp_sort_dir']) && $params['fbrp_sort_dir'] == 'a')
					{
					usort($values, array("FormBuilder","field_sorter_asc"));
					}
				else
					{
					usort($values, array("FormBuilder","field_sorter_desc"));
					}
				}
			}
		if ($records > $number)
			{
			$values = array_slice( $values, $start_point, $number);
			}
		return array($records, $names, $values);
	}


	function field_sorter_asc($a, $b)
	{
    	return strcasecmp($a->fields[$a->sf], $b->fields[$b->sf]);
	}

	function field_sorter_desc($a, $b)
	{
    	return strcasecmp($b->fields[$b->sf], $a->fields[$a->sf]);
	}

	
	// For a given form, returns an array of response objects
	function ListResponses($form_id, $sort_order='submitted')
	{
		global $gCms;
		$db =& $gCms->GetDb();
		$ret = array();
		$sql = 'SELECT * FROM '.cms_db_prefix().
        			'module_fb_resp WHERE form_id=? ORDER BY ?';
       	$dbresult = $db->Execute($query, array($form_id,$sort_order));
		while ($dbresult && $row = $dbresult->FetchRow())
			{
			$oneset = new stdClass();
			$oneset->id = $result['resp_id'];
			$oneset->user_approved = $db->UnixTimeStamp($result['user_approved']); 
 			$oneset->admin_approved = $db->UnixTimeStamp($result['admin_approved']); 
			$oneset->submitted = $db->UnixTimeStamp($result['submitted']); 
		    array_push($ret,$oneset);
		    }
		return $ret;
	}

    function def(&$var)
    {
    	if (!isset($var))
    	   {
    	   	return false;
    	   }
    	else if (is_null($var))
    	   {
    	   	return false;
    	   }
    	else if (!is_array($var) && empty($var))
    	   {
    	   	return false;
    	   }
    	else if (is_array($var) && count($var) == 0)
    	   {
    	   	return false;
    	   }
    	return true;
    }

    function ClearFileLock()
    {
		global $gCms;
		$db =& $gCms->GetDb();
		$sql = "DELETE from ".cms_db_prefix().'module_fb_flock';
		$rs = $db->Execute($sql);
    }


    function GetFileLock()
    {
		global $gCms;
		$db =& $gCms->GetDb();
		$sql = "insert into ".cms_db_prefix()."module_fb_flock (flock_id, flock) values (1,".$db->sysTimeStamp.")";
		$rs = $db->Execute($sql);
        if ($rs)
        	{
        	return true;
        	}
        $sql = "SELECT flock_id FROM ".cms_db_prefix().
        	"module_fb_flock where flock + interval 15 second < ".$db->sysTimeStamp;
		$rs = $db->Execute($sql);
        if ($rs && $rs->RecordCount() > 0)
        	{
        	$this->ClearFileLock();
        	return false;
        	}        	 
		return false;
    }

    function ReturnFileLock()
    {
		$this->ClearFileLock();
    }

  function GetEventDescription ( $eventname )
  {
    return $this->Lang('event_info_'.$eventname );
  }

  function GetEventHelp ( $eventname )
  {
    return $this->Lang('event_help_'.$eventname );
  }


  function CreatePageDropdown($id,$name,$current='',
			      $addtext='',$markdefault =true)
  {
    // we get here (hopefully) when the template is changed
    // in the dropdown.
    $db =& $this->GetDb();
    global $gCms;
    $defaultid = '';
    if( $markdefault )
      {
	$contentops =& $gCms->GetContentOperations();
	$defaultid = $contentops->GetDefaultPageID();
      }
    
    // get a list of the pages used by this template
    $mypages = array();
    $parms = array('content');
    $q = "SELECT content_id,content_name 
                FROM ".cms_db_prefix()."content
               WHERE type = ?
                 AND active = 1";
    $dbresult = $db->Execute( $q, $parms );
    while( $row = $dbresult->FetchRow() )
      {
	if( $defaultid != '' && $row['content_id'] == $defaultid )
	  {
	    // use a star instead of a word here so I don't have to
	    // worry about translation stuff
	    $mypages[$row['content_name'].' (*)'] = $row['content_id'];
	  }
	else
	  {
	    $mypages[$row['content_name']] = $row['content_id'];
	  }
      }

    return $this->CreateInputDropdown($id,'fbrp_'.$name,$mypages,-1,$current,$addtext);
  }

	function SuppressAdminOutput(&$request)
   {
      if (strpos($_SERVER['QUERY_STRING'],'exportxml') !== false)
         {
         return true;
         }
      elseif (strpos($_SERVER['QUERY_STRING'],'admin_get_template') !== false)
         {
         return true;
         }
      return false;
   }


} // End of Class

# vim:ts=4 sw=4 noet
?>
]]></data>
	</file>
	<file>
	  <filename>/images/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/images/icon.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[R0lGODlhIAAgAPflAP///4+IiP7+/vv7+/z8/P39/cjHx/X19fT09PLy8vr6+vn5+efm5uTj4+jn55CJidHQ0O3s7NnZ2ZWPj+Xl5d3d3dvb2/j4+NPS0vDw8PHx8e7u7vf39+vq6tra2uLi4uzs7NHR0dHOzszLy+Hf39bW1uLh4fX09M/Pz8vKyr25ucfExObl5djX18rJyfn4+Nzb2+/u7u/v7/b29sXExMC8vNLPz7y4uElJScC/v+fn5+no6NnY2NDPz2dnZ93c3JeQkOzr68vLy+Pi4pSOjvPz876+vvz7+5+ZmfDv73Z2dr29vevr6+Hh4bu6usTExH19fdfV1Z2Xl9LS0qqkpJeRkaulpeDe3o2Njbu3t46OjsPDw9TU1N7d3dXU1K6pqXV1dbeyss7Ly1tbW7q5ufHw8PPy8ri4uJWVlaKcnPj39/Lx8cLBwX9/f8HAwLq2ttPR0ff29tXT0/v6+iUlJerq6rm1tZycnKmpqdPQ0JiRkcfDw8TAwKScnD09PaehodfU1Le3t+3t7aCamtDQ0Ly8vKGcnLWxscnJyVpaWrOyst/f36OdnbKysp2dnW5uboqKip6YmCkpKcrHx9fX14GBgbOurmJiYlZWVt3b2+rp6Z+amtzc3CAgINjW1t7c3JqUlJaPj/b19cXFxd7f387OztHPz5GRkXl5eaijo769vZSNjaioqOrr67q1tb66utrZ2ebm5pmSkpmZmczMzKqqqpGKiubk5NTT09TR0baxsejo6Ojp6crKylBQUOTk5JaQkNfW1pWOjt/e3qWfn5+fn7m0tJiSks7MzG5lZZOMjOPj47+/vzY2NoODg+Hg4KKiov79/cbFxcTCwr28vLu5ud7e3sLCwunp6bW1tevs7MfGxtDNzZ6enmBgYOLj4+Dg4NjY2K2oqNXS0rezs////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAOUALAAAAAAgACAAAAj/AMsJHEiwoMGDBAEoVDiQIcKHCRdKnEgRQMKDFTNqpChwo0eNHT8qHJDBAQsGdZKcWDBDw4YNAkiIMTMxQ4VFIC4o4LCwFTUnKQyM2vKEDBk2IQwg0EUkU7mFBEqg8aGE1RJo3ipR0BYCAQATLCxI6METgBtN5AJEeaqQwIdAUJr5mYWlE44pCUagIOWhixBVigyUALeEhYoAntgCELCgCLYKFRAIuhaCg1tkhCjBIPGNQYNhP5os2BMAkOKFAjYKKHCkwEIFCRx0GBdAxOmNBTZYsFABFq4RNHLkkLbtSYMAK26PTHAgg5BeFwrw2MLpl4MNBwaMZOIkRgA7pwl4/+gGBkshR74uIQLww8sJMx2GWPACoQcELi1mBKByusAUZzhAgQckqNzhAQAN0OCCKRgEA4MJDICQhAYDLAAEEiEppIEEtCwjgw4yZAfAHDEEkcAC0Sw2wAEfWrOGIXpkqJBrGRGQAAMwYDCCAS5A0MUzKThghTAybnRACtW4EA4FGiiw2AUUcMGEJUQUudgBTRjRSDFgnJFBCzsckQAFPJRigAEotMDLCa5MICMIp/igxRh0YPLIGMzMgIEBGEAAhwQNFEGAGhEAcEENwMj4QSKSaNGGErWgUAICBMQigQkRILAAARGE0QcoAyiwQhUyImBENrskoB1u0ySzSRYKrZsQSpEKOCkSAAgIIMoQufARySpW3qrQC3lQEcCxxzYkbAExyBEGMVUc+8AxVrwxibIfDRCEGF9MgGwAE2TRgEEelWHDFw8gawsSxkSxQxwIUSTAAbfYoMIfQKQbgDJp1HDFCxDdVgY34uh7rBQ3XCFAwBFFoAIj3gbwgCyp3CACAxwszLCyn3wrxSskaLwxQg4McogIHQA8skEBAQA7]]></data>
	</file>
	<file>
	  <filename>/includes/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/includes/Contact_Form.xml</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?xml version="1.0" encoding="utf-8"?>
<form id="1"
	alias="contact">
	<form_name><![CDATA[Contact Us]]></form_name>
		<attribute key="css_class"><![CDATA[contactform]]></attribute>
		<attribute key="captcha_wrong"><![CDATA[Captcha was not correct.]]></attribute>
		<attribute key="form_template"><![CDATA[{* DEFAULT FORM LAYOUT / pure CSS *}
{$fb_form_header}
{if $fb_form_done == 1}
	{* This first section is for displaying submission errors *}
	{if $fb_submission_error}
		<div class="error_message">{$fb_submission_error}</div>
		{if $fb_show_submission_errors}
			<div class="error">
			<ul>
			{foreach from=$fb_submission_error_list item=thisErr}
				<li>{$thisErr}</li>
			{/foreach}
			</ul>
		</div>
		{/if}
	{/if}
{else}
	{* this section is for displaying the form *}
	{* we start with validation errors *}
	{if $fb_form_has_validation_errors}
		<div class="error_message">
		<ul>
		{foreach from=$fb_form_validation_errors item=thisErr}
			<li>{$thisErr}</li>
		{/foreach}
		</ul>
		</div>
	{/if}
	{if $captcha_error}
		<div class="error_message">{$captcha_error}</div>
	{/if}

	{* and now the form itself *}
	{$fb_form_start}
	<div>{$fb_hidden}</div>
	<div{if $css_class != ''} class="{$css_class}"{/if}>
	{if $total_pages gt 1}<span>{$title_page_x_of_y}</span>{/if}
	{foreach from=$fields item=entry}
		{if $entry->display == 1}
        	{strip}
         	{if $entry->needs_div == 1}
            	<div
            	{if $entry->required == 1 || $entry->css_class != ''} class="
              		{if $entry->required == 1}
                		required
              		{/if}
              		{if $entry->required == 1 && $entry->css_class != ''} {/if}
              		{if $entry->css_class != ''}
                		{$entry->css_class}
              		{/if}
              		"
            	{/if}
            	>
         	{/if}
         	{if $entry->hide_name == 0}
            	<label{if $entry->multiple_parts != 1} for="{$entry->input_id}"{/if}>{$entry->name}
            	{if $entry->required_symbol != ''}
               		{$entry->required_symbol}
            	{/if}
            	</label>
         	{/if}
         	{if $entry->multiple_parts == 1}
            	{section name=numloop loop=$entry->input}
               		{if $entry->label_parts == 1}
               			<div>{$entry->input[numloop]->input}&nbsp;{$entry->input[numloop]->name}</div>
               		{else}
               			{$entry->input[numloop]->input}
               		{/if}
               		{if $entry->input[numloop]->op}{$entry->input[numloop]->op}{/if}
            	{/section}
         	{else}
            	{if $entry->smarty_eval == '1'}{eval var=$entry->input}{else}{$entry->input}{/if}
         	{/if}
         	{if $entry->valid == 0} &lt;--- {$entry->error}{/if}
         	{if $entry->needs_div == 1}
            	</div>
         	{/if}
         	{/strip}
     	{/if}
	{/foreach}
	{if $has_captcha == 1}
		<div class="captcha">{$graphic_captcha}{$title_captcha}<br />{$input_captcha}</div>
	{/if}
	<div class="submit">{$prev}{$submit}</div>
	</div>
	{$fb_form_end}
{/if}
{$fb_form_footer}]]></attribute>
		<attribute key="use_captcha"><![CDATA[0]]></attribute>
		<attribute key="submit_action"><![CDATA[text]]></attribute>
		<attribute key="title_user_captcha"><![CDATA[Please confirm that you are not a script by entering the letters from the image.]]></attribute>
		<attribute key="next_button_text"><![CDATA[Continue...]]></attribute>
		<attribute key="prev_button_text"><![CDATA[Back...]]></attribute>
		<attribute key="required_field_symbol"><![CDATA[*]]></attribute>
		<attribute key="unspecified"><![CDATA[[unspecified]]]></attribute>
		<attribute key="submit_button_text"><![CDATA[Submit Form]]></attribute>
		<attribute key="input_button_safety"><![CDATA[0]]></attribute>
		<attribute key="redirect_page"><![CDATA[-1]]></attribute>
		<attribute key="submit_response"><![CDATA[<p>Thank you, <strong>{$your_name}</strong>.</p>
<p>Your submission has been successful. You may wish to print this page as a reference.</p>
<h3>Contact Details</h3>
<p>
<strong>Name</strong>: {$your_name}<br />
<strong>Email</strong>: <a href="mailto:{$your_email_address}">{$your_email_address}</a><br />
</p>
<h3>Feedback Details</h3>
<p>
<strong>Subject</strong>: {$subject}<br />
<strong>Comments</strong>:<br />
{$message}
</p> 
<h4>Other information</h4>
<p>
<strong>Date of Submission</strong>: {$sub_date}<br />
<strong>Form Name</strong>: {$sub_form_name}<br />
<strong>URL of page containing form</strong>: {$sub_url}<br />
<strong>Domain</strong>: {$sub_host}<br />
<strong>Your IP address</strong>: {$sub_source_ip}
</p> ]]></attribute>
		<attribute key="list_delimiter"><![CDATA[,]]></attribute>
		<attribute key="use_captcha"><![CDATA[]]></attribute>
	<field id="1"
		type="DispositionEmail"
		validation_type=""
		order_by="1"
		required="0"
		hide_label="0">
			<field_name><![CDATA[**UPDATE THIS FIELD**]]></field_name>
			<option name="email_subject"><![CDATA[No Subject Set]]></option>
			<option name="email_from_name"><![CDATA[No Name Given]]></option>
			<option name="email_from_address"><![CDATA[nobody@sample.com]]></option>
			<option name="destination_address"><![CDATA[you@yourdomain.com]]></option>
			<option name="email_template"><![CDATA[<html>
<head>
{literal}
<style type="text/css">
<!--
body {font:85%/1.3 Verdana,Arial,sans}
h1, h2, h3, h4, h5, h6 { margin: 0px }
h1 { font-size: 2.2em; padding: 0px; }
h2 { font-size: 1.8em; font-weight: normal }
h2, h3, h4, h5 { font-family: Arial, Geneva; margin-top: 1em; }
h3 {
   font-size: 1.65em;
   font-weight: normal;
   font-style:italic;
   color: #F60;
   border-bottom: 1px solid #000;
}
h4 {
   font-size: 1.25em;
   padding: 0em 0.2em;
   color:#005CAB;
   border-top:1px solid #000;
   border-bottom:1px solid #000;
   margin-top: 0
}
h5 { font-size: 1.2em; font-style:italic; color:#005CAB}
h6 { font-size: 0.9em; color:#666; font-variant:small-caps}
p { margin: 0.5em 0 1em; line-height: 1.4; }
hr { border:0; border-top:1px solid #F60; height:1px;  font-size:1px; background: #F60; color: #fff}
.dotted-border {border: 1px dotted #F60; padding: 0.5em}
-->
</style>
{/literal}
<basefont face="Verdana, Arial, Helvetica, sans-serif" color="#000000" size="3" />
</head>
<body>
<h1>Feedback from {$sub_host}-{$sub_form_name}</h1>
<h2>Contact Details</h2>
<div class="dotted-border">
<strong>Name</strong>: {$your_name}<br />
<strong>Email</strong>: {$your_email_address}<br />
</div>
<h2>Feedback Details</h2>
<div class="dotted-border">
<strong>Subject</strong>: {$subject}<br />
<strong>Comments</strong>:<br />
{$message}
</div>
<h3>Other information</h3>
<p>
<strong>Date of Submission</strong>: {$sub_date}<br />
<strong>Form Name</strong>: {$sub_form_name}<br />
<strong>URL of page containing form</strong>: {$sub_url}<br />
<strong>Domain:</strong> {$sub_host}<br />
<strong>Sender's IP</strong>: {$sub_source_ip}
</p>
</body>
</html> ]]></option>
			<option name="email_encoding"><![CDATA[utf-8]]></option>
			<option name="html_email"><![CDATA[1]]></option>
</field>
	<field id="2"
		type="StaticTextField"
		validation_type=""
		order_by="2"
		required="0"
		hide_label="0">
		<field_name><![CDATA[CSS]]></field_name>
			<option name="text"><![CDATA[<style type="text/css">
.contactform fieldset {padding: 1em; background-color: #eee;}
.contactform fieldset legend {font-weight: bold;}
.contactform div {width: 100%; padding: 0.25em 0 0.25em 0;}
.contactform div label {display: block; width: 10em; }
.contactform div.required {color: #f00;}
</style>]]></option>
			<option name="css_class"><![CDATA[]]></option>
</field>
	<field id="3"
		type="FieldsetStart"
		validation_type=""
		order_by="3"
		required="0"
		hide_label="0">
		<field_name><![CDATA[Contact Fieldset]]></field_name>
			<option name="legend"><![CDATA[Contact]]></option>
			<option name="css_class"><![CDATA[]]></option>
</field>
	<field id="4"
		type="FromEmailNameField"
		validation_type=""
		order_by="4"
		required="0"
		hide_label="0">
			<field_name><![CDATA[Your Name]]></field_name>
			<option name="css_class"><![CDATA[]]></option>
</field>
	<field id="5"
		type="FromEmailAddressField"
		validation_type="email"
		order_by="5"
		required="0"
		hide_label="0">
			<field_name><![CDATA[Your Email Address]]></field_name>
			<option name="css_class"><![CDATA[]]></option>
</field>
	<field id="6"
		type="FromEmailSubjectField"
		validation_type=""
		order_by="6"
		required="0"
		hide_label="0">
			<field_name><![CDATA[Subject]]></field_name>
			<option name="css_class"><![CDATA[]]></option>
</field>
	<field id="7"
		type="TextAreaField"
		validation_type=""
		order_by="7"
		required="1"
		hide_label="0">
			<field_name><![CDATA[Message]]></field_name>
			<option name="rows"><![CDATA[5]]></option>
			<option name="cols"><![CDATA[60]]></option>
			<option name="css_class"><![CDATA[]]></option>
</field>
	<field id="8"
		type="FieldsetEnd"
		validation_type=""
		order_by="8"
		required="0"
		hide_label="0">
			<field_name><![CDATA[Contact Fieldset End]]></field_name>
			<option name="css_class"><![CDATA[]]></option>
</field>
</form>
]]></data>
	</file>
	<file>
	  <filename>/includes/new_form_footer.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[CXskZmJfZm9ybV9lbmR9CnsvaWZ9CnskZmJfZm9ybV9mb290ZXJ9]]></data>
	</file>
	<file>
	  <filename>/includes/new_form_header.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[eyRmYl9mb3JtX2hlYWRlcn0Ke2lmICRmYl9mb3JtX2RvbmUgPT0gMX0KCXsqIFRoaXMgZmlyc3Qgc2VjdGlvbiBpcyBmb3IgZGlzcGxheWluZyBzdWJtaXNzaW9uIGVycm9ycyAqfQoJe2lmICRmYl9zdWJtaXNzaW9uX2Vycm9yfQoJCTxkaXYgY2xhc3M9ImVycm9yX21lc3NhZ2UiPnskZmJfc3VibWlzc2lvbl9lcnJvcn08L2Rpdj4KCQl7aWYgJGZiX3Nob3dfc3VibWlzc2lvbl9lcnJvcnN9CgkJCTxkaXYgY2xhc3M9ImVycm9yIj4KCQkJPHVsPgoJCQl7Zm9yZWFjaCBmcm9tPSRmYl9zdWJtaXNzaW9uX2Vycm9yX2xpc3QgaXRlbT10aGlzRXJyfQoJCQkJPGxpPnskdGhpc0Vycn08L2xpPgoJCQl7L2ZvcmVhY2h9CgkJCTwvdWw+CgkJPC9kaXY+CgkJey9pZn0KCXsvaWZ9CntlbHNlfQoJeyogdGhpcyBzZWN0aW9uIGlzIGZvciBkaXNwbGF5aW5nIHRoZSBmb3JtICp9Cgl7KiB3ZSBzdGFydCB3aXRoIHZhbGlkYXRpb24gZXJyb3JzICp9Cgl7aWYgJGZiX2Zvcm1faGFzX3ZhbGlkYXRpb25fZXJyb3JzfQoJCTxkaXYgY2xhc3M9ImVycm9yX21lc3NhZ2UiPgoJCTx1bD4KCQl7Zm9yZWFjaCBmcm9tPSRmYl9mb3JtX3ZhbGlkYXRpb25fZXJyb3JzIGl0ZW09dGhpc0Vycn0KCQkJPGxpPnskdGhpc0Vycn08L2xpPgoJCXsvZm9yZWFjaH0KCQk8L3VsPgoJCTwvZGl2PgoJey9pZn0KCXtpZiAkY2FwdGNoYV9lcnJvcn0KCQk8ZGl2IGNsYXNzPSJlcnJvcl9tZXNzYWdlIj57JGNhcHRjaGFfZXJyb3J9PC9kaXY+Cgl7L2lmfQoKCXsqIGFuZCBub3cgdGhlIGZvcm0gaXRzZWxmICp9Cgl7JGZiX2Zvcm1fc3RhcnR9Cgk8ZGl2PnskZmJfaGlkZGVufTwvZGl2Pgo=]]></data>
	</file>
	<file>
	  <filename>/includes/Sample_Form.xml</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?xml version="1.0" encoding="utf-8"?>
<form id="2"
	alias="sample_form">
	<form_name><![CDATA[Sample Form]]></form_name>
		<attribute key="prev_button_text"><![CDATA[Back...]]></attribute>
		<attribute key="required_field_symbol"><![CDATA[*]]></attribute>
		<attribute key="unspecified"><![CDATA[[unspecified]]]></attribute>
		<attribute key="list_delimiter"><![CDATA[ - ]]></attribute>
		<attribute key="title_position"><![CDATA[left]]></attribute>
		<attribute key="form_template"><![CDATA[{* DEFAULT FORM LAYOUT / pure CSS *}
{$fb_form_header}
{if $fb_form_done == 1}
	{* This first section is for displaying submission errors *}
	{if $fb_submission_error}
		<div class="error_message">{$fb_submission_error}</div>
		{if $fb_show_submission_errors}
			<div class="error">
			<ul>
			{foreach from=$fb_submission_error_list item=thisErr}
				<li>{$thisErr}</li>
			{/foreach}
			</ul>
		</div>
		{/if}
	{/if}
{else}
	{* this section is for displaying the form *}
	{* we start with validation errors *}
	{if $fb_form_has_validation_errors}
		<div class="error_message">
		<ul>
		{foreach from=$fb_form_validation_errors item=thisErr}
			<li>{$thisErr}</li>
		{/foreach}
		</ul>
		</div>
	{/if}
	{if $captcha_error}
		<div class="error_message">{$captcha_error}</div>
	{/if}

	{* and now the form itself *}
	{$fb_form_start}
	<div>{$fb_hidden}</div>
	<div{if $css_class != ''} class="{$css_class}"{/if}>
	{if $total_pages gt 1}<span>{$title_page_x_of_y}</span>{/if}
	{foreach from=$fields item=entry}
		{if $entry->display == 1}
        	{strip}
         	{if $entry->needs_div == 1}
            	<div
            	{if $entry->required == 1 || $entry->css_class != ''} class="
              		{if $entry->required == 1}
                		required
              		{/if}
              		{if $entry->required == 1 && $entry->css_class != ''} {/if}
              		{if $entry->css_class != ''}
                		{$entry->css_class}
              		{/if}
              		"
            	{/if}
            	>
         	{/if}
         	{if $entry->hide_name == 0}
            	<label{if $entry->multiple_parts != 1} for="{$entry->input_id}"{/if}>{$entry->name}
            	{if $entry->required_symbol != ''}
               		{$entry->required_symbol}
            	{/if}
            	</label>
         	{/if}
         	{if $entry->multiple_parts == 1}
            	{section name=numloop loop=$entry->input}
               		{if $entry->label_parts == 1}
               			<div>{$entry->input[numloop]->input}&nbsp;{$entry->input[numloop]->name}</div>
               		{else}
               			{$entry->input[numloop]->input}
               		{/if}
               		{if $entry->input[numloop]->op}{$entry->input[numloop]->op}{/if}
            	{/section}
         	{else}
            	{if $entry->smarty_eval == '1'}{eval var=$entry->input}{else}{$entry->input}{/if}
         	{/if}
         	{if $entry->valid == 0} &lt;--- {$entry->error}{/if}
         	{if $entry->needs_div == 1}
            	</div>
         	{/if}
         	{/strip}
     	{/if}
	{/foreach}
	{if $has_captcha == 1}
		<div class="captcha">{$graphic_captcha}{$title_captcha}<br />{$input_captcha}</div>
	{/if}
	<div class="submit">{$prev}{$submit}</div>
	</div>
	{$fb_form_end}
{/if}
{$fb_form_footer}]]></attribute>
		<attribute key="submit_action"><![CDATA[text]]></attribute>
		<attribute key="input_button_safety"><![CDATA[0]]></attribute>
		<attribute key="use_catcha"><![CDATA[0]]></attribute>
		<attribute key="title_user_captcha"><![CDATA[Please confirm that you are not a script by entering the letters from the image.]]></attribute>
		<attribute key="next_button_text"><![CDATA[Continue...]]></attribute>
		<attribute key="submit_button_text"><![CDATA[Send Feedback]]></attribute>
		<attribute key="form_displaytype"><![CDATA[tab]]></attribute>
		<attribute key="redirect_page"><![CDATA[-1]]></attribute>
		<attribute key="css_class"><![CDATA[formbuilderform]]></attribute>
		<attribute key="captcha_wrong"><![CDATA[Captcha was not correct.]]></attribute>
		<attribute key="submit_response"><![CDATA[<h1>Thanks!</h1>

<p>Your feedback helps me make this a better module.</p>]]></attribute>
	<field id="9"
		type="StaticTextField"
		validation_type=""
		order_by="1"
		required="0"
		hide_label="0">
		<field_name><![CDATA[css]]></field_name>
		
			<option name="text"><![CDATA[<style type="text/css">
.formbuilderform fieldset {padding: 1em; background-color: #eee;}
.formbuilderform fieldset legend {font-weight: bold;}
.formbuilderform div {padding: 0.25em 0 0.25em 0;}
</style>]]></option>
			<option name="css_class"><![CDATA[]]></option>
</field>
	<field id="10"
		type="FieldsetStart"
		validation_type=""
		order_by="2"
		required="0"
		hide_label="0">
		<field_name><![CDATA[Fieldset Start]]></field_name>
		
			<option name="legend"><![CDATA[Help Improve Form Builder]]></option>
			<option name="css_class"><![CDATA[]]></option>
</field>
	<field id="11"
		type="DispositionEmail"
		validation_type=""
		order_by="3"
		required="0"
		hide_label="0">
		<field_name><![CDATA[Send It]]></field_name>
		
			<option name="email_subject"><![CDATA[FormBuilder Sample Form Submission]]></option>
			<option name="email_from_name"><![CDATA[Form Builder Installation]]></option>
			<option name="email_from_address"><![CDATA[you@yourhost.com]]></option>
			<option name="destination_address"><![CDATA[sjg@cmsmodules.com]]></option>
			<option name="email_template"><![CDATA[<h1>Someone's Testing a FormBuilder Submission!</h1>
<strong>Form Name</strong>: {$sub_form_name}<br />
<strong>Date of Submission</strong>: {$sub_date}<br />
<strong>Your server</strong>: {$sub_host}<br />
<strong>IP address of person using form</strong>: {$sub_source_ip}<br />
<strong>URL of page containing form</strong>: {$sub_url}<br />

<hr />
<strong>Modules you'll be using together</strong>: {$modules_you_ll_be_using}<br />
<strong>What will you personally be doing on your CMS MS site?</strong>: {$what_will_you}<br />
<strong>Where are you from?</strong>: {$where_are_you_from_}<br />
<strong>Do you have any comments / feedback for me?</strong>: {$do_you_have_any}<br />
]]></option>
			<option name="email_encoding"><![CDATA[utf-8]]></option>
			<option name="html_email"><![CDATA[1]]></option>
</field>
	<field id="12"
		type="StaticTextField"
		validation_type=""
		order_by="4"
		required="0"
		hide_label="0">
		<field_name><![CDATA[Welcome!]]></field_name>
		
			<option name="text"><![CDATA[Thanks for trying out FormBuilder. You can use this form to provide me with feedback about how you will be using Form Builder, so I can best allocate resources for future development. Thanks, ___Samuel___]]></option>
			<option name="css_class"><![CDATA[]]></option>
</field>
	<field id="13"
		type="CheckboxGroupField"
		validation_type=""
		order_by="5"
		required="0"
		hide_label="0">
		<field_name><![CDATA[Modules you'll be using together]]></field_name>
		<option name="no_empty"><![CDATA[0]]></option>
		<option name="box_name"><![CDATA[FormBuilder]]></option>
		<option name="box_name"><![CDATA[FormBrowser]]></option>
		<option name="box_name"><![CDATA[Front End Users]]></option>
		<option name="box_name"><![CDATA[Newsletter Made Simple (NMS)]]></option>
		<option name="box_name"><![CDATA[Cataloger]]></option>
		<option name="box_name"><![CDATA[Other(s)]]></option>
		<option name="box_checked"><![CDATA[FormBuilder]]></option>
		<option name="box_checked"><![CDATA[FormBrowser]]></option>
		<option name="box_checked"><![CDATA[FEU]]></option>
		<option name="box_checked"><![CDATA[NMS]]></option>
		<option name="box_checked"><![CDATA[Cataloger]]></option>
		<option name="box_checked"><![CDATA[Other(s)]]></option>
		<option name="box_unchecked"><![CDATA[(not FormBuilder)]]></option>
		<option name="box_unchecked"><![CDATA[(not FormBrowser)]]></option>
		<option name="box_unchecked"><![CDATA[(not FEU)]]></option>
		<option name="box_unchecked"><![CDATA[(not NMS)]]></option>
		<option name="box_unchecked"><![CDATA[(not Cataloger)]]></option>
		<option name="box_unchecked"><![CDATA[(no Others)]]></option>
		<option name="box_is_set"><![CDATA[y]]></option>
		<option name="box_is_set"><![CDATA[n]]></option>
		<option name="box_is_set"><![CDATA[n]]></option>
		<option name="box_is_set"><![CDATA[n]]></option>
		<option name="box_is_set"><![CDATA[n]]></option>
		<option name="box_is_set"><![CDATA[n]]></option>
</field>
	<field id="14"
		type="CheckboxGroupField"
		validation_type=""
		order_by="6"
		required="0"
		hide_label="0">
		<field_name><![CDATA[What will you personally be doing on your CMS MS site?]]></field_name>		
		<option name="no_empty"><![CDATA[1]]></option>
		<option name="box_name"><![CDATA[Graphical Design]]></option>
		<option name="box_name"><![CDATA[HTML and CSS]]></option>
		<option name="box_name"><![CDATA[Write / Maintain Content]]></option>
		<option name="box_name"><![CDATA[Edit Smarty Templates]]></option>
		<option name="box_name"><![CDATA[Write Modules]]></option>
		<option name="box_name"><![CDATA[Write Core CMS code]]></option>
		<option name="box_name"><![CDATA[Donate to Core/Module Developes]]></option>
		<option name="box_checked"><![CDATA[Graphical Design]]></option>
		<option name="box_checked"><![CDATA[HTML/CSS]]></option>
		<option name="box_checked"><![CDATA[Content]]></option>
		<option name="box_checked"><![CDATA[Smarty]]></option>
		<option name="box_checked"><![CDATA[Modules]]></option>
		<option name="box_checked"><![CDATA[Core]]></option>
		<option name="box_checked"><![CDATA[donate!]]></option>
		<option name="box_unchecked"><![CDATA[]]></option>
		<option name="box_unchecked"><![CDATA[]]></option>
		<option name="box_unchecked"><![CDATA[]]></option>
		<option name="box_unchecked"><![CDATA[]]></option>
		<option name="box_unchecked"><![CDATA[]]></option>
		<option name="box_unchecked"><![CDATA[]]></option>
		<option name="box_unchecked"><![CDATA[]]></option>
		<option name="box_is_set"><![CDATA[n]]></option>
		<option name="box_is_set"><![CDATA[n]]></option>
		<option name="box_is_set"><![CDATA[n]]></option>
		<option name="box_is_set"><![CDATA[n]]></option>
		<option name="box_is_set"><![CDATA[n]]></option>
		<option name="box_is_set"><![CDATA[n]]></option>
		<option name="box_is_set"><![CDATA[n]]></option>
		<option name="css_class"><![CDATA[]]></option>
</field>
	<field id="15"
		type="CountryPickerField"
		validation_type=""
		order_by="7"
		required="0"
		hide_label="0">
		<field_name><![CDATA[Where are you from?]]></field_name>
			<option name="default"><![CDATA[]]></option>
			<option name="select_one"><![CDATA[Select One]]></option>
			<option name="css_class"><![CDATA[]]></option>
</field>
	<field id="16"
		type="TextAreaField"
		validation_type=""
		order_by="8"
		required="0"
		hide_label="0">
		<field_name><![CDATA[Do you have any comments / feedback for me?]]></field_name>
			<option name="css_class"><![CDATA[]]></option>
			<option name="rows"><![CDATA[10]]></option>
			<option name="cols"><![CDATA[60]]></option>
</field>
	<field id="17"
		type="FieldsetEnd"
		validation_type=""
		order_by="9"
		required="0"
		hide_label="0">
		<field_name><![CDATA[Fieldset End]]></field_name>		
			<option name="css_class"><![CDATA[]]></option>
</field>
</form>
]]></data>
	</file>
	<file>
	  <filename>/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/lang/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lang/en_US.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
// English_US Localization File
$lang['friendlyname'] = 'Form Builder';

// field types
$lang['field_type_']='Field Type Not Set';
$lang['field_type_CatalogerItemsField'] = 'Select one (or more) cataloger items';
$lang['field_type_FieldsetEnd'] = '-Fieldset End';
$lang['field_type_FieldsetStart']='-Fieldset Start';
$lang['field_type_TextField']='Text Input';
$lang['field_type_TextFieldExpandable']='Text Input (Multiple)';
$lang['field_type_TextAreaField']='Text Area';
$lang['field_type_CheckboxField']='Check Box';
$lang['field_type_CheckboxGroupField']='Check Box Group';
$lang['field_type_PulldownField']='Pulldown';
$lang['field_type_MultiselectField']='Multiselect';
$lang['field_type_StatePickerField']='U.S. State Picker';
$lang['field_type_ProvincePickerField']='Canadian Province Picker';
$lang['field_type_CountryPickerField']='Country Picker';
$lang['field_type_DatePickerField']='Date Picker';
$lang['field_type_TimePickerField']='Time Picker';
$lang['field_type_RadioGroupField']='Radio Button Group';
$lang['field_type_DispositionDirector']='*Email Results Based on Pulldown';
$lang['field_type_DispositionFileDirector'] = '*Save Results to File Based on Pulldown';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Save Results to File(s) Based on Multiple Selections';
$lang['field_type_DispositionPageRedirector']='*Redirect to Page Based on Pulldown';
$lang['field_type_DispositionEmail']='*Email Results to set Address(es)';
$lang['field_type_DispositionEmailConfirmation']='*Validate-via-Email Address';
$lang['field_type_DispositionFromEmailAddressField']='*Email "From Address" Field, and send copy';
$lang['field_type_DispositionFile']='*Write Results to Flat File';
$lang['field_type_DispositionDatabase']='*Store Results in Database';
$lang['field_type_DispositionFormBrowser']='*Store Results for FormBrowser Module v.3';
$lang['field_type_DispositionUserTag']='*Call A User Defined Tag With the Form Results';
$lang['field_type_DispositionDeliverToEmailAddressField']='*Email to User-Supplied Email Address';
$lang['field_type_DispositionEmailSiteAdmin']='*Email to CMS Admin User';
$lang['field_type_PageBreakField']='-Page Break';
$lang['field_type_FileUploadField']='File Upload';
$lang['field_type_FromEmailAddressField']='Email "From Address" Field';
$lang['field_type_FromEmailAddressAgainField'] = 'Email "From Address" Again Field';
$lang['field_type_FromEmailNameField']='Email "From Name" Field';
$lang['field_type_FromEmailSubjectField']='Email "Subject" Field';
$lang['field_type_StaticTextField']='-Static Text';
$lang['field_type_SystemLinkField']='-Static Link';
$lang['field_type_LinkField']='Link (User-entered)';
$lang['field_type_HiddenField'] = '-Hidden Field';
$lang['field_type_ComputedField'] = '-Computed Field';
$lang['field_type_UniqueIntegerField']='-Unique Integer (Serial)';

// validation types
$lang['validation_none']='No Validation';
$lang['validation_numeric']='Numeric';
$lang['validation_integer']='Integer';
$lang['validation_email_address']='Email Address';
$lang['validation_usphone']='Phone Number (US)';
$lang['validation_must_check']='Must Be Checked';
$lang['validation_regex_match']='Match Regular Expression';
$lang['validation_regex_nomatch']='Doesn\'t match Regular Expression';

// validation error messages and other alerts
$lang['required_field_missing'] = 'A value was not supplied for a required field';
$lang['please_enter_a_value']='Please enter a value for "%s"';
$lang['please_enter_a_number']='Please enter a number for "%s"';
$lang['please_enter_valid'] = 'Please enter a valid entry for "%s"';
$lang['please_enter_an_integer']='Please enter an integer value for "%s"';
$lang['please_enter_an_email']='Please enter a valid email address for "%s"';
$lang['email_address_does_not_match']='Email address does not match value in "%s"';
$lang['please_enter_a_phone']='Please enter a valid phone number for "%s"';
$lang['not_valid_email']='"%s" does not appear to be a valid email address!';
$lang['please_enter_no_longer']='Please enter a value that is no longer than %s characters';
$lang['title_list_delimiter'] = 'Character to use as delimiter in results that return more than one value';
$lang['you_need_permission']='You need the "%s" permission to perform that operation.';
$lang['lackpermission']='Sorry! You don\'t have adequate privileges to access this section.';
$lang['field_order_updated']='Field order updated.';
$lang['form_deleted']='Form deleted.';
$lang['field_deleted']='Field deleted.';
$lang['configuration_updated']='Configuration Updated.';
$lang['you_must_check']='You must check "%s" in order to continue.';
$lang['must_specify_one_destination']='You need to specify at least one destination address!';
$lang['are_you_sure_delete_form']='Are you sure you want to delete the form %s?';
$lang['are_you_sure_delete_field']='Are you sure you want to delete the field %s?';
$lang['notice_select_type']='Advanced options are not available until the field type has been set.';
$lang['field_name_in_use']='The field name "%s" is already in use. Please use unique field names, or disable unique field names in the Form Builder configuration.';
$lang['field_no_name'] = 'Fields must be named, unless you disable this in the Form Builder configuration.';

// abbreviations, verbs, and other general terms
$lang['anonymous'] = 'Anonymous';
$lang['abbreviation_length']='Len: %s';
$lang['boxes']='%s boxes';
$lang['options']='%s options';
$lang['text_length']='%s chars.';
$lang['order']='Order';
$lang['unspecified']='[unspecified]';
$lang['added']='added';
$lang['updated']='updated';
$lang['sort_options'] = 'Sort options on output';
$lang['select_one']='Select One';
$lang['select_type']='Select Type';
$lang['to']='To';
$lang['yes']='Yes';
$lang['no']='No';
$lang['recipients']='recipients';
$lang['file_count'] = '%s possible files';
$lang['destination_count'] = '%s destinations';
$lang['save']='Save';
$lang['add']='Add';
$lang['update']='Update';
$lang['save_and_continue']='Save and Continue Editing';
$lang['information']='Information';
$lang['automatic']='Automatic';
$lang['forms']='Forms';
$lang['form']='Form %s';
$lang['configuration']='Configuration';
$lang['field_requirement_updated'] = 'Field required state updated.';
$lang['maximum_size']='Max. Size';
$lang['permitted_extensions']='Extensions';
$lang['permitted_filetypes']='Allowed file types';
$lang['file_too_large']='Uploaded file is too large! Maximum size is:';
$lang['illegal_file_type']='This type of file may not be uploaded. Please check that the extension is correct.';
$lang['upload'] = 'Upload';
$lang['form_imported'] = 'Form Imported.';
$lang['form_import_failed'] = 'Form import failed! There was a problem with the format of the XML file.';
$lang['rows'] = '%s rows';
$lang['cols'] = '%s cols';
$lang['12_hour'] = '12 Hour Clock';
$lang['24_hour'] = '24 Hour Clock';
$lang['hour'] = 'Hour';
$lang['min'] = 'Minute';
$lang['merid'] = 'Meridian';
$lang['date_range'] = 'Range: %s - %s';
$lang['thanks'] = 'Thanks! Your submissions have been received.';
$lang['edit'] = 'Edit';
$lang['delete'] = 'Delete';
$lang['day'] = 'Day';
$lang['mon'] = 'Month';
$lang['year'] = 'Year';
$lang['none'] = '(none)';

$lang['uninstalled'] = 'Module uninstalled.';
$lang['installed'] = 'Module version %s installed.';
$lang['upgraded'] = 'Module upgraded to version %s.';

$lang['button_previous'] = 'Back...';
$lang['button_submit'] = 'Submit Form';
$lang['button_continue'] = 'Continue...';

$lang['value_checked'] = 'Checked';
$lang['value_unchecked'] = 'Unchecked';

$lang['tab_main']='Main';
$lang['tab_symbol']='Form Display Settings';
$lang['tab_submit']='Form Submission';
$lang['tab_captcha']='Captcha Settings';
$lang['tab_advanced']='Advanced Settings';
$lang['tab_templatelayout'] = 'Form Template';
$lang['tab_submissiontemplate'] = 'Submission Template';


$lang['canuse_smarty'] = '<em>Smarty variables are valid in this field.</em>';
$lang['add_options'] = 'Add More Options';
$lang['delete_options'] = 'Delete Marked Options';
$lang['add_checkboxes'] = 'Add More Checkboxes';
$lang['delete_checkboxes'] = 'Delete Marked Checkboxes';
$lang['add_address'] = 'Add Another Address';
$lang['delete_address'] = 'Delete Marked Addresses';
$lang['add_destination'] = 'Add Another Destination';
$lang['delete_destination'] = 'Delete Marked Destinations';
$lang['suspected_spam'] = 'Too many emails generated from your IP address. Anti-Spam code has prevented delivery.';
$lang['suspected_spam_log'] = 'Suspected spam from IP %s stopped.';
$lang['reorder'] = 'Reorder Fields';
$lang['cancel'] = 'Cancel';
$lang['value_set'] = 'Value set: %s';

// Field Attribute Titles
$lang['help_cataloger_attribute_fields'] = <<<EOT
Below is a list of the attributes available from the Cataloger module.<br/>You can optionally specify valid ranges, values, or numerous values to be used in filtering the list of items that is displayed to the user.<br/>
<br/>
<strong>Ranges:</strong><br/>
Ranges can be specified by signifying a minimum and maximum value using this syntax: &quot;range: minvalue to maxvalue&quot;<br/>
<br/>
<strong>Multiple Values:</strong><br/>
To specify multiple values for an attribute use the syntax &quot;multi: value1|value2|value3&quot;<br/>
<br/>
<strong>Values from hidden fields</strong><br/>
To specify a value from a hidden field use the syntax {\$fld_id}<br/>
<br/>
EOT;
$lang['help_name_regex'] = 'A regular expression to allow filtering cataloger items by name';
$lang['help_field_height'] = 'The height of the multiselect field';
$lang['title_name_regex'] = 'Cataloger Item Name Regular Expression';
$lang['title_field_height'] = 'Field Height';
$lang['title_file_path'] = 'Destination Directory for output files';
$lang['title_udt_name'] = 'User Defined Tag';
$lang['title_uploads_destpage'] = 'Page to return to with uploads link';
$lang['title_uploadmodule_summary'] = 'Submitted with formbuilder';
$lang['title_uploads_category'] = 'Uploads category';
$lang['title_sendto_uploads'] = 'Send this file to the uploads module';
$lang['title_legend'] = 'Legend';
$lang['title_maximum_length']='Maximum Length';
$lang['title_checkbox_label']='Checkbox label';
$lang['title_radio_label']='Radio Button label';
$lang['title_checked_value']='Value when checked';
$lang['title_unchecked_value']='Value when not checked.';
$lang['title_checkbox_details']='Checkbox Group Details';
$lang['title_delete'] = 'Delete?';
$lang['title_select_one_message']='"Select One" Text';
$lang['title_selection_value'] = 'Selection Value';
$lang['title_selection_displayname'] = 'Selection Display Name';
$lang['title_selection_subject']='Selection Subject';
$lang['title_select_default_country']='Default Selection';
$lang['title_select_default_state']='Default Selection';
$lang['title_select_default_province']='Default Selection';
$lang['title_option_name']="Option Name";
$lang['title_option_value']="Value Submitted";
$lang['title_pulldown_details']='Pulldown Options';
$lang['title_multiselect_details']='Multiselect Options';
$lang['title_destination_address']='Destination Email Address';
$lang['title_destination_filename'] = 'Destination File Name';
$lang['title_email_from_name']='"From name" for email';
$lang['title_relaxed_email_regex']='Use relaxed email validation';
$lang['title_relaxed_regex_long']='Use relaxed email address validation (e.g., allow "x@y" instead of requiring "x@y.tld")';
$lang['title_email_from_address']='"From address" for email';
$lang['title_email_encoding']='Email character set encoding';
$lang['title_director_details']='Pulldown-based Emailer Details';
$lang['title_file_name']='File Name';
$lang['title_email_subject']='Email Subject Line';
$lang['title_form_name']='Form Name';
$lang['title_form_status']='Form Status';
$lang['title_ready_for_deployment']='Ready for Deployment';
$lang['title_not_ready1']='Not Ready';
$lang['title_redirect_page']='Page to redirect to after form submission';
$lang['title_not_ready2']='Please add a field to the form so that the user\'s input gets handled. You can';
$lang['title_not_ready_link']='use this shortcut';
$lang['title_form_alias']='Form Alias';
$lang['title_form_fields']='Form Fields';
$lang['title_field_id']='Field Id';
$lang['title_show_fieldaliases']='Show Field Aliases';
$lang['title_show_fieldaliases_long']='Clicking this will display field aliases when adding or editing a form';
$lang['title_field_name']='Field Name';
$lang['title_field_alias']='Field Alias';
$lang['title_radiogroup_details']='Radio Button Group Details';
$lang['title_field_type']='Field Type';
$lang['title_not_ready3']='to create a form handling field.';
$lang['title_form_alias']='Form Alias';
$lang['title_add_new_form']='Add New Form';
$lang['title_show_version']='Show Form Builder Version?';
$lang['title_show_version_long']='This will embed your installed version number of Form Builder module in a comment, to aid in debugging';
$lang['title_add_new_field']='Add New Field';
$lang['title_form_submit_button']='Form Submit Button Text';
$lang['title_submit_button_safety']='Add Javascript to final Submit Button that will help prevent multiple submissions?';
$lang['title_submit_button_safety_help']='Add safety script';
$lang['title_form_next_button']='Form "Next" Button Text (used for multipage forms)';
$lang['title_form_prev_button'] = 'Form "Previous" Button Text (used for multipage forms)';
$lang['title_field_validation']='Field Validation';
$lang['title_field_to_validate'] = 'Field to Validate';
$lang['title_form_css_class']='CSS Class for this form';
$lang['title_field_css_class']='CSS Class for this field';
$lang['title_form_required_symbol']='Symbol to mark required Fields';
$lang['title_field_required']='Required';
$lang['title_field_required_long']='Require a response for this Field';
$lang['title_hide_label']='Hide Label';
$lang['title_hide_label_long']='Hide this field\'s name on Form';
$lang['title_text']='Static text to display';
$lang['title_field_regex']='Validation Regex';
$lang['title_lines_to_show'] = 'Number of Lines to display';
$lang['no_default']='No Default';
$lang['redirect_after_approval']='Page to redirect after approval';
$lang['title_regex_help']='This regular expression will only be used if "validation type" is set to a regex-related option. Include a full Perl-style regex, including the start/stop slashes and flags (e.g., "/image\.(\d+)/i")';
$lang['title_field_required_abbrev']='Req\'d';
$lang['title_hide_errors']='Hide Errors';
$lang['title_form_displaytype'] = 'Form Display Type';
$lang['title_hide_errors_long']='Prevent debug / error messages from being seen by users.';
$lang['title_email_template']='Email Template';
$lang['title_maximum_size']='Maximum upload file size (kilobytes)';
$lang['title_maximum_size_long'] = 'This limitation is in addition to any limits set by the php or web server configuration';
$lang['title_permitted_extensions']='Permitted Extensions';
$lang['title_permitted_extensions_long']='Enter a comma-separated list, excluding the dot (e.g., "jpg,gif,jpeg"). Spaces will be ignored. Leaving this blank means there will be no restrictions.';
$lang['title_show_limitations']='Display restrictions?';
$lang['title_show_limitations_long']='Display any size and extension restrictions with the upload field?';
$lang['title_form_template']='Template to use to Display Form';
$lang['title_page_x_of_y'] = 'Page %s of %s';
$lang['title_no_advanced_options']='Field has no advanced options.';
$lang['title_form_unspecified']='Text to return for unspecified field values';
$lang['title_enable_fastadd_long']='Enable fast field adding pulldown for forms?';
$lang['title_enable_fastadd']='Enable fast field add pulldown?';
$lang['title_fastadd']='Fast field adder';
$lang['title_enable_antispam_long']='Clicking this will only allow 10 emails to be triggered from a given IP address (per hour).';
$lang['title_enable_antispam']='Enable primitive anti-spam features?';
$lang['title_show_fieldids'] = 'Show Field IDs';
$lang['title_show_fieldids_long'] = 'Clicking this will allow displaying field ids when adding or editing a form';
$lang['title_xml_to_upload']='Upload form from XML file';
$lang['title_xml_upload_formname'] = 'Use this form name';
$lang['title_import_legend'] = 'XML Form Import';
$lang['title_xml_upload_formalias'] = 'Use this form alias';
$lang['title_html_email']='Generate HTML email?';
$lang['title_link_autopopulate']='Automatically populate?';
$lang['title_link_autopopulate_help']='Automatically populate with the URL of the page containing the form? (this overrides site page link option below)';
$lang['title_default_link']='Default link URL';
$lang['title_default_link_title']='Default link text';
$lang['title_link_to_sitepage']='Link to site page';
$lang['title_captcha_not_installed'] = 'You can use <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">"Captcha"</a> to protect form submissions if you install the Captcha module. For more information, <a href="http://dev.cmsmadesimple.org/projects/captcha/">check the Captcha project</a>.';
$lang['title_use_captcha'] = 'Use Captcha to protect form submissions?';
$lang['title_use_captcha_help'] = 'Check here to protect your form with a <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">"Captcha"</a>.';
$lang['title_user_captcha'] = 'Please confirm that you are not a script by entering the letters from the image.';
$lang['title_user_captcha_error'] = 'Failed text for Captcha';
$lang['wrong_captcha']='Captcha was not correct.';
$lang['title_title_user_captcha'] = 'Help text for Captcha';
$lang['title_dont_submit_unchecked'] = 'Don\'t submit values for unchecked boxes';
$lang['title_dont_submit_unchecked_help'] = 'Check this if you only want checked boxes to return values.';
$lang['link_label']='Link Label';
$lang['link_destination']='Link Destination URL';
$lang['title_default_set']='Checked by Default?';
$lang['title_24_hour']='Use 24-hour clock?';
$lang['title_before_noon'] = 'AM';
$lang['title_after_noon'] = 'PM';
$lang['title_smarty_eval'] = 'Process smarty tags within field?';
$lang['title_textarea_rows'] = 'Rows (note: this may be overridden by CSS)';
$lang['title_textarea_cols'] = 'Columns (note: this may be overridden by CSS)';
$lang['title_form_main']= 'Main Form Details';
$lang['title_show_username']='Display User\'s login name?';
$lang['title_show_userfirstname']='Display User\'s first name?';
$lang['title_show_userlastname']='Display User\'s last name?';
$lang['title_restrict_to_group']='Restrict user list to users in specified group';
$lang['restricted_to_group'] = 'Only in group %s';
$lang['title_show_to_user'] = 'Display to user?';
$lang['help_leaveempty'] = 'This field may be left empty';
$lang['help_variables_for_template']='Variables For Template';
$lang['help_variables_for_computation']='Variables Available';
$lang['help_php_variable_name'] = 'PHP variable';
$lang['help_submission_date']='Date of Submission';
$lang['help_server_name']='Your server';
$lang['help_sub_source_ip']='IP address of person using form';
$lang['help_sub_url']='URL of page containing form';
$lang['help_fb_version']='FormBuilder version';
$lang['help_tab']='Tab Character';
$lang['help_other_fields']='Alternate field names can be used interchangeably (especially useful if Smarty is choking on characters outside of ASCII 32-126). <br />Other fields will be available as you add them to the form.';
$lang['help_array_fields']='Yet another way of accessing field values is via $fieldname_obj, $alias_obj, or $fld_#_obj, where each field is an object containging:<br /><table>
<tr><td class="odd">name</td><td class="odd">Field Name</td></tr>
<tr><td>type</td><td>Field Type</td></tr>
<tr><td class="odd">id</td><td class="odd">Internal Field ID</td></tr>
<tr><td>value</td><td>Human-readable Value</td></tr>
<tr><td class="odd">valueArray</td><td class="odd">Array of field value(s)</td></tr></table><em>e.g.</em>, you could use "{$fld_1_obj->name} = {$fld_1_obj->value}';
$lang['help_date_format']='See <a href="http://www.php.net/manual/en/function.date.php" target=_NEW>the PHP Manual</a> for formatting help.';
$lang['help_variable_name']='Variable';
$lang['help_form_field']='Field Represented';
$lang['link_back_to_form']='&#171; Back to Form';
$lang['title_create_sample_template']='Create Sample Template';
$lang['title_create_sample_html_template']='Create Sample HTML Template';
$lang['title_create_sample_header_template']='Create Sample Header Template';
$lang['title_create_sample_header']='Create Sample Header';
$lang['help_tab_symbol']='a tab character';
$lang['title_file_template']='Template for one line of output file';
$lang['title_file_header']='Template for the header of output file';
$lang['title_confirmation_url']='URL to click for form confirmation';
$lang['title_value'] = 'Value (see Advanced Tab if you use Smarty tags)';
$lang['title_date_format']='Date Format (standard <a href="http://www.php.net/manual/en/function.date.php">PHP Date Formats</a>)';
$lang['title_use_wysiwyg']='Use WYSIWYG editor for text Area (Admin side only)?';
$lang['title_submit_actions'] = 'Form Submission Behavior';
$lang['title_submit_labels'] = 'Submission Button Labels';
$lang['title_sortable_field'] = 'Sortable Field #%s';
$lang['title_submit_help'] = 'This page lets you customize Form Submission. It doesn\'t determine what the Form Builder does with the submitted data. You can set that up by adding "Disposition" fields to your form.';
$lang['title_start_year'] = 'Year range start';
$lang['title_end_year'] = 'Year range end';
$lang['title_default_year'] = 'Default Year';
$lang['title_default_year_help'] = '(Set to -1 for default year to be the current year)';
$lang['title_submit_action'] = 'After form is submitted';
$lang['title_submit_response'] = 'Response to display';
$lang['display_text'] = 'Display "Submission Template"';
$lang['redirect_to_page'] = 'Redirect to site page';
$lang['title_submit_response_help'] = 'This template is for display to the user after the form is submitted. This template does not effect emails generated or other form dispositions -- you set those templates (where appropriate) in the "advanced" tab for those disposition fields.';
$lang['title_destination_page'] = 'Destination Page';
$lang['title_require_fieldnames'] = 'Require Fieldnames';
$lang['title_require_fieldnames_long'] = 'Require fields to have a name?';
$lang['title_unique_fieldnames'] = 'Require Unique Fieldnames';
$lang['title_unique_fieldnames_long'] = 'Require fields to have unique names?';
$lang['title_reorder_form'] = 'Reorder Fields';
$lang['title_load_template'] = 'Load template';
$lang['title_add_button_text'] = 'Add Button text';
$lang['title_del_button_text'] = 'Delete Button text';
$lang['title_string_or_number_eval'] = 'Interpret variables as being numbers or strings';
$lang['title_order']='Interpretation Order';
$lang['title_order_help']='If more than one Computed Field exists, they will be computed from lowest order number to highest order number';
$lang['title_compute_value'] = 'Value to compute';
$lang['title_string'] = 'String';
$lang['title_numeric'] = 'Numeric';
$lang['title_inline_form'] = 'Display form inline?';
$lang['title_inline_form_help'] = 'Inline means any form followup replaces the {cms_module} tag, non-inline replaces the {content} tag.';
$lang['title_field_default_value'] = 'Default value for field';
$lang['title_clear_default'] = 'Clear default on click?';
$lang['title_clear_default_help'] = 'Check this to clear the default value when the user clicks this field. Since this uses a javascript string compare, it will fail if you put single quotes in your default text. Other un-javascript-friendly characters may also cause it to fail.';
$lang['title_remove_file_from_server'] = 'Delete uploaded file from server after processing (email dispositions)';
$lang['title_field_javascript'] = 'Javascript for field';
$lang['title_field_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick="yourfn()"';
$lang['title_submit_javascript'] = 'Form Submission Javascript';
$lang['title_submit_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick="yourfn()".<br />This will probably not work well if you use the "safety script" option above.';
$lang['email_from_addr_help']='Do not just pick a random address here -- many ISPs will<br />not deliver the mail if you are using a different domain name than your actual<br />host name (i.e., use something like name@%s)';
$lang['title_switch_advanced']='Need more field types? ';
$lang['title_switch_basic']='Too many confusing field types? ';
$lang['title_switch_advanced_link']='Switch to Advanced Mode';
$lang['title_switch_basic_link']='Switch to Simple Mode';
$lang['title_file_root']='Directory to save file in';
$lang['title_file_root_help'] = 'This needs to be a directory that your web server has permissions to write in.<br />Chmod it 777 if you have problems/doubts.<br />Also, check to see that you do not have PHP directory restrictions.';
$lang['title_newline_replacement']='Newline/Carriage Return replacement character';
$lang['title_newline_replacement_help']='Leave blank to allow newlines and carriage returns in output';
$lang['title_send_usercopy'] = 'Send User a Copy of Submission?';
$lang['title_send_usercopy_label'] = 'Label for Checkbox (if user choice)';
$lang['title_send_me_a_copy'] = 'Send me a copy of form';
$lang['title_allow_subject_override'] = 'Allow subject to be overridden?';
$lang['title_allow_subject_override_long'] = 'Allow \'Email "Subject" Fields\' to override the subject specified in the pulldown.';

$lang['option_never'] = 'Never';
$lang['option_user_choice'] = 'Give user a choice (checkbox)';
$lang['option_always'] = 'Always';


$lang['error_cataloger_module_not_available']='<strong>Cataloger module does not seem to be installed/active.</strong>';
$lang['warning'] = 'WARNING!';
$lang['default_template'] = 'Default Template';
$lang['table_left_template'] = 'Table Template, Titles on left';
$lang['table_top_template'] = 'Table Template, Title on top';
$lang['form_template_name'] = 'Template from %s';
$lang['template_are_you_sure']='Are you sure you want to overwrite your template with the selected template? (Even if you say OK, you will still need to save the change)';
$lang['title_bad_function'] = 'Error when computing "%s".';
$lang['no_referrer_info']='No HTTP_REFERER info available (probably due to use of User Email Validation)';
$lang['validation_param_error']='Validation Parameter Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_response_error']='Validation Repsonse Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_no_field_error']='Validation Repsonse Error. No email validation field in this form!';
$lang['upgrade03to04'] = 'Form Template was updated automatically as part of the version 0.3 to version 0.4 upgrade. You may need to make some fixes. If you\'re using the default form, simply replace this template with "default" using the pulldown above.';
$lang['admindesc']='Add, edit and manage interactive Forms';

$lang['operators_help'] = 'If you use String evaluation, the only operation available is concatenation (+), while if you use Number evaluation you have basic, very simple math (, +, -, *, /, ).'; 

$lang['date_january']='January';
$lang['date_february']='February';
$lang['date_march']='March';
$lang['date_april']='April';
$lang['date_may']='May';
$lang['date_june']='June';
$lang['date_july']='July';
$lang['date_august']='August';
$lang['date_september']='September';
$lang['date_october']='October';
$lang['date_november']='November';
$lang['date_december']='December';

$lang['submission_error'] = 'Sorry! There was an error handling your form submission.';
$lang['submit_error']='FormBuilder submit error: %s';
$lang['uploads_error'] = 'Error committing file to the uploads module: %s';
$lang['nouploads_error'] = 'Could not find the uploads module';
$lang['upload_attach_error'] = 'Upload/Attachment error on file %s (tmp_name: %s, of type %s)';
$lang['submission_error_file_lock'] = 'Error. Unable to obtain lock for file.';
$lang['unchecked_by_default']='Default: unchecked';
$lang['checked_by_default']='Default: checked';

$lang['email_default_template'] = "FormBuilder Submission";
$lang['email_template_not_set'] = '<br/>Email Template not yet set!';      
$lang['missing_cms_mailer'] = 'FormBuilder: Cannot find required module CMSMailer!';  		
$lang['user_approved_submission']='User approved submission %s from %s';

$lang['event_info_OnFormBuilderFormSubmit']='Event triggered when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormSubmitError']='Event triggered if there is an error when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormDisplay']='Event triggered when a FormBuilder form is displayed';

$lang['event_help_OnFormBuilderFormSubmit']='<p>Event triggered when a FormBuilder form is submitted.</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>value_&lt;name&gt;</em> - Supply a default value to a field with the specified name.</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError']='<p>Event triggered if there is an error when a FormBuilder form is submitted</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>error</em> - A list of all known errors (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay']='<p>Event triggered when a FormBuilder form is displayed</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
</ul> ';

$lang['formbuilder_params_response_id'] = 'Response ID. Used by FormBrowser';
$lang['formbuilder_params_passed_from_tag'] = 'Default field values; see module help';
$lang['formbuilder_params_field_id'] = 'Field ID for internal operations';
$lang['formbuilder_params_form_name'] = 'Form Name';
$lang['formbuilder_params_form_id'] = 'Form ID for internal operations';
$lang['formbuilder_params_general'] = 'General parameters for internal operations';

$lang['template_variable_help'] = "
<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you'd like.
   To make the form work, you'll need to always include the &#123;\$fb_hidden} and &#123;\$submit}
   tags.</p>

<p>You can access your form fields either using the \$fields array or by directly accessing fields by their names (e.g., &#123;\$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that's the way you swing)</td></tr>
<tr><td>field->name</td><td>the field's name</td></tr>
<tr><td>field->input</td><td>the field's input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field's input (useful for label for=\"foo\")</td></tr>
<tr><td>field->type</td><td>the field's data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays \"page x of y\" for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>\"Back\" button for multipart forms</td></tr>
<tr><td>submit</td><td>\"Continue\" or \"Submit\" button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you'd want some of those, but there you go...</p>
";

// post-install message
$lang['post_install']="
<br />Make sure to set the \"Modify Forms\" permissions
on users who will be administering feedback forms. Also, if you'll be emailing form
results, be sure to update the Configuration appropriately.<br />
Please be aware that a feedback form should not be active (e.g., usable by the public) while
you are still editing the form. You should create the form, and place the tag into an active
content page only when you have finished editing. Otherwise, erroneous results could be returned.<br />
Additionally, this version does not support parallel editing of forms. Please take care that
only one admin is editing a given form at a given time.";

$lang['help'] = "<h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create feedback forms (in fact, it's a replacement of the original Feedback Form module), with the added power of database storage. With its companion module Form Browser, you can use it to create simple database applications.</p>
<p>The forms created using the Form Builder may be inserted
into templates and/or content pages. Forms may contain many kinds of inputs, and may have
validation applied to these inputs. The results of these forms may be handled in a variety of ways.</p>

<h3>How Do I Use it?</h3>
<P>Install it, and poke around the menus. Play with it. Try creating forms, and adding them to your content.
If you get stuck, chat with me on the #cms IRC channel, post to the forum, send me email, or, if you're
really desperate, try reading the instructions on the rest of this page.</P>

<h3>How Do I Create a Form</h3>
<p>In the CMS Admin Menu, you should get a new menu item called FormBuilder. Click on this. On the page
that gets shown, there are options (at the bottom of the list of Forms) to Add a New Form or Modify
Configuration.</p>

<h3>Adding a Form to a Page</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module='FormBuilder' form='sample_form'}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page's content if you use a WYSIWYG editor such as TinyMCE, FCKEdit, or HTMLArea. These editors may stealthily
change the quote marks (\") into HTML entities (&amp;quot;), and the forms will not show up. Try using
single quotes (') or editing the HTML directly.</p>

<h3>Working with Forms</h3>
<p>By clicking on a Form's name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you'll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing.</p>
<p>Below this, if you have it enabled, is the \"fast field adder\" pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Form Submission</h4>
<p>When the form is submitted, you can either redirect the user to another page of your site, or you can present the user some message (which can contain any of the user's form entries, or just static text). In this tab, you select which of these approaches you wish to use, and, if you chose redirection, it allows you to pick the page to redirect users to after a successful form submission.</p>
<p>Also on this page, you can specify the labels of various submission buttons (\"Previous\", \"next\", \"submit\"). You can also opt to have some Javascript added to the last page of a form that will prevent multiple submissions (useful on slow servers).</p>
<h4>Form Display Options</h4>
<p>This tab allows for other form customizations, like the symbol to show for required fields.</p>
<h4>Captcha Settings</h4>
<p>If you have installed the Captcha module, this tab lets you configure the Captcha settings for your form.</p>
<h4>Form Template</h4>
<p>This is where you do your customization work of your form's Smarty Template. See the section called Form Template Variables below.</p>
<p>The form should default to a Custom template that documents the Smarty tags available to you.</p>
<p>Unless you're a Smarty expert, you probably don't want to mess around with this. If you are a Smarty expert, this is where you can unleash your magic.</p>
<h4>Submission Template</h4>
<p>If, in the Form Submission tab, you selected 'Display \"Submission Template\", this is where you can create that template. There is a display of which smarty variables are available to you, and a button to generate a sample template.</p>
<p>If you're a Smarty expert, you can do all manner of creative and powerful things here. If you're not a Smarty expert, you might just want to use the default.
</p>

<h3>Adding Fields to your Form</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it's submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it's safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked \"Required\", which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to \"view source\" on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It's really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It's really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Canadian Province. This is a pulldown listing the Canadian Provinces (Contributed by Noel McGran. Thanks!)</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
<li>Time Picker. This is a set of pulldowns allowing the user to select a time (using 12 or 24 hour clock).</li>
<li>File Upload. This is a file upload field.</li>
<li>Link (User Entered). This creates a double input field for getting a link URL and link title.</li>
<li>Text Field (Multiple). This field creates one or more text inputs with add and delete buttons, effectively giving the end user a way of creating variable-length lists.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the \"From\" field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the \"From\" field.</li>
<li>Email Subject Field. This allows users to provide a subject for their email. The email generated when the form gets handled will use this in the \"Subject\" field. This may cause trouble with certain dispositions that want to control the Email Subject, so use it with caution.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Fieldset Start. Combined with Fieldset End, this allows you to group various fields within your form. Use this to start a given grouping.</li>
<li>-Fieldset End. Combined with Fieldset Start, this allows you to group various fields within your form. Use this to end a given grouping.</li>
<li>-Hidden Field. This allows you to embed a hidden field in your form.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you're not using a Custom Template to render your form.</li>
<li>-Static Link. This allows you to put a link to a given page into your form. Optionally, you can have it autopopulate with the page where the form is embedded (useful if you're sending results via email).</li>
<li>-Computed Field. This allows you to embed a computed field in your form. It is not visible to the user until after the form is submitted. It allows you to do simple arithmetic or string concatenation.</li>
<li>-Unique Integer (Serial). This is an integer that increases every time someone hits your form. Your results may not be sequential, but they will increase monotonically.</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<ul><li>*Call a User Defined Tag With the Form Results. This submits all the form results to the User-Defined Tag you specify. The UDT can handle the results however it wants. Values are passed as \$param['field_name'].</li>
<li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these \"Director\" pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email to User-Supplied Address. This puts an input field in the form for the user to populate with an email address. The form results get sent to that address. Beware of Spam abuse! Active the primitive anti-spam features in the FormBuilder configuration screen.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Redirect to Page Based on Pulldown. This allows you to redirect the form to a different site page depending on its value. If you have multiple dispositions, make sure this is used last.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered \"approved,\" and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the \"output\" directory under the
module's installation directory, assuming the web server has permission to write there.</li>
<li>*Save Results to File Based on Pulldown. Like the Flat File disposition, except the value of a pull-down determines which file results get written to.</li>
<li>*Save Results to File(s) Based on Multiple Selections. Like the Flat File disposition, except the value(s) of checkboxes  determines which file(s) results get written to.</li>
<li>*Email to CMS Admin User. Provides a pull-down of CMS Admin users, and directs the results as an email to the selected admin.</li>
<li>*Store Results for FormBrowser Module v.3. Stores the form results in an XML structure as a single database record. This will become the interface to Form Browser in the next release.</li>

</ul></li></li></ul>


<h3>Passing Default Values to Forms</h3>
<p>Calguy added a nice feature, which is that you can pass default field values to your form via the module tag. This allows you to have
the same form in multiple places, but with different default values. It may not work for more exotic field types, but for fields that have
a single value, you can specify like:</p>
<p>{cms_module module='FormBuilder' form='my_form' value_<i>FIELDNAME</i>='default_value'}</p>
<p>This will set the field with <i>FIELDNAME</i> to 'default_value'.</p>
<p>This can be problematic, as sometimes field names are unweildy or contain characters that don't work well with Smarty. So there is an
alternative like this:</p>
<p>{cms_module module='FormBuilder' form='my_form' value_fld<i>NUMBER</i>='default_value'}</p>
<p>That uses field <i>NUMBER</i>, where <i>NUMBER</i> is the internal FormBuilder field id. You might wonder how you know what that id is. Simply go into the FormBuilder configuration tab,
and check \"Show Field IDs\"</p>

<h3>Email and Flat File Templates</h3>
<p>Many disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it's own best guess, which may or may not work out to your liking. You can always click on the \"Create Sample Template\" and then customize the results.</p>
<p>To the right, you'll find a legend which lists all of the variables that are available to you to use in your template. As of version 0.3, variables have two names, one based on the field name, the other based on the field ID. If you use field names that have characters outside of the ASCII 32-126 range, it will be safer to use the ID-based variables.</p>
<p><strong>Note that once you've changed a template, it will no longer automatically add new fields.</strong> For this reason, it's usually best to create your templates as the last step of creating your form.</p>
<p>As of version 0.2.4, you can opt to send any of these emails as HTML email. There should be a checkbox at the top of the template page for this. There is also a \"Create Sample HTML Template\" button over in the legend area. For HTML email, the email body will also provide the default text-only values.</p>

<h3>Configuration</h3>
<p>There are some global configuration options for FormBuilder:</p>
<ul>
<li>Enable fast field add pulldown. This enables the pulldown on the Form Edit page which saves a step in the creation of new fields.</li>
<li>Hide Errors. This is set by default. Unchecking it will cause more detailed errors to be displayed if there are problems when you submit your form.</li>
<li>Require Field Names. Typically, you will want form fields to be named so you can tell which is which. However, in some cases, you might want to have nameless fields. Uncheck this if you want to allow nameless fields.</li>
<li>Unique Field Names. Typically, you will want form fields to have unique names so you can tell which is which. Uncheck this if you want to allow fields to share names.</li>
<li>Use relaxed email validation. This uses a less restrictive regular expression for validating email; e.g., x@y will be allowed, where typically x@y.tld is required.</li>
<li>Show Form Builder Version. Displays the version of FormBuilder you're using in a comment when the form is generated. Typically only useful when debugging.</li>
<li>Enable primitive anti-spam features. When turned on, this allows any given IP address to only generate 10 emails per hour.</li>
<li>Show Field IDs. When turned on, FormBuilder will display field ids when adding or editing a form.</li>
</ul>
<h3>Styling and CSS</h3>
<p>Paul Noone graciously provides us all with a pretty good standard CSS that you can use for forms:</p>
<pre>
	/* Sample FormBuilder CSS base */
	form {margin-top:0}
	form, td, th, li { font-size: 100%}
	form div {margin-bottom:0}
	fieldset div {
		margin-bottom:0.5em;
		margin-left:1em;
	}
	fieldset div div {
		margin-top:0.5em;
		margin-left:1em
	}
	fieldset {
		margin-bottom:1em;
		border:1px solid #F60;
		padding:0.5em
	}
	fieldset label {
		width:auto;
	}
	legend {
		color:#FFF;
		background:#F60;
		font-style:italic;
		font-size:1.2em;
		margin-bottom:0.5em;
		padding:0.2em;
		width:auto;
		border:1px solid #CCC
	}
	textarea {
		margin: 0.5em 0;
		width:98%;
		height: 6em
	}

	/* Apply this class to text/select input fields with shorter labels
		to help alignment */
	.short-label label {float:left; width:10em}
	.short-label fieldset div input,
	.short-label fieldset div select {width:16em}

	/* Pretty up your Captcha image output */
	.captcha {
		margin:0.5em 0;
		width:200px;
		text-align:center
	}
	.captcha img {border:1px solid #F60; margin-bottom:0.5em}
	.captcha input {width:196px; margin-top:0.5em}

	/* Just a bit more room for the Submit button */
	.submit {margin-top:0.5em}
</pre>

<h3>Form Template Variables</h3>
".$lang['template_variable_help']."

<h3>Known Issues</h3>
<ul>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn't matter since the user side is pretty simple.</li>
<li>FileUpload Fields may not work correctly with multipage forms.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you're running CMS 1.1 or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you're missing fields in an email that gets generated, check the disposition field's template, and make sure you're specifying the missing fields. Seems obvious, but it's an easy mistake to make.</li>
<li>Uncheck the \"Hide Errors\" checkbox in the global options, and see what message gets displayed when you submit your form.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is no longer a particularly early version, but it is probably still buggy. While I've done all I can
to make sure no egregious bugs have crept in, I have to admit that during early testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor's nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href=\"http://dev.cmsmadesimple.org\">Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href=\"mailto:sjg@cmsmodules.com\">&lt;sjg@cmsmodules.com&gt;</a>.</li>
<li>Additional discussion of this module may also be found in the <a href=\"http://forum.cmsmadesimple.org\">CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href=\"irc://irc.freenode.net/#cms\">CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
<li>Donations are good motivators, too. Keep in mind that the dollar is weak, and if you are not in the US, your donation gets magnified.</li>
</ul>
<p>Keep in mind that the author has put hundreds and hundreds of hours into the development of this module. Please take the time to read the documentation before sending questions. Either that, or send your questions written on financially negotiable instruments (i.e., checks or cash). Am I sounding like a broken record? Do you kids these days even know what a broken record is? I would say skipping CD, but you might not know what that is either. Like a sample that got stuck on loop? Damn, I am getting old. So is this paragraph. Time to move on, here.</p>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2008, Samuel Goldstein <a href=\"mailto:sjg@cmsmodules.com\">&lt;sjg@cmsmodules.com&gt;</a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=\"http://www.gnu.org/licenses/licenses.html#GPL\">GNU Public License</a>. You must agree to this license before using the module.</p>";

$lang['changelog'] = "
<ul>
<li>Version 0.5.5. 1 Oct 08. Bug fixes. Added new DispositionFromEmailAddressField to replace deficiencies with Email Address 'From' Field type.</li>
<li>Version 0.5.4. 29 Aug 08. Scrapping plans for 0.6. Bug fixes. Ted's new \"Email \"From Address\" Again Field\". Added database indices.</li>
<li>Version 0.5.3. 26 May 08. Bugfixes to previous set of bugfixes. Now ready for major upgrades for 0.6.</li>
<li>Version 0.5.2. 25 May 08. Bugfixes. Release in preparation for substantial reworking for 0.6</li>
<li>Version 0.5.1. 30 April 08. Bugfixes, rewrote some of the File Upload code to prevent white screen of annoyance.</li>
<li>Version 0.5. 19 April 08. Bugfixes, support for FormBrowser fixes and features, disposition type for upcoming FormBrowser version.</li>
<li>Version 0.4.4. 26 Sept 07. Bugfixes for radio button groups, fix for validation of DispositionDeliverToEmailAddressField.</li>
<li>Version 0.4.3. 18 Sept 07. Bugfixes for pulldowns using numbers, option to inline form, fixes for table-layouts provided by Ap Muthu, fix for requirability of Dispositions.</li>
<li>Version 0.4.2. 14 Sept 07. Bugfixes for XML export, RadioButton Group submission, and HTML labels.</li>
<li>Version 0.4.1. Bugfixes for File Disposition Types.</li>
<li>Version 0.4
	<ul>
		<li>Upped minimum CMS version to 1.1</li>
		<li>Numerous Bug fixes; too many to enumerate here</li>
		<li>Massive rejiggering of code to work with CMS MS 1.1 parameter sanitizing regime</li>
		<li>Added field types: \"TextField (Multiple)\" and \"Computed Field\"</li>
		<li>Added dispositions: \"Save Results to File Based on Pulldown\" and \"Save Results to File(s) Based on Multiple Selections\"(Calguy)</li>
		<li>Added neat-o AJAX-y template-copying for Form Templates, gave versions of old table-based templates to soothe the raging masses.</li>
		<li>Added ability to pass default values to form elements from module tag using value_FIELDNAME=\"value\" syntax (Calguy)</li>
		<li>Added option to display field ids in admin (Calguy)</li>
	</ul>
</li>
<li>Version 0.3
   <ul>
      <li>Added Captcha module support.</li>
      <li>Reworked labeling of form elements to be XHTML compliant</li>
      <li>Added Paul Noone's new, improved contact form templates</li>
      <li>Implementation of Email Subject Field</li>
      <li>Added admin-specifiable values to hidden field type, which may contain parsable smarty tags</li>
      <li>Text Area Field now allows specification of rows and cols in the admin, instead of CSS</li>
      <li>Added Drag'n'Drop reordering of form fields.</li>
      <li>Added non-blank field name and unique field name global configuration options and validation</li>
      <li>Implemented templated display of form results upon submission in addition to page redirecting</li>
      <li></li>
   </ul>
</li>
<li>Version 0.2.4 - 09 May 2007
   <p>Big release:<ul>
   <li>Added \"Email Form to User-Supplied Address\" disposition.</li>
   <li>Added \"TimePicker\" field type. Split \"Link\" field into a \"User-supplied Link\" field and a \"Static Link\" field.</li>
   <li>Added HTML email option and auto-templates for all email dispositions.</li>
   <li>Added primitive anti-spam features.</li>
   <li>Added XML-based import and export of forms.</li>
   </ul>
   </p>
</li>
<li>Version 0.2.3
   <p>Add the ability to call a selectable user defined tag upon disposition of the form.</p>
</li>
<li>Version 0.2.2
   <p>Many thanks to Utter Design for sponsoring some changes and bugfixes, which include:
   <ul>
      <li>Added file upload capabilities to the email disposition</li>
      <li>Add PageSetStart and PageSetEnd field types
      <p>These field types allow you to create fieldsets in your form, and organise
      your fields logically for the user.  You can even nest fieldsets, and
      associate a style with them appropriately.  The default template was changed
      to prevent it from wrapping a div around these types of fields.
      </p>
      </li>
      <li>Fixed a problem with DATETIME fields on install
      <p>This solves a problem when on install the response table would sometimes not get created when using adodb lite</li>
      </li>
   </ul>
   </p>
</li>
<li>Version 0.2 - 14 November 2006. Calguy &amp; tsw's bug fixes for field re-ordering and custom templates. Additional bug fixes for field labels.</li>
<li>Version 0.1 - 8 July 2006. Initial Release</li>
</ul>
";


?>
]]></data>
	</file>
	<file>
	  <filename>/lang/ext/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lang/ext/cs_CZ.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Tvůrce formul&aacute;řů';
$lang['field_type_'] = 'Typ pole nebyl nastaven';
$lang['field_type_CatalogerItemsField'] = 'Vyberte jednu (nebo v&iacute;ce) položek modulu Cataloger';
$lang['field_type_FieldsetEnd'] = '-Konec skupiny pol&iacute;ček';
$lang['field_type_FieldsetStart'] = '-Zač&aacute;tek skupiny pol&iacute;ček';
$lang['field_type_TextField'] = 'Textov&eacute; vstupn&iacute; pole';
$lang['field_type_TextFieldExpandable'] = 'Textov&eacute; vstupn&iacute; pole (v&iacute;cen&aacute;sobn&eacute;)';
$lang['field_type_TextAreaField'] = 'Textov&yacute; r&aacute;meček';
$lang['field_type_CheckboxField'] = 'Za&scaron;krt&aacute;vac&iacute; pol&iacute;čko';
$lang['field_type_CheckboxGroupField'] = 'Skupina za&scaron;krt&aacute;vac&iacute;ch pol&iacute;ček';
$lang['field_type_PulldownField'] = 'Rozbalovac&iacute; nab&iacute;dka';
$lang['field_type_MultiselectField'] = 'V&yacute;běr v&iacute;ce možnost&iacute;';
$lang['field_type_StatePickerField'] = 'V&yacute;běr st&aacute;tů USA';
$lang['field_type_ProvincePickerField'] = 'V&yacute;běr kanadsk&yacute;ch provinci&iacute;';
$lang['field_type_CountryPickerField'] = 'V&yacute;běr st&aacute;tů';
$lang['field_type_DatePickerField'] = 'V&yacute;běr data';
$lang['field_type_TimePickerField'] = 'V&yacute;běr času';
$lang['field_type_RadioGroupField'] = 'Skupina přep&iacute;načů';
$lang['field_type_DispositionDirector'] = '*Email Results Based on Pulldown';
$lang['field_type_DispositionFileDirector'] = '*Save Results to File Based on Pulldown';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Save Results to File(s) Based on Multiple Selections';
$lang['field_type_DispositionPageRedirector'] = '*Redirect to Page Based on Pulldown';
$lang['field_type_DispositionEmail'] = '*Email Results to set Address(es)';
$lang['field_type_DispositionEmailConfirmation'] = '*Validate-via-Email Address';
$lang['field_type_DispositionFromEmailAddressField'] = '*Email &quot;From Address&quot; Field, and send copy';
$lang['field_type_DispositionFile'] = '*Zapsat v&yacute;sledky do textov&eacute;ho souboru';
$lang['field_type_DispositionDatabase'] = '*Uložit v&yacute;sledky do datab&aacute;ze';
$lang['field_type_DispositionFormBrowser'] = '*Uložit v&yacute;sledky pro modul Prohl&iacute;žeč formul&aacute;řů v.3';
$lang['field_type_DispositionUserTag'] = '*Call A User Defined Tag With the Form Results';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Email to User-Supplied Email Address';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Email to CMS Admin User';
$lang['field_type_PageBreakField'] = '-Page Break';
$lang['field_type_FileUploadField'] = 'Nahr&aacute;n&iacute; souboru';
$lang['field_type_FromEmailAddressField'] = 'Email &quot;From Address&quot; Field';
$lang['field_type_FromEmailAddressAgainField'] = 'Email &quot;From Address&quot; Again Field';
$lang['field_type_FromEmailNameField'] = 'Email &quot;From Name&quot; Field';
$lang['field_type_FromEmailSubjectField'] = 'Email &quot;Subject&quot; Field';
$lang['field_type_StaticTextField'] = '-Statick&yacute; text (Static Text)';
$lang['field_type_SystemLinkField'] = '-Statick&yacute; odkaz (Static Link)';
$lang['field_type_LinkField'] = 'Odkaz (vložen&yacute; uživatelem) [Link (User-entered)]';
$lang['field_type_HiddenField'] = '-Schovan&eacute; pole (Hidden Field)';
$lang['field_type_ComputedField'] = '-Vypoč&iacute;tan&eacute; pole (Computed Field)';
$lang['field_type_UniqueIntegerField'] = '-Unique Integer (Serial)';
$lang['validation_none'] = 'Bez oveřen&iacute; platnosti';
$lang['validation_numeric'] = 'Č&iacute;seln&aacute; hodnota (Numeric)';
$lang['validation_integer'] = 'Celoč&iacute;seln&aacute; hodnota (Integer)';
$lang['validation_email_address'] = 'Emailov&aacute; adresa (Email Address)';
$lang['validation_usphone'] = 'Telefon&iacute; č&iacute;slo (US)';
$lang['validation_must_check'] = 'Mus&iacute; b&yacute;t za&scaron;krtnuto (Must Be Checked)';
$lang['validation_regex_match'] = 'Odpov&iacute;d&aacute; regul&aacute;rn&iacute;mu v&yacute;razu';
$lang['validation_regex_nomatch'] = 'Doesn&#039;t match Regular Expression';
$lang['required_field_missing'] = 'Ve vyžadovan&eacute;m poli nebyla vložena hodnota';
$lang['please_enter_a_value'] = 'Pros&iacute;m vyplňte pole &quot;%s&quot;';
$lang['please_enter_a_number'] = 'Pros&iacute;m vyplňte č&iacute;selnou hodnotu v poli &quot;%s&quot;';
$lang['please_enter_valid'] = 'Pros&iacute;m vyplňte platn&yacute; &uacute;daj v poli &quot;%s&quot;';
$lang['please_enter_an_integer'] = 'Pros&iacute;m vyplňte celoč&iacute;selnou hodnotu v poli &quot;%s&quot;';
$lang['please_enter_an_email'] = 'Pros&iacute;m vyplňte platnou emailovou adresu v poli &quot;%s&quot;';
$lang['email_address_does_not_match'] = 'E-mailov&aacute; adresa neodpov&iacute;d&aacute; hodnotě v poli &quot;%s&quot;';
$lang['please_enter_a_phone'] = 'Pros&iacute;m vložte platn&eacute; telefon&iacute; č&iacute;slo do pole &quot;%s&quot;';
$lang['not_valid_email'] = '&quot;%s&quot; nevypad&aacute; jako platn&aacute; emailov&aacute; adresa!';
$lang['please_enter_no_longer'] = 'Pros&iacute;m vložte hodnotu krat&scaron;&iacute; než %s znaků';
$lang['title_list_delimiter'] = 'Znak, kter&yacute; bude použit jako oddělovač ve v&yacute;sledc&iacute;ch, kter&eacute; vracej&iacute; v&iacute;ce než 1 hodnotu';
$lang['you_need_permission'] = 'You need the &quot;%s&quot; permission to perform that operation.';
$lang['lackpermission'] = 'Sorry! You don&#039;t have adequate privileges to access this section.';
$lang['field_order_updated'] = 'Pořad&iacute; pol&iacute; aktualizov&aacute;no.';
$lang['form_deleted'] = 'Formul&aacute;ř smaz&aacute;n.';
$lang['field_deleted'] = 'Pole smaz&aacute;no.';
$lang['configuration_updated'] = 'Konfigurace aktualizov&aacute;na.';
$lang['you_must_check'] = 'Pro pokračov&aacute;n&iacute; mus&iacute;te za&scaron;krtnout &quot;%s&quot;.';
$lang['must_specify_one_destination'] = 'Mus&iacute;te určit alespoň jednu adresu!';
$lang['are_you_sure_delete_form'] = 'Jste si jist vymaz&aacute;n&iacute;m formul&aacute;ře %s?';
$lang['are_you_sure_delete_field'] = 'Jste si jist smaz&aacute;n&iacute;m pole %s?';
$lang['notice_select_type'] = 'Pokročil&eacute; možnosti nejsou dostupn&eacute;, dokud nen&iacute; nastaven typ pole.';
$lang['field_name_in_use'] = 'The field name &quot;%s&quot; is already in use. Please use unique field names, or disable unique field names in the Form Builder configuration.';
$lang['field_no_name'] = 'Pole musej&iacute; b&yacute;t pojmenov&aacute;na, pokud toto nevypnete v nastaven&iacute; Tvůrce formul&aacute;řů.';
$lang['anonymous'] = 'Anonymn&iacute;';
$lang['abbreviation_length'] = 'D&eacute;lka: %s';
$lang['boxes'] = '%s boxes';
$lang['options'] = '%s možnost&iacute;';
$lang['text_length'] = '%s znaků.';
$lang['order'] = 'Pořad&iacute;';
$lang['unspecified'] = '[neurčeno]';
$lang['added'] = 'přid&aacute;no';
$lang['updated'] = 'aktualizov&aacute;no';
$lang['sort_options'] = 'Tř&iacute;dit vlastnosti na v&yacute;stupu';
$lang['select_one'] = 'Select One';
$lang['select_type'] = 'Select Type';
$lang['to'] = 'Pro';
$lang['yes'] = 'Ano';
$lang['no'] = 'Ne';
$lang['recipients'] = 'př&iacute;jemců';
$lang['file_count'] = '%s možn&yacute;ch souborů';
$lang['destination_count'] = '%s destinations';
$lang['save'] = 'Uložit';
$lang['add'] = 'Přidat';
$lang['update'] = 'Aktualizovat';
$lang['save_and_continue'] = 'Uložit a pokračovat v &uacute;prav&aacute;ch';
$lang['information'] = 'Informace';
$lang['automatic'] = 'Automatick&eacute;';
$lang['forms'] = 'Formul&aacute;ře';
$lang['form'] = 'Formul&aacute;ř %s';
$lang['configuration'] = 'Nastaven&iacute;';
$lang['field_requirement_updated'] = 'Vyžadovanost pol&iacute;čka byla upravena.';
$lang['maximum_size'] = 'Max. velikost';
$lang['permitted_extensions'] = 'Roz&scaron;&iacute;řen&iacute;';
$lang['permitted_filetypes'] = 'Povolen&eacute; typy souborů';
$lang['file_too_large'] = 'Nahran&yacute; soubor je př&iacute;li&scaron; velik&yacute;. Povolen&aacute; velikost je:';
$lang['illegal_file_type'] = 'Tento typ souboru nemůže b&yacute;t nahr&aacute;n. Pros&iacute;m zkontrolujte, že soubor m&aacute; spr&aacute;vnou př&iacute;ponu.';
$lang['upload'] = 'Nahr&aacute;t';
$lang['form_imported'] = 'Formul&aacute;ř byl importov&aacute;n.';
$lang['form_import_failed'] = 'Import formul&aacute;ře selhal! XML soubor nen&iacute; ve spr&aacute;vn&eacute;m tvaru.';
$lang['rows'] = '%s ř&aacute;dků';
$lang['cols'] = '%s sloupců';
$lang['12_hour'] = '12 hodinov&eacute; poč&iacute;t&aacute;n&iacute; času';
$lang['24_hour'] = '24 hodinov&eacute; poč&iacute;t&aacute;n&iacute; času';
$lang['hour'] = 'Hodina';
$lang['min'] = 'Minuta';
$lang['merid'] = 'Poledn&iacute;k';
$lang['date_range'] = 'Rozsah: %s - %s';
$lang['thanks'] = 'Děkujeme! V&aacute;&scaron; př&iacute;spěvek byl zaznamen&aacute;n.';
$lang['edit'] = 'Upravit';
$lang['delete'] = 'Smazat';
$lang['day'] = 'Den';
$lang['mon'] = 'Měs&iacute;c';
$lang['year'] = 'Rok';
$lang['none'] = '(nic)';
$lang['uninstalled'] = 'Modul odinstalov&aacute;n.';
$lang['installed'] = 'Modul verze %s byl nainstalov&aacute;n.';
$lang['upgraded'] = 'Modul byl upgradov&aacute;n na verzi %s.';
$lang['button_previous'] = 'Zpět...';
$lang['button_submit'] = 'Uložit formul&aacute;ř';
$lang['button_continue'] = 'Pokračovat...';
$lang['value_checked'] = 'Za&scaron;krtnuto';
$lang['value_unchecked'] = 'Neza&scaron;krtnuto';
$lang['tab_main'] = 'Hlavn&iacute;';
$lang['tab_symbol'] = 'Nastaven&iacute; zobrazen&iacute; formul&aacute;ře';
$lang['tab_submit'] = 'Ukl&aacute;d&aacute;n&iacute; formul&aacute;ře';
$lang['tab_captcha'] = 'Nastaven&iacute; Captcha';
$lang['tab_advanced'] = 'Pokročil&aacute; nastaven&iacute;';
$lang['tab_templatelayout'] = '&Scaron;ablona formul&aacute;ře';
$lang['tab_submissiontemplate'] = '&Scaron;ablona zpr&aacute;vy po vložen&iacute; dat';
$lang['canuse_smarty'] = '<em>V tomto poli lze použ&iacute;t proměnn&eacute; Smarty.<em>';
$lang['add_options'] = 'Přidat v&iacute;ce možnost&iacute;';
$lang['delete_options'] = 'Smazat označen&eacute; možnosti';
$lang['add_checkboxes'] = 'Přidat v&iacute;ce za&scaron;krt&aacute;vac&iacute;ch pol&iacute;ček';
$lang['delete_checkboxes'] = 'Smazat označen&aacute; za&scaron;krt&aacute;vac&iacute; pol&iacute;čka';
$lang['add_address'] = 'Přidat dal&scaron;&iacute; adresu';
$lang['delete_address'] = 'Smazat označen&eacute; adresy';
$lang['add_destination'] = 'Přidat dal&scaron;&iacute; c&iacute;l';
$lang['delete_destination'] = 'Smazat označen&eacute; c&iacute;le';
$lang['suspected_spam'] = 'Bylo vytvořeno př&iacute;li&scaron; mnoho e-mailů pro Va&scaron;i IP adresu. Antispam zabr&aacute;nil doručen&iacute;.';
$lang['suspected_spam_log'] = 'Suspected spam from IP %s stopped.';
$lang['reorder'] = 'Seřadit pol&iacute;čka';
$lang['cancel'] = 'Strono';
$lang['value_set'] = 'Sada hodnot: %s';
$lang['help_cataloger_attribute_fields'] = 'Below is a list of the attributes available from the Cataloger module.<br/>You can optionally specify valid ranges, values, or numerous values to be used in filtering the list of items that is displayed to the user.<br/>
<br/>
<strong>Ranges:</strong><br/>
Ranges can be specified by signifying a minimum and maximum value using this syntax: &quot;range: minvalue to maxvalue&quot;<br/>
<br/>
<strong>Multiple Values:</strong><br/>
To specify multiple values for an attribute use the syntax &quot;multi: value1|value2|value3&quot;<br/>
<br/>
<strong>Values from hidden fields</strong><br/>
To specify a value from a hidden field use the syntax {$fld_id}<br/>
<br/>';
$lang['help_name_regex'] = 'Regul&aacute;rn&iacute; v&yacute;raz, umožňuj&iacute;c&iacute; filtrov&aacute;n&iacute; pol&iacute;ček modulu Cataloger podle jm&eacute;na';
$lang['help_field_height'] = 'V&yacute;&scaron;ka pol&iacute;čka typu select';
$lang['title_name_regex'] = 'Cataloger Item Name Regular Expression';
$lang['title_field_height'] = 'V&yacute;&scaron;ka pol&iacute;čka';
$lang['title_file_path'] = 'Adres&aacute;ř, kam budou ukl&aacute;d&aacute;ny oubory';
$lang['title_udt_name'] = 'Uživatelem definovan&yacute; tag';
$lang['title_uploads_destpage'] = 'Page to return to with uploads link';
$lang['title_uploadmodule_summary'] = 'Submitted with formbuilder';
$lang['title_uploads_category'] = 'Uploads category';
$lang['title_sendto_uploads'] = 'Send this file to the uploads module';
$lang['title_legend'] = 'Legend';
$lang['title_maximum_length'] = 'Maximum Length';
$lang['title_checkbox_label'] = 'Checkbox label';
$lang['title_radio_label'] = 'Radio Button label';
$lang['title_checked_value'] = 'Value when checked';
$lang['title_unchecked_value'] = 'Value when not checked.';
$lang['title_checkbox_details'] = 'Checkbox Group Details';
$lang['title_delete'] = 'Delete?';
$lang['title_select_one_message'] = '&quot;Select One&quot; Text';
$lang['title_selection_value'] = 'Selection Value';
$lang['title_selection_displayname'] = 'Selection Display Name';
$lang['title_selection_subject'] = 'Selection Subject';
$lang['title_select_default_country'] = 'Default Selection';
$lang['title_select_default_state'] = 'Default Selection';
$lang['title_select_default_province'] = 'Default Selection';
$lang['title_option_name'] = 'Option Name';
$lang['title_option_value'] = 'Value Submitted';
$lang['title_pulldown_details'] = 'Pulldown Options';
$lang['title_multiselect_details'] = 'Multiselect Options';
$lang['title_destination_address'] = 'Destination Email Address';
$lang['title_destination_filename'] = 'Destination File Name';
$lang['title_email_from_name'] = '&quot;From name&quot; for email';
$lang['title_relaxed_email_regex'] = 'Use relaxed email validation';
$lang['title_relaxed_regex_long'] = 'Use relaxed email address validation (e.g., allow &quot;x@y&quot; instead of requiring &quot;x@y.tld&quot;)';
$lang['title_email_from_address'] = '&quot;From address&quot; for email';
$lang['title_email_encoding'] = 'Email character set encoding';
$lang['title_director_details'] = 'Pulldown-based Emailer Details';
$lang['title_file_name'] = 'File Name';
$lang['title_email_subject'] = 'Email Subject Line';
$lang['title_form_name'] = 'Form Name';
$lang['title_form_status'] = 'Form Status';
$lang['title_ready_for_deployment'] = 'Ready for Deployment';
$lang['title_not_ready1'] = 'Not Ready';
$lang['title_redirect_page'] = 'Page to redirect to after form submission';
$lang['title_not_ready2'] = 'Please add a field to the form so that the user&#039;s input gets handled. You can';
$lang['title_not_ready_link'] = 'use this shortcut';
$lang['title_form_alias'] = 'Form Alias';
$lang['title_form_fields'] = 'Form Fields';
$lang['title_field_id'] = 'Field Id';
$lang['title_show_fieldaliases'] = 'Show Field Aliases';
$lang['title_show_fieldaliases_long'] = 'Clicking this will display field aliases when adding or editing a form';
$lang['title_field_name'] = 'Field Name';
$lang['title_field_alias'] = 'Field Alias';
$lang['title_radiogroup_details'] = 'Radio Button Group Details';
$lang['title_field_type'] = 'Field Type';
$lang['title_not_ready3'] = 'to create a form handling field.';
$lang['title_add_new_form'] = 'Add New Form';
$lang['title_show_version'] = 'Show Form Builder Version?';
$lang['title_show_version_long'] = 'This will embed your installed version number of Form Builder module in a comment, to aid in debugging';
$lang['title_add_new_field'] = 'Add New Field';
$lang['title_form_submit_button'] = 'Form Submit Button Text';
$lang['title_submit_button_safety'] = 'Add Javascript to final Submit Button that will help prevent multiple submissions?';
$lang['title_submit_button_safety_help'] = 'Add safety script';
$lang['title_form_next_button'] = 'Form &quot;Next&quot; Button Text (used for multipage forms)';
$lang['title_form_prev_button'] = 'Form &quot;Previous&quot; Button Text (used for multipage forms)';
$lang['title_field_validation'] = 'Field Validation';
$lang['title_field_to_validate'] = 'Field to Validate';
$lang['title_form_css_class'] = 'CSS Class for this form';
$lang['title_field_css_class'] = 'CSS Class for this field';
$lang['title_form_required_symbol'] = 'Symbol to mark required Fields';
$lang['title_field_required'] = 'Required';
$lang['title_field_required_long'] = 'Require a response for this Field';
$lang['title_hide_label'] = 'Hide Label';
$lang['title_hide_label_long'] = 'Hide this field&#039;s name on Form';
$lang['title_text'] = 'Static text to display';
$lang['title_field_regex'] = 'Validation Regex';
$lang['title_lines_to_show'] = 'Number of Lines to display';
$lang['no_default'] = 'No Default';
$lang['redirect_after_approval'] = 'Page to redirect after approval';
$lang['title_regex_help'] = 'This regular expression will only be used if &quot;validation type&quot; is set to a regex-related option. Include a full Perl-style regex, including the start/stop slashes and flags (e.g., &quot;/image\.(\d+)/i&quot;)';
$lang['title_field_required_abbrev'] = 'Req&#039;d';
$lang['title_hide_errors'] = 'Hide Errors';
$lang['title_form_displaytype'] = 'Form Display Type';
$lang['title_hide_errors_long'] = 'Prevent debug / error messages from being seen by users.';
$lang['title_email_template'] = 'Email Template';
$lang['title_maximum_size'] = 'Maximum upload file size (kilobytes)';
$lang['title_maximum_size_long'] = 'This limitation is in addition to any limits set by the php or web server configuration';
$lang['title_permitted_extensions'] = 'Permitted Extensions';
$lang['title_permitted_extensions_long'] = 'Enter a comma-separated list, excluding the dot (e.g., &quot;jpg,gif,jpeg&quot;). Spaces will be ignored. Leaving this blank means there will be no restrictions.';
$lang['title_show_limitations'] = 'Display restrictions?';
$lang['title_show_limitations_long'] = 'Display any size and extension restrictions with the upload field?';
$lang['title_form_template'] = 'Template to use to Display Form';
$lang['title_page_x_of_y'] = 'Page %s of %s';
$lang['title_no_advanced_options'] = 'Field has no advanced options.';
$lang['title_form_unspecified'] = 'Text to return for unspecified field values';
$lang['title_enable_fastadd_long'] = 'Enable fast field adding pulldown for forms?';
$lang['title_enable_fastadd'] = 'Enable fast field add pulldown?';
$lang['title_fastadd'] = 'Fast field adder';
$lang['title_enable_antispam_long'] = 'Clicking this will only allow 10 emails to be triggered from a given IP address (per hour).';
$lang['title_enable_antispam'] = 'Enable primitive anti-spam features?';
$lang['title_show_fieldids'] = 'Show Field IDs';
$lang['title_show_fieldids_long'] = 'Clicking this will allow displaying field ids when adding or editing a form';
$lang['title_xml_to_upload'] = 'Upload form from XML file';
$lang['title_xml_upload_formname'] = 'Use this form name';
$lang['title_import_legend'] = 'XML Form Import';
$lang['title_xml_upload_formalias'] = 'Use this form alias';
$lang['title_html_email'] = 'Generate HTML email?';
$lang['title_link_autopopulate'] = 'Automatically populate?';
$lang['title_link_autopopulate_help'] = 'Automatically populate with the URL of the page containing the form? (this overrides site page link option below)';
$lang['title_default_link'] = 'Default link URL';
$lang['title_default_link_title'] = 'Default link text';
$lang['title_link_to_sitepage'] = 'Link to site page';
$lang['title_captcha_not_installed'] = 'You can use <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a> to protect form submissions if you install the Captcha module. For more information, <a href="http://dev.cmsmadesimple.org/projects/captcha/">check the Captcha project</a>.';
$lang['title_use_captcha'] = 'Use Captcha to protect form submissions?';
$lang['title_use_captcha_help'] = 'Check here to protect your form with a <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a>.';
$lang['title_user_captcha'] = 'Please confirm that you are not a script by entering the letters from the image.';
$lang['title_user_captcha_error'] = 'Failed text for Captcha';
$lang['wrong_captcha'] = 'Opi&scaron;te spr&aacute;vně znaky z obr&aacute;zku.';
$lang['title_title_user_captcha'] = 'Help text for Captcha';
$lang['title_dont_submit_unchecked'] = 'Don&#039;t submit values for unchecked boxes';
$lang['title_dont_submit_unchecked_help'] = 'Check this if you only want checked boxes to return values.';
$lang['link_label'] = 'Link Label';
$lang['link_destination'] = 'Link Destination URL';
$lang['title_default_set'] = 'Checked by Default?';
$lang['title_24_hour'] = 'Use 24-hour clock?';
$lang['title_before_noon'] = 'AM';
$lang['title_after_noon'] = 'PM';
$lang['title_smarty_eval'] = 'Process smarty tags within field?';
$lang['title_textarea_rows'] = 'Rows (note: this may be overridden by CSS)';
$lang['title_textarea_cols'] = 'Columns (note: this may be overridden by CSS)';
$lang['title_form_main'] = 'Main Form Details';
$lang['title_show_username'] = 'Display User&#039;s login name?';
$lang['title_show_userfirstname'] = 'Display User&#039;s first name?';
$lang['title_show_userlastname'] = 'Display User&#039;s last name?';
$lang['title_restrict_to_group'] = 'Restrict user list to users in specified group';
$lang['restricted_to_group'] = 'Only in group %s';
$lang['title_show_to_user'] = 'Display to user?';
$lang['help_leaveempty'] = 'This field may be left empty';
$lang['help_variables_for_template'] = 'Variables For Template';
$lang['help_variables_for_computation'] = 'Variables Available';
$lang['help_php_variable_name'] = 'PHP variable';
$lang['help_submission_date'] = 'Date of Submission';
$lang['help_server_name'] = 'Your server';
$lang['help_sub_source_ip'] = 'IP address of person using form';
$lang['help_sub_url'] = 'URL of page containing form';
$lang['help_fb_version'] = 'FormBuilder version';
$lang['help_tab'] = 'Tab Character';
$lang['help_other_fields'] = 'Alternate field names can be used interchangeably (especially useful if Smarty is choking on characters outside of ASCII 32-126). <br />Other fields will be available as you add them to the form.';
$lang['help_array_fields'] = 'Fields that have multiple values may also be accessed via the smarty value of $fieldname_array or $fld_#_array.';
$lang['help_date_format'] = 'See <a href="http://www.php.net/manual/en/function.date.php" target=_NEW>the PHP Manual</a> for formatting help.';
$lang['help_variable_name'] = 'Variable';
$lang['help_form_field'] = 'Field Represented';
$lang['link_back_to_form'] = '&laquo; Back to Form';
$lang['title_create_sample_template'] = 'Create Sample Template';
$lang['title_create_sample_html_template'] = 'Create Sample HTML Template';
$lang['title_create_sample_header_template'] = 'Create Sample Header Template';
$lang['title_create_sample_header'] = 'Create Sample Header';
$lang['help_tab_symbol'] = 'a tab character';
$lang['title_file_template'] = 'Template for one line of output file';
$lang['title_file_header'] = 'Template for the header of output file';
$lang['title_confirmation_url'] = 'URL to click for form confirmation';
$lang['title_value'] = 'Value (see Advanced Tab if you use Smarty tags)';
$lang['title_date_format'] = 'Date Format (standard <a href="http://www.php.net/manual/en/function.date.php">PHP Date Formats</a>)';
$lang['title_use_wysiwyg'] = 'Use WYSIWYG editor for text Area (Admin side only)?';
$lang['title_submit_actions'] = 'Form Submission Behavior';
$lang['title_submit_labels'] = 'Submission Button Labels';
$lang['title_sortable_field'] = 'Sortable Field #%s';
$lang['title_submit_help'] = 'This page lets you customize Form Submission. It doesn&#039;t determine what the Form Builder does with the submitted data. You can set that up by adding &quot;Disposition&quot; fields to your form.';
$lang['title_start_year'] = 'Year range start';
$lang['title_end_year'] = 'Year range end';
$lang['title_default_year'] = 'Default Year';
$lang['title_default_year_help'] = '(Set to -1 for default year to be the current year)';
$lang['title_submit_action'] = 'After form is submitted';
$lang['title_submit_response'] = 'Response to display';
$lang['display_text'] = 'Display &quot;Submission Template&quot;';
$lang['redirect_to_page'] = 'Redirect to site page';
$lang['title_submit_response_help'] = 'This template is for display to the user after the form is submitted. This template does not effect emails generated or other form dispositions -- you set those templates (where appropriate) in the &quot;advanced&quot; tab for those disposition fields.';
$lang['title_destination_page'] = 'Destination Page';
$lang['title_require_fieldnames'] = 'Require Fieldnames';
$lang['title_require_fieldnames_long'] = 'Require fields to have a name?';
$lang['title_unique_fieldnames'] = 'Require Unique Fieldnames';
$lang['title_unique_fieldnames_long'] = 'Require fields to have unique names?';
$lang['title_reorder_form'] = 'Reorder Fields';
$lang['title_load_template'] = 'Load template';
$lang['title_add_button_text'] = 'Add Button text';
$lang['title_del_button_text'] = 'Delete Button text';
$lang['title_string_or_number_eval'] = 'Interpret variables as being numbers or strings';
$lang['title_order'] = 'Interpretation Order';
$lang['title_order_help'] = 'If more than one Computed Field exists, they will be computed from lowest order number to highest order number';
$lang['title_compute_value'] = 'Value to compute';
$lang['title_string'] = 'String';
$lang['title_numeric'] = 'Numeric';
$lang['title_inline_form'] = 'Display form inline?';
$lang['title_inline_form_help'] = 'Inline means any form followup replaces the {cms_module} tag, non-inline replaces the {content} tag.';
$lang['title_field_default_value'] = 'Default value for field';
$lang['title_clear_default'] = 'Clear default on click?';
$lang['title_clear_default_help'] = 'Check this to clear the default value when the user clicks this field. Since this uses a javascript string compare, it will fail if you put single quotes in your default text. Other un-javascript-friendly characters may also cause it to fail.';
$lang['title_remove_file_from_server'] = 'Delete uploaded file from server after processing (email dispositions)';
$lang['title_field_javascript'] = 'Javascript for field';
$lang['title_field_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;';
$lang['title_submit_javascript'] = 'Form Submission Javascript';
$lang['title_submit_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;.<br />This will probably not work well if you use the &quot;safety script&quot; option above.';
$lang['email_from_addr_help'] = 'Do not just pick a random address here -- many ISPs will<br />not deliver the mail if you are using a different domain name than your actual<br />host name (i.e., use something like name@%s)';
$lang['title_switch_advanced'] = 'Need more field types? ';
$lang['title_switch_basic'] = 'Too many confusing field types? ';
$lang['title_switch_advanced_link'] = 'Switch to Advanced Mode';
$lang['title_switch_basic_link'] = 'Switch to Simple Mode';
$lang['title_file_root'] = 'Directory to save file in';
$lang['title_file_root_help'] = 'This needs to be a directory that your web server has permissions to write in.<br />Chmod it 777 if you have problems/doubts.<br />Also, check to see that you do not have PHP directory restrictions.';
$lang['title_newline_replacement'] = 'Newline/Carriage Return replacement character';
$lang['title_newline_replacement_help'] = 'Leave blank to allow newlines and carriage returns in output';
$lang['title_send_usercopy'] = 'Send User a Copy of Submission?';
$lang['title_send_usercopy_label'] = 'Label for Checkbox (if user choice)';
$lang['title_send_me_a_copy'] = 'Send me a copy of form';
$lang['title_allow_subject_override'] = 'Allow subject to be overridden?';
$lang['title_allow_subject_override_long'] = 'Allow &#039;Email &quot;Subject&quot; Fields&#039; to override the subject specified in the pulldown.';
$lang['option_never'] = 'Never';
$lang['option_user_choice'] = 'Give user a choice (checkbox)';
$lang['option_always'] = 'Always';
$lang['error_cataloger_module_not_available'] = '<strong>Cataloger module does not seem to be installed/active.</strong>';
$lang['warning'] = 'WARNING!';
$lang['default_template'] = 'Default Template';
$lang['table_left_template'] = 'Table Template, Titles on left';
$lang['table_top_template'] = 'Table Template, Title on top';
$lang['form_template_name'] = 'Template from %s';
$lang['template_are_you_sure'] = 'Are you sure you want to overwrite your template with the selected template? (Even if you say OK, you will still need to save the change)';
$lang['title_bad_function'] = 'Error when computing &quot;%s&quot;.';
$lang['no_referrer_info'] = 'No HTTP_REFERER info available (probably due to use of User Email Validation)';
$lang['validation_param_error'] = 'Validation Parameter Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_response_error'] = 'Validation Repsonse Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_no_field_error'] = 'Validation Repsonse Error. No email validation field in this form!';
$lang['upgrade03to04'] = 'Form Template was updated automatically as part of the version 0.3 to version 0.4 upgrade. You may need to make some fixes. If you&#039;re using the default form, simply replace this template with &quot;default&quot; using the pulldown above.';
$lang['admindesc'] = 'Add, edit and manage interactive Forms';
$lang['operators_help'] = 'If you use String evaluation, the only operation available is concatenation (+), while if you use Number evaluation you have basic, very simple math (, +, -, *, /, ).';
$lang['date_january'] = 'ledna';
$lang['date_february'] = '&uacute;nora';
$lang['date_march'] = 'března';
$lang['date_april'] = 'dubna';
$lang['date_may'] = 'května';
$lang['date_june'] = 'června';
$lang['date_july'] = 'července';
$lang['date_august'] = 'srpna';
$lang['date_september'] = 'z&aacute;ř&iacute;';
$lang['date_october'] = 'ř&iacute;jna';
$lang['date_november'] = 'listopadu';
$lang['date_december'] = 'prosince';
$lang['submission_error'] = 'Sorry! There was an error handling your form submission.';
$lang['submit_error'] = 'FormBuilder submit error: %s';
$lang['uploads_error'] = 'Error committing file to the uploads module: %s';
$lang['nouploads_error'] = 'Could not find the uploads module';
$lang['upload_attach_error'] = 'Upload/Attachment error on file %s (tmp_name: %s, of type %s)';
$lang['submission_error_file_lock'] = 'Error. Unable to obtain lock for file.';
$lang['unchecked_by_default'] = 'Default: unchecked';
$lang['checked_by_default'] = 'Default: checked';
$lang['email_default_template'] = 'FormBuilder Submission';
$lang['email_template_not_set'] = '<br/>Email Template not yet set!';
$lang['missing_cms_mailer'] = 'FormBuilder: Cannot find required module CMSMailer!';
$lang['user_approved_submission'] = 'User approved submission %s from %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Event triggered when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Event triggered if there is an error when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Event triggered when a FormBuilder form is displayed';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Event triggered when a FormBuilder form is submitted.</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>value_<name></em> - Supply a default value to a field with the specified name.</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Event triggered if there is an error when a FormBuilder form is submitted</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>error</em> - A list of all known errors (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Event triggered when a FormBuilder form is displayed</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
</ul> ';
$lang['formbuilder_params_response_id'] = 'Response ID. Used by FormBrowser';
$lang['formbuilder_params_passed_from_tag'] = 'Default field values; see module help';
$lang['formbuilder_params_field_id'] = 'Field ID for internal operations';
$lang['formbuilder_params_form_name'] = 'Form Name';
$lang['formbuilder_params_form_id'] = 'Form ID for internal operations';
$lang['formbuilder_params_general'] = 'General parameters for internal operations';
$lang['template_variable_help'] = '<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>
';
$lang['post_install'] = '<p>Make sure to set the &quot;Modify Forms&quot; permissions
on users who will be administering feedback forms. Also, if you&#039;ll be emailing form
results, be sure to update the Configuration appropriately.</p>
<p>Please be aware that a feedback form should not be active (e.g., usable by the public) while
you are still editing the form. You should create the form, and place the tag into an active
content page only when you have finished editing. Otherwise, erroneous results could be returned.</p>
<p>Additionally, this version does not support parallel editing of forms. Please take care that
only one admin is editing a given form at a given time.</p>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create feedback forms (in fact, it&#039;s a replacement of the original Feedback Form module), with the added power of database storage. With its companion module Form Browser, you can use it to create simple database applications.</p>
<p>The forms created using the Form Builder may be inserted
into templates and/or content pages. Forms may contain many kinds of inputs, and may have
validation applied to these inputs. The results of these forms may be handled in a variety of ways.</p>

<h3>How Do I Use it?</h3>
<P>Install it, and poke around the menus. Play with it. Try creating forms, and adding them to your content.
If you get stuck, chat with me on the #cms IRC channel, post to the forum, send me email, or, if you&#039;re
really desperate, read the rest of this page.</P>

<h3>How Do I Create a Form</h3>
<p>In the CMS Admin Menu, you should get a new menu item called FormBuilder. Click on this. On the page
that gets shown, there are options (at the bottom of the list of Forms) to Add a New Form or Modify
Configuration.</p>

<h3>Adding a Form to a Page</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module=&#039;FormBuilder&#039; form=&#039;sample_form&#039;}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page&#039;s content if you use a WYSIWYG editor such as TinyMCE, FCKEdit, or HTMLArea. These editors may stealthily
change the quote marks (&quot;) into HTML entities (&amp;quot;), and the forms will not show up. Try using
single quotes (&#039;) or editing the HTML directly.</p>

<h3>Working with Forms</h3>
<p>By clicking on a Form&#039;s name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you&#039;ll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing.</p>
<p>Below this, if you have it enabled, is the &quot;fast field adder&quot; pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Form Submission</h4>
<p>When the form is submitted, you can either redirect the user to another page of your site, or you can present the user some message (which can contain any of the user&#039;s form entries, or just static text). In this tab, you select which of these approaches you wish to use, and, if you chose redirection, it allows you to pick the page to redirect users to after a successful form submission.</p>
<p>Also on this page, you can specify the labels of various submission buttons (&quot;Previous&quot;, &quot;next&quot;, &quot;submit&quot;). You can also opt to have some Javascript added to the last page of a form that will prevent multiple submissions (useful on slow servers).</p>
<h4>Form Display Options</h4>
<p>This tab allows for other form customizations, like the symbol to show for required fields.</p>
<h4>Captcha Settings</h4>
<p>If you have installed the Captcha module, this tab lets you configure the Captcha settings for your form.</p>
<h4>Form Template</h4>
<p>This is where you do your customization work of your form&#039;s Smarty Template. See the section called Form Template Variables below.</p>
<p>The form should default to a Custom template that documents the Smarty tags available to you.</p>
<p>Unless you&#039;re a Smarty expert, you probably don&#039;t want to mess around with this. If you are a Smarty expert, this is where you can unleash your magic.</p>
<h4>Submission Template</h4>
<p>If, in the Form Submission tab, you selected &#039;Display &quot;Submission Template&quot;, this is where you can create that template. There is a display of which smarty variables are available to you, and a button to generate a sample template.</p>
<p>If you&#039;re a Smarty expert, you can do all manner of creative and powerful things here. If you&#039;re not a Smarty expert, you might just want to use the default.
</p>

<h3>Adding Fields to your Form</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it&#039;s submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it&#039;s safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked &quot;Required&quot;, which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to &quot;view source&quot; on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It&#039;s really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It&#039;s really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
<li>Time Picker. This is a set of pulldowns allowing the user to select a time (using 12 or 24 hour clock).</li>
<li>File Upload. This is a file upload field.</li>
<li>Link (User Entered). This creates a double input field for getting a link URL and link title.</li>
<li>Text Field (Multiple). This field creates one or more text inputs with add and delete buttons, effectively giving the end user a way of creating variable-length lists.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the &quot;From&quot; field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the &quot;From&quot; field.</li>
<li>Email Subject Field. This allows users to provide a subject for their email. The email generated when the form gets handled will use this in the &quot;Subject&quot; field. This may cause trouble with certain dispositions that want to control the Email Subject, so use it with caution.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Fieldset Start. Combined with Fieldset End, this allows you to group various fields within your form. Use this to start a given grouping.</li>
<li>-Fieldset End. Combined with Fieldset Start, this allows you to group various fields within your form. Use this to end a given grouping.</li>
<li>-Hidden Field. This allows you to embed a hidden field in your form.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you&#039;re not using a Custom Template to render your form.</li>
<li>-Static Link. This allows you to put a link to a given page into your form. Optionally, you can have it autopopulate with the page where the form is embedded (useful if you\&#039;re sending results via email).</li>
<li>-Computed Field. This allows you to embed a computed field in your form. It is not visible to the user until after the form is submitted. It allows you to do simple arithmetic or string concatenation.</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<ul><li>*Call a User Defined Tag With the Form Results. This submits all the form results to the User-Defined Tag you specify. The UDT can handle the results however it wants.</li>
<li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these &quot;Director&quot; pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email to User-Supplied Address. This puts an input field in the form for the user to populate with an email address. The form results get sent to that address. Beware of Spam abuse! Active the primitive anti-spam features in the FormBuilder configuration screen.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Redirect to Page Based on Pulldown. This allows you to redirect the form to a different site page depending on its value. If you have multiple dispositions, make sure this is used last.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered &quot;approved,&quot; and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the &quot;output&quot; directory under the
module&#039;s installation directory, assuming the web server has permission to write there.</li>
<li>*Save Results to File Based on Pulldown. Like the Flat File disposition, except the value of a pull-down determines which file results get written to.</li>
<li>*Save Results to File(s) Based on Multiple Selections. Like the Flat File disposition, except the value(s) of checkboxes  determines which file(s) results get written to.</li>
</ul></li></li></ul>


<h3>Passing Default Values to Forms</h3>
<p>Calguy added a nice feature, which is that you can pass default field values to your form via the module tag. This allows you to have
the same form in multiple places, but with different default values. It may not work for more exotic field types, but for fields that have
a single value, you can specify like:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_<i>FIELDNAME</i>=&#039;default_value&#039;}</p>
<p>This will set the field with <i>FIELDNAME</i> to &#039;default_value&#039;.</p>
<p>This can be problematic, as sometimes field names are unweildy or contain characters that don&#039;t work well with Smarty. So there is an
alternative like this:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_fld<i>NUMBER</i>=&#039;default_value&#039;}</p>
<p>That uses field <i>NUMBER</i>, where <i>NUMBER</i> is the internal FormBuilder field id. You might wonder how you know what that id is. Simply go into the FormBuilder configuration tab,
and check &quot;Show Field IDs&quot;</p>

<h3>Email and Flat File Templates</h3>
<p>Many disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it&#039;s own best guess, which may or may not work out to your liking. You can always click on the &quot;Create Sample Template&quot; and then customize the results.</p>
<p>To the right, you&#039;ll find a legend which lists all of the variables that are available to you to use in your template. As of version 0.3, variables have two names, one based on the field name, the other based on the field ID. If you use field names that have characters outside of the ASCII 32-126 range, it will be safer to use the ID-based variables.</p>
<p><strong>Note that once you&#039;ve changed a template, it will no longer automatically add new fields.</strong> For this reason, it&#039;s usually best to create your templates as the last step of creating your form.</p>
<p>As of version 0.2.4, you can opt to send any of these emails as HTML email. There should be a checkbox at the top of the template page for this. There is also a &quot;Create Sample HTML Template&quot; button over in the legend area. For HTML email, the email body will also provide the default text-only values.</p>

<h3>Configuration</h3>
<p>There are some global configuration options for FormBuilder:</p>
<ul>
<li>Enable fast field add pulldown. This enables the pulldown on the Form Edit page which saves a step in the creation of new fields.</li>
<li>Hide Errors. This is set by default. Unchecking it will cause more detailed errors to be displayed if there are problems when you submit your form.</li>
<li>Require Field Names. Typically, you will want form fields to be named so you can tell which is which. However, in some cases, you might want to have nameless fields. Uncheck this if you want to allow nameless fields.</li>
<li>Unique Field Names. Typically, you will want form fields to have unique names so you can tell which is which. Uncheck this if you want to allow fields to share names.</li>
<li>Use relaxed email validation. This uses a less restrictive regular expression for validating email; e.g., x@y will be allowed, where typically x@y.tld is required.</li>
<li>Show Form Builder Version. Displays the version of FormBuilder you&#039;re using in a comment when the form is generated. Typically only useful when debugging.</li>
<li>Enable primitive anti-spam features. When turned on, this allows any given IP address to only generate 10 emails per hour.</li>
<li>Show Field IDs. When turned on, FormBuilder will display field ids when adding or editing a form.</li>
</ul>
<h3>Styling and CSS</h3>
<p>Paul Noone graciously provides us all with a pretty good standard CSS that you can use for forms:</p>
<pre>
	/* Sample FormBuilder CSS base */
	form {margin-top:0}
	form, td, th, li { font-size: 100%}
	form div {margin-bottom:0}
	fieldset div {
		margin-bottom:0.5em;
		margin-left:1em;
	}
	fieldset div div {
		margin-top:0.5em;
		margin-left:1em
	}
	fieldset {
		margin-bottom:1em;
		border:1px solid #F60;
		padding:0.5em
	}
	fieldset label {
		width:auto;
	}
	legend {
		color:#FFF;
		background:#F60;
		font-style:italic;
		font-size:1.2em;
		margin-bottom:0.5em;
		padding:0.2em;
		width:auto;
		border:1px solid #CCC
	}
	textarea {
		margin: 0.5em 0;
		width:98%;
		height: 6em
	}

	/* Apply this class to text/select input fields with shorter labels
		to help alignment */
	.short-label label {float:left; width:10em}
	.short-label fieldset div input,
	.short-label fieldset div select {width:16em}

	/* Pretty up your Captcha image output */
	.captcha {
		margin:0.5em 0;
		width:200px;
		text-align:center
	}
	.captcha img {border:1px solid #F60; margin-bottom:0.5em}
	.captcha input {width:196px; margin-top:0.5em}

	/* Just a bit more room for the Submit button */
	.submit {margin-top:0.5em}
</pre>

<h3>Form Template Variables</h3>

<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>


<h3>Known Issues</h3>
<ul>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder cannot yet be inlined. That should be a simple upgrade down the line.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn&#039;t matter since the user side is pretty simple.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you&#039;re running CMS 1.1 or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you&#039;re missing fields in an email that gets generated, check the disposition field&#039;s template, and make sure you&#039;re specifying the missing fields. Seems obvious, but it&#039;s an easy mistake to make.</li>
<li>Uncheck the &quot;Hide Errors&quot; checkbox in the global options, and see what message gets displayed when you submit your form.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is no longer a particularly early version, but it is probably still buggy. While I&#039;ve done all I can
to make sure no egregious bugs have crept in, I have to admit that during early testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor&#039;s nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>.</li>
<li>Additional discussion of this module may also be found in the <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2007, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '<ul>
<li>Version 0.4
	<ul>
		<li>Upped minimum CMS version to 1.1</li>
		<li>Numerous Bug fixes; too many to enumerate here</li>
		<li>Massive rejiggering of code to work with CMS MS 1.1 parameter sanitizing regime</li>
		<li>Added field types: &quot;TextField (Multiple)&quot; and &quot;Computed Field&quot;</li>
		<li>Added dispositions: &quot;Save Results to File Based on Pulldown&quot; and &quot;Save Results to File(s) Based on Multiple Selections&quot;(Calguy)</li>
		<li>Added neat-o AJAX-y template-copying for Form Templates, gave versions of old table-based templates to soothe the raging masses.</li>
		<li>Added ability to pass default values to form elements from module tag using value_FIELDNAME=&quot;value&quot; syntax (Calguy)</li>
		<li>Added option to display field ids in admin (Calguy)</li>
	</ul>
</li>
<li>Version 0.3
   <ul>
      <li>Added Captcha module support.</li>
      <li>Reworked labeling of form elements to be XHTML compliant</li>
      <li>Added Paul Noone&#039;s new, improved contact form templates</li>
      <li>Implementation of Email Subject Field</li>
      <li>Added admin-specifiable values to hidden field type, which may contain parsable smarty tags</li>
      <li>Text Area Field now allows specification of rows and cols in the admin, instead of CSS</li>
      <li>Added Drag&#039;n&#039;Drop reordering of form fields.</li>
      <li>Added non-blank field name and unique field name global configuration options and validation</li>
      <li>Implemented templated display of form results upon submission in addition to page redirecting</li>
      <li></li>
   </ul>
</li>
<li>Version 0.2.4 - 09 May 2007
   <p>Big release:<ul>
   <li>Added &quot;Email Form to User-Supplied Address&quot; disposition.</li>
   <li>Added &quot;TimePicker&quot; field type. Split &quot;Link&quot; field into a &quot;User-supplied Link&quot; field and a &quot;Static Link&quot; field.</li>
   <li>Added HTML email option and auto-templates for all email dispositions.</li>
   <li>Added primitive anti-spam features.</li>
   <li>Added XML-based import and export of forms.</li>
   </ul>
   </p>
</li>
<li>Version 0.2.3
   <p>Add the ability to call a selectable user defined tag upon disposition of the form.</p>
</li>
<li>Version 0.2.2
   <p>Many thanks to Utter Design for sponsoring some changes and bugfixes, which include:
   <ul>
      <li>Added file upload capabilities to the email disposition</li>
      <li>Add PageSetStart and PageSetEnd field types
      <p>These field types allow you to create fieldsets in your form, and organise
      your fields logically for the user.  You can even nest fieldsets, and
      associate a style with them appropriately.  The default template was changed
      to prevent it from wrapping a div around these types of fields.
      </p>
      </li>
      <li>Fixed a problem with DATETIME fields on install
      <p>This solves a problem when on install the response table would sometimes not get created when using adodb lite</li>
      </li>
   </ul>
   </p>
</li>
<li>Version 0.2 - 14 November 2006. Calguy &amp; tsw&#039;s bug fixes for field re-ordering and custom templates. Additional bug fixes for field labels.</li>
<li>Version 0.1 - 8 July 2006. Initial Release</li>
</ul>
';
$lang['utmz'] = '156861353.1222937461.251.53.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/search/|utmcmd=referral';
$lang['utma'] = '156861353.1608855210.1167908109.1222896749.1222937461.251';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/da_DK.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Formular Generator';
$lang['field_type_'] = 'Felt-type ikke sat';
$lang['field_type_CatalogerItemsField'] = 'Select one (or more) cataloger items';
$lang['field_type_FieldsetEnd'] = '-Felts&aelig;t slut';
$lang['field_type_FieldsetStart'] = '-Felts&aelig;t begynd';
$lang['field_type_TextField'] = 'Tekstfelt';
$lang['field_type_TextFieldExpandable'] = 'Tekstfelt (flere)';
$lang['field_type_TextAreaField'] = 'Tekstfelt, flere linier';
$lang['field_type_CheckboxField'] = 'Afkrydsningsboks';
$lang['field_type_CheckboxGroupField'] = 'Gruppe af afkrydsningsbokse';
$lang['field_type_PulldownField'] = 'Pulldown-menu';
$lang['field_type_MultiselectField'] = 'Multi-valg';
$lang['field_type_StatePickerField'] = 'U.S. State v&aelig;lger';
$lang['field_type_ProvincePickerField'] = 'Canadisk proins v&aelig;lger';
$lang['field_type_CountryPickerField'] = 'Lande valg';
$lang['field_type_DatePickerField'] = 'Dato Valg';
$lang['field_type_TimePickerField'] = 'Tidsvalg';
$lang['field_type_RadioGroupField'] = 'Radio knap gruppe';
$lang['field_type_DispositionDirector'] = '*Email resultatet baseret p&aring; pulldown-valg';
$lang['field_type_DispositionFileDirector'] = '*Gem resultater i en fil baseret p&aring; menu';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Gem resultater i en fil baseret p&aring; flere valgt';
$lang['field_type_DispositionPageRedirector'] = '*Viderestil til side baseret p&aring; pulldown-valg';
$lang['field_type_DispositionEmail'] = '*Email resultatet til angivne adresse(r)';
$lang['field_type_DispositionEmailConfirmation'] = '*Valid&eacute;r via email adresse';
$lang['field_type_DispositionFromEmailAddressField'] = '*Email &quot;From Address&quot; Field, and send copy';
$lang['field_type_DispositionFile'] = '*Skriv resultater til alm. tekst-fil';
$lang['field_type_DispositionDatabase'] = '*Gem resultater i databasen';
$lang['field_type_DispositionFormBrowser'] = '*Gem resultater til FormBrowser modul version 3';
$lang['field_type_DispositionUserTag'] = '*Kald en brugerdefineret tag inde i formularen';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Email til bruger-angiven email adresse';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Email til en CMS admin bruger';
$lang['field_type_PageBreakField'] = '-Sideskift';
$lang['field_type_FileUploadField'] = 'Fil-upload';
$lang['field_type_FromEmailAddressField'] = 'Email &quot;Fra adresse&quot; felt';
$lang['field_type_FromEmailAddressAgainField'] = 'Email &quot;From Address&quot; Again Field';
$lang['field_type_FromEmailNameField'] = 'Email &quot;Fra navn&quot; felt';
$lang['field_type_FromEmailSubjectField'] = 'Email &quot;Emne&quot; felt';
$lang['field_type_StaticTextField'] = '-Statisk tekst';
$lang['field_type_SystemLinkField'] = '-Statisk link';
$lang['field_type_LinkField'] = '-Link';
$lang['field_type_HiddenField'] = '-Skjult felt';
$lang['field_type_ComputedField'] = '-Beregnet felt';
$lang['field_type_UniqueIntegerField'] = '-Unikt tal (serielt)';
$lang['validation_none'] = 'Ingen validering';
$lang['validation_numeric'] = 'Numerisk';
$lang['validation_integer'] = 'Heltal';
$lang['validation_email_address'] = 'Email adresse';
$lang['validation_usphone'] = 'Telefon nummer (USA)';
$lang['validation_must_check'] = 'Skal v&aelig;re valgt';
$lang['validation_regex_match'] = 'Skal matche regul&aelig;r udtryk';
$lang['validation_regex_nomatch'] = 'M&aring; ikke matche regul&aelig;r udtryk';
$lang['required_field_missing'] = 'En v&aelig;rdi blev ikke angivet i et p&aring;kr&aelig;vet felt';
$lang['please_enter_a_value'] = 'Angiv en v&aelig;rdi for &quot;%s&quot;';
$lang['please_enter_a_number'] = 'Angiv et tal for &quot;%s&quot;';
$lang['please_enter_valid'] = 'Angiv en gyldig v&aelig;rdi for &quot;%s&quot;';
$lang['please_enter_an_integer'] = 'Angiv et heltal for &quot;%s&quot;';
$lang['please_enter_an_email'] = 'Angiv en gyldig email adresse for &quot;%s&quot;';
$lang['email_address_does_not_match'] = 'Email address does not match value in &quot;%s&quot;';
$lang['please_enter_a_phone'] = 'Please enter a valid phone number for &quot;%s&quot;';
$lang['not_valid_email'] = '&quot;%s&quot; er ikke en gyldig email adresse!';
$lang['please_enter_no_longer'] = 'Angiv en v&aelig;rdi der ikke er l&aelig;ngere end %s tegn';
$lang['title_list_delimiter'] = 'Tegn der kan benyttes til at adskille flere v&aelig;rdier';
$lang['you_need_permission'] = 'Du skal have &quot;%s&quot; tilladelsen for at kunne udf&oslash;re den operation';
$lang['lackpermission'] = 'Beklager! Du har ikke de n&oslash;dvendige tilladelser for at tilg&aring; den sektion.';
$lang['field_order_updated'] = 'Felt-r&aelig;kkef&oslash;lgen blev opdateret.';
$lang['form_deleted'] = 'Formularem blev slettet';
$lang['field_deleted'] = 'Feltet blev slettet';
$lang['configuration_updated'] = 'Konfigurationen blev opdateret';
$lang['you_must_check'] = 'Du skal s&aelig;tte kryds i &quot;%s&quot; for at forts&aelig;tte';
$lang['must_specify_one_destination'] = 'Du skal angive mindst en modtager-adresse';
$lang['are_you_sure_delete_form'] = 'Er du sikker p&aring; du vil slette formularen %s?';
$lang['are_you_sure_delete_field'] = 'Er du sikker p&aring; du vil slette feltet %s?';
$lang['notice_select_type'] = 'Udvidede indstillinger kan f&oslash;rst ses, n&aring;r der er valgt felttype';
$lang['field_name_in_use'] = 'Feltnavnet &quot;%s&quot; er allerede i brug. Benyt venligst unikke feltnavne';
$lang['field_no_name'] = 'Felter skal navngives med mindre du sl&aring; dette fra i Formular Generatorens indstillinger';
$lang['anonymous'] = 'Anonym';
$lang['abbreviation_length'] = 'L&aelig;ngde: %s';
$lang['boxes'] = '%s bokse';
$lang['options'] = '%s valgmuligheder';
$lang['text_length'] = '%s chars';
$lang['order'] = 'R&aelig;kkef&oslash;lge';
$lang['unspecified'] = '[ikke angivet]';
$lang['added'] = 'tilf&oslash;jet';
$lang['updated'] = 'opdateret';
$lang['sort_options'] = 'Sort&eacute;r valgmuligheder ved output';
$lang['select_one'] = 'V&aelig;lg en';
$lang['select_type'] = 'V&aelig;lg type';
$lang['to'] = 'Til';
$lang['yes'] = 'Ja';
$lang['no'] = 'Nej';
$lang['recipients'] = 'modtagere';
$lang['file_count'] = '%s mulige filer';
$lang['destination_count'] = '%s destinationer';
$lang['save'] = 'Gem';
$lang['add'] = 'Tilf&oslash;j';
$lang['update'] = 'Opdat&eacute;r';
$lang['save_and_continue'] = 'Gem og forts&aelig;t redigering';
$lang['information'] = 'Information';
$lang['automatic'] = 'Automatisk';
$lang['forms'] = 'Formularer';
$lang['form'] = 'Formular %s';
$lang['configuration'] = 'Konfiguration';
$lang['field_requirement_updated'] = 'Feltets p&aring;kr&aelig;vet-status opdateret';
$lang['maximum_size'] = 'Maks. st&oslash;rrelse';
$lang['permitted_extensions'] = 'Udvidelser';
$lang['permitted_filetypes'] = 'Tilladte filtyper';
$lang['file_too_large'] = 'Den upload&#039;ede fil er for stor! Maksimal st&oslash;rrelse er: ';
$lang['illegal_file_type'] = 'Denne type fil m&aring; ikke uploades. Kontroll&eacute;r venligst at filtypen er korrekt.';
$lang['upload'] = 'Upload';
$lang['form_imported'] = 'Formular importeret';
$lang['form_import_failed'] = 'Import af formular fejlede. Der var et problem med formatet af XML-filen';
$lang['rows'] = '%s r&aelig;kker';
$lang['cols'] = '%s kolonner';
$lang['12_hour'] = '12-timers tid';
$lang['24_hour'] = '24-timers tid';
$lang['hour'] = 'Time';
$lang['min'] = 'Minut';
$lang['merid'] = 'Meridian';
$lang['date_range'] = 'Omr&aring;de: %s - %s';
$lang['thanks'] = 'Tak! Din afsendelse er modtaget.';
$lang['edit'] = 'Redig&eacute;r';
$lang['delete'] = 'Slet';
$lang['day'] = 'Dag';
$lang['mon'] = 'M&aring;ned';
$lang['year'] = '&Aring;r';
$lang['none'] = '(ingen)';
$lang['uninstalled'] = 'Modulet blev afinstalleret';
$lang['installed'] = 'Modul version %s installeret.';
$lang['upgraded'] = 'Modulet blev opgraderet til version %s.';
$lang['button_previous'] = 'Tilbage...';
$lang['button_submit'] = 'Send formular';
$lang['button_continue'] = 'Videre...';
$lang['value_checked'] = 'Valgt';
$lang['value_unchecked'] = 'Ikke valgt';
$lang['tab_main'] = 'Main';
$lang['tab_symbol'] = 'Formular fremvisnings indstillinger';
$lang['tab_submit'] = 'Formular afsendelse';
$lang['tab_captcha'] = 'Captcha indstillinger';
$lang['tab_advanced'] = 'Avancerede indstillinger';
$lang['tab_templatelayout'] = 'Template Layout Options';
$lang['tab_submissiontemplate'] = 'Afsendelses skabelon';
$lang['canuse_smarty'] = '<em>Smarty variabler kan benyttes i dette felt.</em>';
$lang['add_options'] = 'Tilf&oslash;j flere valgmuligheder';
$lang['delete_options'] = 'Slet markerede valgmuligheder';
$lang['add_checkboxes'] = 'Tilf&oslash;j flere checkboxe';
$lang['delete_checkboxes'] = 'Slet markerede checkboxe';
$lang['add_address'] = 'Tilf&oslash;j endnu en adresse';
$lang['delete_address'] = 'Slet den markerede adresse';
$lang['add_destination'] = 'Tilf&oslash;j endnu en destination';
$lang['delete_destination'] = 'Slet de markerede destinations';
$lang['suspected_spam'] = 'Too many emails generated from your IP address. Anti-Spam code has prevented delivery.';
$lang['suspected_spam_log'] = 'Suspected spam from IP %s stopped.';
$lang['reorder'] = 'Omarrang&eacute;r felter';
$lang['cancel'] = 'Fortryd';
$lang['value_set'] = 'Value set: %s';
$lang['help_cataloger_attribute_fields'] = 'Below is a list of the attributes available from the Cataloger module.<br/>You can optionally specify valid ranges, values, or numerous values to be used in filtering the list of items that is displayed to the user.<br/>
<br/>
<strong>Ranges:</strong><br/>
Ranges can be specified by signifying a minimum and maximum value using this syntax: &quot;range: minvalue to maxvalue&quot;<br/>
<br/>
<strong>Multiple Values:</strong><br/>
To specify multiple values for an attribute use the syntax &quot;multi: value1|value2|value3&quot;<br/>
<br/>
<strong>Values from hidden fields</strong><br/>
To specify a value from a hidden field use the syntax {$fld_id}<br/>
<br/>';
$lang['help_name_regex'] = 'A regular expression to allow filtering cataloger items by name';
$lang['help_field_height'] = 'The height of the multiselect field';
$lang['title_name_regex'] = 'Cataloger Item Name Regular Expression';
$lang['title_field_height'] = 'Field Height';
$lang['title_file_path'] = 'Destination Directory for output files';
$lang['title_udt_name'] = 'User Defined Tag';
$lang['title_uploads_destpage'] = 'Page to return to with uploads link';
$lang['title_uploadmodule_summary'] = 'Submitted with formbuilder';
$lang['title_uploads_category'] = 'Uploads category';
$lang['title_sendto_uploads'] = 'Send this file to the uploads module';
$lang['title_legend'] = 'Legend';
$lang['title_maximum_length'] = 'Maximum Length';
$lang['title_checkbox_label'] = 'Checkbox label';
$lang['title_radio_label'] = 'Radio Button label';
$lang['title_checked_value'] = 'Value when checked';
$lang['title_unchecked_value'] = 'Value when not checked.';
$lang['title_checkbox_details'] = 'Checkbox Group Details';
$lang['title_delete'] = 'Delete?';
$lang['title_select_one_message'] = '&quot;V&aelig;lg en&quot; Text';
$lang['title_selection_value'] = 'Valgt v&aelig;rdi';
$lang['title_selection_displayname'] = 'Selection Display Name';
$lang['title_selection_subject'] = 'Selection Subject';
$lang['title_select_default_country'] = 'Default Selection';
$lang['title_select_default_state'] = 'Default Selection';
$lang['title_select_default_province'] = 'Default Selection';
$lang['title_option_name'] = 'Valgmulighedens navn';
$lang['title_option_value'] = 'Value Submitted';
$lang['title_pulldown_details'] = 'Pulldown Options';
$lang['title_multiselect_details'] = 'Multiselect Options';
$lang['title_destination_address'] = 'Destination Email Address';
$lang['title_destination_filename'] = 'Destination File Name';
$lang['title_email_from_name'] = '&quot;Fra navn&quot; for email';
$lang['title_relaxed_email_regex'] = 'Use relaxed email validation';
$lang['title_relaxed_regex_long'] = 'Benyt afslappet email-validering (f.eks., tillad &quot;x@y&quot; i stedet for at kr&aelig;ve &quot;x@y.tld&quot;)';
$lang['title_email_from_address'] = '&quot;Fra adresse&quot; for email';
$lang['title_email_encoding'] = 'Email character set encoding';
$lang['title_director_details'] = 'Pulldown-based Emailer Details';
$lang['title_file_name'] = 'File Name';
$lang['title_email_subject'] = 'Email Subject Line';
$lang['title_form_name'] = 'Formular navn';
$lang['title_form_status'] = 'Formular status';
$lang['title_ready_for_deployment'] = 'Klar til brug';
$lang['title_not_ready1'] = 'Ikke klar';
$lang['title_redirect_page'] = 'Side der skal viderestilles til efter afsendelse af formular';
$lang['title_not_ready2'] = 'Please add a field to the form so that the user\&#039;s input gets handled. You can';
$lang['title_not_ready_link'] = 'benyt denne genvej';
$lang['title_form_alias'] = 'Form Alias';
$lang['title_form_fields'] = 'Formular felter';
$lang['title_field_id'] = 'Field Id';
$lang['title_show_fieldaliases'] = 'Show Field Aliases';
$lang['title_show_fieldaliases_long'] = 'Clicking this will display field aliases when adding or editing a form';
$lang['title_field_name'] = 'Field Name';
$lang['title_field_alias'] = 'Field Alias';
$lang['title_radiogroup_details'] = 'Radio Button Group Details';
$lang['title_field_type'] = 'Field Type';
$lang['title_not_ready3'] = 'to create a form handling field.';
$lang['title_add_new_form'] = 'Add New Form';
$lang['title_show_version'] = 'Show Form Builder Version?';
$lang['title_show_version_long'] = 'This will embed your installed version number of Form Builder module in a comment, to aid in debugging';
$lang['title_add_new_field'] = 'Add New Field';
$lang['title_form_submit_button'] = 'Form Submit Button Text';
$lang['title_submit_button_safety'] = 'Add Javascript to final Submit Button that will help prevent multiple submissions?';
$lang['title_submit_button_safety_help'] = 'Add safety script';
$lang['title_form_next_button'] = 'Form &quot;Next&quot; Button Text (used for multipage forms)';
$lang['title_form_prev_button'] = 'Form &quot;Previous&quot; Button Text (used for multipage forms)';
$lang['title_field_validation'] = 'Felt validering';
$lang['title_field_to_validate'] = 'Felt der skal valideres';
$lang['title_form_css_class'] = 'CSS Class for this form';
$lang['title_field_css_class'] = 'CSS Class for this field';
$lang['title_form_required_symbol'] = 'Symbol to mark required Fields';
$lang['title_field_required'] = 'Required';
$lang['title_field_required_long'] = 'Require a response for this Field';
$lang['title_hide_label'] = 'Hide Label';
$lang['title_hide_label_long'] = 'Skjul feltets navn p&aring; formularen';
$lang['title_text'] = 'Statisk tekst der skal vises';
$lang['title_field_regex'] = 'Validation Regex';
$lang['title_lines_to_show'] = 'Number of Lines to display';
$lang['no_default'] = 'No Default';
$lang['redirect_after_approval'] = 'Page to redirect after approval';
$lang['title_regex_help'] = 'This regular expression will only be used if \&quot;validation type\&quot; is set to a regex-related option. Include a full Perl-style regex, including the start/stop slashes and flags (e.g., \&quot;/image\.(\d+)/i\&quot;)';
$lang['title_field_required_abbrev'] = 'P&aring;kr&aelig;vet';
$lang['title_hide_errors'] = 'Skjul fejl';
$lang['title_form_displaytype'] = 'Form Display Type';
$lang['title_hide_errors_long'] = 'Prevent debug / error messages from being seen by users.';
$lang['title_email_template'] = 'Email skabelon';
$lang['title_maximum_size'] = 'Maximum upload file size (kilobytes)';
$lang['title_maximum_size_long'] = 'This limitation is in addition to any limits set by the php or web server configuration';
$lang['title_permitted_extensions'] = 'Permitted Extensions';
$lang['title_permitted_extensions_long'] = 'Enter a comma-separated list, excluding the dot (e.g., \&quot;jpg,gif,jpeg\&quot;). Spaces will be ignored. Leaving this blank means there will be no restrictions.';
$lang['title_show_limitations'] = 'Display restrictions?';
$lang['title_show_limitations_long'] = 'Display any size and extension restrictions with the upload field?';
$lang['title_form_template'] = 'Template to use to Display Form';
$lang['title_page_x_of_y'] = 'Page %s of %s';
$lang['title_no_advanced_options'] = 'Field has no advanced options.';
$lang['title_form_unspecified'] = 'Text to return for unspecified field values';
$lang['title_enable_fastadd_long'] = 'Enable fast field adding pulldown for forms?';
$lang['title_enable_fastadd'] = 'Enable fast field add pulldown?';
$lang['title_fastadd'] = 'Fast field adder';
$lang['title_enable_antispam_long'] = 'Clicking this will only allow 10 emails to be triggered from a given IP address (per hour).';
$lang['title_enable_antispam'] = 'Enable primitive anti-spam features?';
$lang['title_show_fieldids'] = 'Show Field IDs';
$lang['title_show_fieldids_long'] = 'Clicking this will allow displaying field ids when adding or editing a form';
$lang['title_xml_to_upload'] = 'Upload form from XML file';
$lang['title_xml_upload_formname'] = 'Use this form name';
$lang['title_import_legend'] = 'XML Form Import';
$lang['title_xml_upload_formalias'] = 'Use this form alias';
$lang['title_html_email'] = 'Generate HTML email?';
$lang['title_link_autopopulate'] = 'Automatically populate?';
$lang['title_link_autopopulate_help'] = 'Automatically populate with the URL of the page containing the form? (this overrides site page link option below)';
$lang['title_default_link'] = 'Default link URL';
$lang['title_default_link_title'] = 'Default link text';
$lang['title_link_to_sitepage'] = 'Link to site page';
$lang['title_captcha_not_installed'] = 'You can use <a href=\"http://www.wikipedia.org/wiki/Captcha\" target=\"_new\">\&quot;Captcha\&quot;</a> to protect form submissions if you install the Captcha module. For more information, <a href=\"http://dev.cmsmadesimple.org/projects/captcha/\">check the Captcha project</a>.';
$lang['title_use_captcha'] = 'Use Captcha to protect form submissions?';
$lang['title_use_captcha_help'] = 'Check here to protect your form with a <a href="http://www.wikipedia.org/wiki/Captcha" target="_new\">&quot;Captcha&quot;</a>.';
$lang['title_user_captcha'] = 'Please confirm that you are not a script by entering the letters from the image.';
$lang['title_user_captcha_error'] = 'Failed text for Captcha';
$lang['wrong_captcha'] = 'Captcha was not correct.';
$lang['title_title_user_captcha'] = 'Help text for Captcha';
$lang['title_dont_submit_unchecked'] = 'Don&#039;t submit values for unchecked boxes';
$lang['title_dont_submit_unchecked_help'] = 'Check this if you only want checked boxes to return values.';
$lang['link_label'] = 'Link Label';
$lang['link_destination'] = 'Link Destination URL';
$lang['title_default_set'] = 'Checked by Default?';
$lang['title_24_hour'] = 'Use 24-hour clock?';
$lang['title_before_noon'] = 'AM';
$lang['title_after_noon'] = 'PM';
$lang['title_smarty_eval'] = 'Process smarty tags within field?';
$lang['title_textarea_rows'] = 'Rows (note: this may be overridden by CSS)';
$lang['title_textarea_cols'] = 'Columns (note: this may be overridden by CSS)';
$lang['title_form_main'] = 'Main Form Details';
$lang['title_show_username'] = 'Display User&#039;s login name?';
$lang['title_show_userfirstname'] = 'Display User&#039;s first name?';
$lang['title_show_userlastname'] = 'Display User&#039;s last name?';
$lang['title_restrict_to_group'] = 'Restrict user list to users in specified group';
$lang['restricted_to_group'] = 'Only in group %s';
$lang['title_show_to_user'] = 'Display to user?';
$lang['help_leaveempty'] = 'This field may be left empty';
$lang['help_variables_for_template'] = 'Variables For Template';
$lang['help_variables_for_computation'] = 'Variables Available';
$lang['help_php_variable_name'] = 'PHP variable';
$lang['help_submission_date'] = 'Dato for afsendelse';
$lang['help_server_name'] = 'Din server';
$lang['help_sub_source_ip'] = 'IP address of person using form';
$lang['help_sub_url'] = 'URL of page containing form';
$lang['help_fb_version'] = 'FormBuilder version';
$lang['help_tab'] = 'Tab Character';
$lang['help_other_fields'] = 'Other fields will be available as you add them to the form.';
$lang['help_array_fields'] = 'Yet another way of accessing field values is via $fieldname_obj, $alias_obj, or $fld_#_obj, where each field is an object containging:<br /><table>
<tr><td class=&quot;odd&quot;>name</td><td class=&quot;odd&quot;>Field Name</td></tr>
<tr><td>type</td><td>Field Type</td></tr>
<tr><td class=&quot;odd&quot;>id</td><td class=&quot;odd&quot;>Internal Field ID</td></tr>
<tr><td>value</td><td>Human-readable Value</td></tr>
<tr><td class=&quot;odd&quot;>valueArray</td><td class=&quot;odd&quot;>Array of field value(s)</td></tr></table><em>e.g.</em>, you could use &quot;{$fld_1_obj->name} = {$fld_1_obj->value}';
$lang['help_date_format'] = 'See <a href="http://www.php.net/manual/en/function.date.php" target=_NEW>the PHP Manual</a> for formatting help.';
$lang['help_variable_name'] = 'Variable';
$lang['help_form_field'] = 'Field Represented';
$lang['link_back_to_form'] = '&laquo; Tilbage til formular';
$lang['title_create_sample_template'] = 'Create Sample Template';
$lang['title_create_sample_html_template'] = 'Create Sample HTML Template';
$lang['title_create_sample_header_template'] = 'Create Sample Header Template';
$lang['title_create_sample_header'] = 'Create Sample Header';
$lang['help_tab_symbol'] = 'a tab character';
$lang['title_file_template'] = 'Template for one line of output file';
$lang['title_file_header'] = 'Template for the header of output file';
$lang['title_confirmation_url'] = 'URL to click for form confirmation';
$lang['title_value'] = 'Value (see Advanced Tab if you use Smarty tags)';
$lang['title_date_format'] = 'Date Format (standard <a href=\"http://www.php.net/manual/en/function.date.php\">PHP Date Formats</a>)';
$lang['title_use_wysiwyg'] = 'Use WYSIWYG editor for text Area?';
$lang['title_submit_actions'] = 'Form Submission Behavior';
$lang['title_submit_labels'] = 'Submission Button Labels';
$lang['title_sortable_field'] = 'Sortable Field #%s';
$lang['title_submit_help'] = 'This page lets you customize Form Submission. It doesn\&#039;t determine what the Form Builder does with the submitted data. You can set that up by adding \&quot;Disposition\&quot; fields to your form.';
$lang['title_start_year'] = 'Year range start';
$lang['title_end_year'] = 'Year range end';
$lang['title_default_year'] = 'Default Year';
$lang['title_default_year_help'] = '(Set to -1 for default year to be the current year)';
$lang['title_submit_action'] = 'After form is submitted';
$lang['title_submit_response'] = 'Response to display';
$lang['display_text'] = 'Vis &quot;afsendelses skabelon&quot;';
$lang['redirect_to_page'] = 'Redirect to site page';
$lang['title_submit_response_help'] = 'This template is for display to the user after the form is submitted. This template does not effect emails generated or other form dispositions -- you set those templates (where appropriate) in the \&quot;advanced\&quot; tab for those disposition fields.';
$lang['title_destination_page'] = 'Destination Page';
$lang['title_require_fieldnames'] = 'Require Fieldnames';
$lang['title_require_fieldnames_long'] = 'Require fields to have a name?';
$lang['title_unique_fieldnames'] = 'Require Unique Fieldnames';
$lang['title_unique_fieldnames_long'] = 'Require fields to have unique names?';
$lang['title_reorder_form'] = 'Reorder Fields';
$lang['title_load_template'] = 'Load template';
$lang['title_add_button_text'] = 'Add Button text';
$lang['title_del_button_text'] = 'Delete Button text';
$lang['title_string_or_number_eval'] = 'Interpret variables as being numbers or strings';
$lang['title_order'] = 'Interpretation Order';
$lang['title_order_help'] = 'If more than one Computed Field exists, they will be computed from lowest order number to highest order number';
$lang['title_compute_value'] = 'Value to compute';
$lang['title_string'] = 'Streng';
$lang['title_numeric'] = 'Numerisk';
$lang['title_inline_form'] = 'Display form inline?';
$lang['title_inline_form_help'] = 'Inline means any form followup replaces the {cms_module} tag, non-inline replaces the {content} tag.';
$lang['title_field_default_value'] = 'Default value for field';
$lang['title_clear_default'] = 'Clear default on click?';
$lang['title_clear_default_help'] = 'Check this to clear the default value when the user clicks this field. Since this uses a javascript string compare, it will fail if you put single quotes in your default text. Other un-javascript-friendly characters may also cause it to fail.';
$lang['title_remove_file_from_server'] = 'Delete uploaded file from server after processing (email dispositions)';
$lang['title_field_javascript'] = 'Javascript for field';
$lang['title_field_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;';
$lang['title_submit_javascript'] = 'Form Submission Javascript';
$lang['title_submit_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;.<br />This will probably not work well if you use the &quot;safety script&quot; option above.';
$lang['email_from_addr_help'] = 'Do not just pick a random address here -- many ISPs will<br />not deliver the mail if you are using a different domain name than your actual<br />host name (i.e., use something like name@%s)';
$lang['title_switch_advanced'] = 'Brug for flere felttyper? ';
$lang['title_switch_basic'] = 'For mange forvirrende felttyper?';
$lang['title_switch_advanced_link'] = 'Skift til avanceret visning';
$lang['title_switch_basic_link'] = 'Skift til simple visning';
$lang['title_file_root'] = 'Directory to save file in';
$lang['title_file_root_help'] = 'This needs to be a directory that your web server has permissions to write in.<br />Chmod it 777 if you have problems/doubts.<br />Also, check to see that you do not have PHP directory restrictions.';
$lang['title_newline_replacement'] = 'Newline/Carriage Return replacement character';
$lang['title_newline_replacement_help'] = 'Leave blank to allow newlines and carriage returns in output';
$lang['title_send_usercopy'] = 'Send User a Copy of Submission?';
$lang['title_send_usercopy_label'] = 'Label for Checkbox (if user choice)';
$lang['title_send_me_a_copy'] = 'Send me a copy of form';
$lang['option_never'] = 'Aldrig';
$lang['option_user_choice'] = 'Give user a choice (checkbox)';
$lang['option_always'] = 'Altid';
$lang['error_cataloger_module_not_available'] = '<strong>Cataloger module does not seem to be installed/active.</strong>';
$lang['warning'] = 'Advarsel';
$lang['default_template'] = 'Default Template';
$lang['table_left_template'] = 'Table Template, Titles on left';
$lang['table_top_template'] = 'Table Template, Title on top';
$lang['form_template_name'] = 'Template from %s';
$lang['template_are_you_sure'] = 'Are you sure you want to overwrite your template with the selected template? (Even if you say OK, you will still need to save the change)';
$lang['title_bad_function'] = 'Error when computing &quot;%s&quot;.';
$lang['no_referrer_info'] = 'No HTTP_REFERER info available (probably due to use of User Email Validation)';
$lang['validation_param_error'] = 'Validation Parameter Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_response_error'] = 'Validation Repsonse Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_no_field_error'] = 'Validation Repsonse Error. No email validation field in this form!';
$lang['upgrade03to04'] = 'Form Template was updated automatically as part of the version 0.3 to version 0.4 upgrade. You may need to make some fixes. If you&#039;re using the default form, simply replace this template with &quot;default&quot; using the pulldown above.';
$lang['admindesc'] = 'Add, edit and manage interactive Forms';
$lang['operators_help'] = 'If you use String evaluation, the only operation available is concatenation (+), while if you use Number evaluation you have basic, very simple math (, +, -, *, /, ).';
$lang['date_january'] = 'Januar';
$lang['date_february'] = 'Februar';
$lang['date_march'] = 'Marts';
$lang['date_april'] = 'April';
$lang['date_may'] = 'Maj';
$lang['date_june'] = 'Juni';
$lang['date_july'] = 'Juli';
$lang['date_august'] = 'August';
$lang['date_september'] = 'September';
$lang['date_october'] = 'Oktober';
$lang['date_november'] = 'November';
$lang['date_december'] = 'December';
$lang['submission_error'] = 'Sorry! There was an error handling your form submission.';
$lang['submit_error'] = 'FormBuilder submit error: %s';
$lang['uploads_error'] = 'Error committing file to the uploads module: %s';
$lang['nouploads_error'] = 'Could not find the uploads module';
$lang['upload_attach_error'] = 'Upload/Attachment error on file %s (tmp_name: %s, of type %s)';
$lang['submission_error_file_lock'] = 'Error. Unable to obtain lock for file.';
$lang['unchecked_by_default'] = 'Default: unchecked';
$lang['checked_by_default'] = 'Default: checked';
$lang['email_default_template'] = 'FormBuilder Afsendelse';
$lang['email_template_not_set'] = '<br/>Email Template not yet set!';
$lang['missing_cms_mailer'] = 'FormBuilder: Cannot find required module CMSMailer!';
$lang['user_approved_submission'] = 'User approved submission %s from %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Event triggered when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Event triggered if there is an error when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Event triggered when a FormBuilder form is displayed';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Event triggered when a FormBuilder form is submitted.</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Event triggered if there is an error when a FormBuilder form is submitted</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>error</em> - A list of all known errors (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Event triggered when a FormBuilder form is displayed</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
</ul> ';
$lang['formbuilder_params_response_id'] = 'Response ID. Used by FormBrowser';
$lang['formbuilder_params_passed_from_tag'] = 'Default field values; see module help';
$lang['formbuilder_params_field_id'] = 'Field ID for internal operations';
$lang['formbuilder_params_form_name'] = 'Form Name';
$lang['formbuilder_params_form_id'] = 'Form ID for internal operations';
$lang['formbuilder_params_general'] = 'General parameters for internal operations';
$lang['template_variable_help'] = '<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you\&#039;d like.
   To make the form work, you\&#039;ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that\&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field\&#039;s name</td></tr>
<tr><td>field->input</td><td>the field\&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field\&#039;s input (useful for <label for=\&quot;\&quot;>)</td></tr>
<tr><td>field->type</td><td>the field\&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays \&quot;page x of y\&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>\&quot;Back\&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>\&quot;Continue\&quot; or \&quot;Submit\&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you\&#039;d want some of those, but there you go...</p>
';
$lang['post_install'] = '<p>Make sure to set the \&quot;Modify Forms\&quot; permissions
on users who will be administering feedback forms. Also, if you\&#039;ll be emailing form
results, be sure to update the Configuration appropriately.</p>
<p>Please be aware that a feedback form should not be active (e.g., usable by the public) while
you are still editing the form. You should create the form, and place the tag into an active
content page only when you have finished editing. Otherwise, erroneous results could be returned.</p>
<p>Additionally, this version does not support parallel editing of forms. Please take care that
only one admin is editing a given form at a given time.</p>';
$lang['help'] = 'h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create feedback forms (in fact, it\&#039;s a replacement of the original Feedback Form module), with the added power of database storage. With its companion module Form Browser, you can use it to create simple database applications.</p>
<p>The forms created using the Form Builder may be inserted
into templates and/or content pages. Forms may contain many kinds of inputs, and may have
validation applied to these inputs. The results of these forms may be handled in a variety of ways.</p>

<h3>How Do I Use it?</h3>
<P>Install it, and poke around the menus. Play with it. Try creating forms, and adding them to your content.
If you get stuck, chat with me on the #cms IRC channel, post to the forum, send me email, or, if you\&#039;re
really desperate, read the rest of this page.</P>

<h3>How Do I Create a Form</h3>
<p>In the CMS Admin Menu, you should get a new menu item called FormBuilder. Click on this. On the page
that gets shown, there are options (at the bottom of the list of Forms) to Add a New Form or Modify
Configuration.</p>

<h3>Adding a Form to a Page</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module=\&#039;FormBuilder\&#039; form=\&#039;sample_form\&#039;}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page\&#039;s content if you use a WYSIWYG editor such as TinyMCE, FCKEdit, or HTMLArea. These editors may stealthily
change the quote marks (\&quot;) into HTML entities (&amp;amp;quot;), and the forms will not show up. Try using
single quotes (\&#039;) or editing the HTML directly.

<h3>Working with Forms</h3>
<p>By clicking on a Form\&#039;s name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you\&#039;ll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing.</p>
<p>Below this, if you have it enabled, is the \&quot;fast field adder\&quot; pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Form Submission</h4>
<p>When the form is submitted, you can either redirect the user to another page of your site, or you can present the user some message (which can contain any of the user\&#039;s form entries, or just static text). In this tab, you select which of these approaches you wish to use, and, if you chose redirection, it allows you to pick the page to redirect users to after a successful form submission.</p>
<p>Also on this page, you can specify the labels of various submission buttons (\&quot;Previous\&quot;, \&quot;next\&quot;, \&quot;submit\&quot;). You can also opt to have some Javascript added to the last page of a form that will prevent multiple submissions (useful on slow servers).</p>
<h4>Form Display Options</h4>
<p>This tab allows for other form customizations, like the symbol to show for required fields.</p>
<h4>Captcha Settings</h4>
<p>If you have installed the Captcha module, this tab lets you configure the Captcha settings for your form.</p>
<h4>Form Template</h4>
<p>This is where you do your customization work of your form\&#039;s Smarty Template. See the section called Form Template Variables below.</p>
<p>The form should default to a Custom template that documents the Smarty tags available to you.</p>
<p>Unless you\&#039;re a Smarty expert, you probably don\&#039;t want to mess around with this. If you are a Smarty expert, this is where you can unleash your magic.</p>
<h4>Submission Template</h4>
<p>If, in the Form Submission tab, you selected \&#039;Display \&quot;Submission Template\&quot;, this is where you can create that template. There is a display of which smarty variables are available to you, and a button to generate a sample template.</p>
<p>If you\&#039;re a Smarty expert, you can do all manner of creative and powerful things here. If you\&#039;re not a Smarty expert, you might just want to use the default.
</p>
<h3>Adding Fields to your Form</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it\&#039;s submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it\&#039;s safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked \&quot;Required\&quot;, which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to \&quot;view source\&quot; on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It\&#039;s really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It\&#039;s really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
<li>Time Picker. This is a set of pulldowns allowing the user to select a time (using 12 or 24 hour clock).</li>
<li>File Upload. This is a file upload field.</li>
<li>Link (User Entered). This creates a double input field for getting a link URL and link title.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the \&quot;From\&quot; field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the \&quot;From\&quot; field.</li>
<li>Email Subject Field. This allows users to provide a subject for their email. The email generated when the form gets handled will use this in the \&quot;Subject\&quot; field. This may cause trouble with certain dispositions that want to control the Email Subject, so use it with caution.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Fieldset Start. Combined with Fieldset End, this allows you to group various fields within your form. Use this to start a given grouping.</li>
<li>-Fieldset End. Combined with Fieldset Start, this allows you to group various fields within your form. Use this to end a given grouping.</li>
<li>-Hidden Field. This allows you to embed a hidden field in your form.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you\&#039;re not using a Custom Template to render your form.</li>
<li>-Static Link. This allows you to put a link to a given page into your form. Optionally, you can have it autopopulate with the page where the form is embedded (useful if you\&#039;re sending results via email).</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<ul><li>*Call a User Defined Tag With the Form Results. This submits all the form results to the User-Defined Tag you specify. The UDT can handle the results however it wants.</li>
<li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these \&quot;Director\&quot; pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email to User-Supplied Address. This puts an input field in the form for the user to populate with an email address. The form results get sent to that address. Beware of Spam abuse! Active the primitive anti-spam features in the FormBuilder configuration screen.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Redirect to Page Based on Pulldown. This allows you to redirect the form to a different site page depending on its value. If you have multiple dispositions, make sure this is used last.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered \&quot;approved,\&quot; and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the \&quot;output\&quot; directory under the
module\&#039;s installation directory, assuming the web server has permission to write there.</li>
</ul></li></li></ul>

<h3>Email and Flat File Templates</h3>
<p>Many disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it\&#039;s own best guess, which may or may not work out to your liking. You can always click on the \&quot;Create Sample Template\&quot; and then customize the results.</p>
<p>To the right, you\&#039;ll find a legend which lists all of the variables that are available to you to use in your template. As of version 0.3, variables have two names, one based on the field name, the other based on the field ID. If you use field names that have characters outside of the ASCII 32-126 range, it will be safer to use the ID-based variables.</p>
<p><strong>Note that once you\&#039;ve changed a template, it will no longer automatically add new fields.</strong> For this reason, it\&#039;s usually best to create your templates as the last step of creating your form.</p>
<p>As of version 0.2.4, you can opt to send any of these emails as HTML email. There should be a checkbox at the top of the template page for this. There is also a \&quot;Create Sample HTML Template\&quot; button over in the legend area. For HTML email, the email body will also provide the default text-only values.</p>

<h3>Configuration</h3>
<p>There are some global configuration options for FormBuilder:</p>
<ul>
<li>Enable fast field add pulldown. This enables the pulldown on the Form Edit page which saves a step in the creation of new fields.</li>
<li>Hide Errors. This is set by default. Unchecking it will cause more detailed errors to be displayed if there are problems when you submit your form.</li>
<li>Require Field Names. Typically, you will want form fields to be named so you can tell which is which. However, in some cases, you might want to have nameless fields. Uncheck this if you want to allow nameless fields.</li>
<li>Unique Field Names. Typically, you will want form fields to have unique names so you can tell which is which. Uncheck this if you want to allow fields to share names.</li>
<li>Use relaxed email validation. This uses a less restrictive regular expression for validating email; e.g., x@y will be allowed, where typically x@y.tld is required.</li>
<li>Show Form Builder Version. Displays the version of FormBuilder you\&#039;re using in a comment when the form is generated. Typically only useful when debugging.</li>
<li>Enable primitive anti-spam features. When turned on, this allows any given IP address to only generate 10 emails per hour.</li>
</ul>
<h3>Styling and CSS</h3>
<p>Paul Noone graciously provides us all with a pretty good standard CSS that you can use for forms:</p>
<pre>
	/* Sample FormBuilder CSS base */
	form {margin-top:0}
	form, td, th, li { font-size: 100%}
	form div {margin-bottom:0}
	fieldset div {
		margin-bottom:0.5em;
		margin-left:1em;
	}
	fieldset div div {
		margin-top:0.5em;
		margin-left:1em
	}
	fieldset {
		margin-bottom:1em;
		border:1px solid #F60;
		padding:0.5em
	}
	fieldset label {
		width:auto;
	}
	legend {
		color:#FFF;
		background:#F60;
		font-style:italic;
		font-size:1.2em;
		margin-bottom:0.5em;
		padding:0.2em;
		width:auto;
		border:1px solid #CCC
	}
	textarea {
		margin: 0.5em 0;
		width:98%;
		height: 6em
	}

	/* Apply this class to text/select input fields with shorter labels
		to help alignment */
	.short-label label {float:left; width:10em}
	.short-label fieldset div input, 
	.short-label fieldset div select {width:16em}

	/* Pretty up your Captcha image output */
	.captcha {
		margin:0.5em 0;
		width:200px;
		text-align:center
	}
	.captcha img {border:1px solid #F60; margin-bottom:0.5em}
	.captcha input {width:196px; margin-top:0.5em}

	/* Just a bit more room for the Submit button */
	.submit {margin-top:0.5em}
</pre>

<h3>Form Template Variables</h3>

<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you\&#039;d like.
   To make the form work, you\&#039;ll need to always include the &amp;#123;$fb_hidden} and &amp;#123;$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., &amp;#123;$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that\&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field\&#039;s name</td></tr>
<tr><td>field->input</td><td>the field\&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field\&#039;s input (useful for <label for=\&quot;\&quot;>)</td></tr>
<tr><td>field->type</td><td>the field\&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays \&quot;page x of y\&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>\&quot;Back\&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>\&quot;Continue\&quot; or \&quot;Submit\&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you\&#039;d want some of those, but there you go...</p>


<h3>Known Issues</h3>
<ul>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder cannot yet be inlined. That should be a simple upgrade down the line.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn\&#039;t matter since the user side is pretty simple.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you\&#039;re running CMS 1.0-svn or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you\&#039;re missing fields in an email that gets generated, check the disposition field\&#039;s template, and make sure you\&#039;re specifying the missing fields. Seems obvious, but it\&#039;s an easy mistake to make.</li>
<li>Uncheck the \&quot;Hide Errors\&quot; checkbox in the global options, and see what message gets displayed when you submit your form.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is no longer a particularly early version, but it is probably still buggy. While I\&#039;ve done all I can
to make sure no egregious bugs have crept in, I have to admit that during early testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor\&#039;s nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href=\"http://dev.cmsmadesimple.org\">Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href=\"mailto:sjg@cmsmodules.com\">&amp;lt;sjg@cmsmodules.com&amp;gt;</a>.</li>
<li>Additional discussion of this module may also be found in the <a href=\"http://forum.cmsmadesimple.org\">CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href=\"irc://irc.freenode.net/#cms\">CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &amp;copy; 2007, Samuel Goldstein <a href=\"mailto:sjg@cmsmodules.com\">&amp;lt;sjg@cmsmodules.com&amp;gt;</a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=\"http://www.gnu.org/licenses/licenses.html#GPL\">GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '<ul>
<li>Version 0.5.4. 29 Aug 08. Scrapping plans for 0.6. Bug fixes. Ted&#039;s new &quot;Email &quot;From Address&quot; Again Field&quot;. Added database indices.</li>
<li>Version 0.5.3. 26 May 08. Bugfixes to previous set of bugfixes. Now ready for major upgrades for 0.6.</li>
<li>Version 0.5.2. 25 May 08. Bugfixes. Release in preparation for substantial reworking for 0.6</li>
<li>Version 0.5.1. 30 April 08. Bugfixes, rewrote some of the File Upload code to prevent white screen of annoyance.</li>
<li>Version 0.5. 19 April 08. Bugfixes, support for FormBrowser fixes and features, disposition type for upcoming FormBrowser version.</li>
<li>Version 0.4.4. 26 Sept 07. Bugfixes for radio button groups, fix for validation of DispositionDeliverToEmailAddressField.</li>
<li>Version 0.4.3. 18 Sept 07. Bugfixes for pulldowns using numbers, option to inline form, fixes for table-layouts provided by Ap Muthu, fix for requirability of Dispositions.</li>
<li>Version 0.4.2. 14 Sept 07. Bugfixes for XML export, RadioButton Group submission, and HTML labels.</li>
<li>Version 0.4.1. Bugfixes for File Disposition Types.</li>
<li>Version 0.4
	<ul>
		<li>Upped minimum CMS version to 1.1</li>
		<li>Numerous Bug fixes; too many to enumerate here</li>
		<li>Massive rejiggering of code to work with CMS MS 1.1 parameter sanitizing regime</li>
		<li>Added field types: &quot;TextField (Multiple)&quot; and &quot;Computed Field&quot;</li>
		<li>Added dispositions: &quot;Save Results to File Based on Pulldown&quot; and &quot;Save Results to File(s) Based on Multiple Selections&quot;(Calguy)</li>
		<li>Added neat-o AJAX-y template-copying for Form Templates, gave versions of old table-based templates to soothe the raging masses.</li>
		<li>Added ability to pass default values to form elements from module tag using value_FIELDNAME=&quot;value&quot; syntax (Calguy)</li>
		<li>Added option to display field ids in admin (Calguy)</li>
	</ul>
</li>
<li>Version 0.3
   <ul>
      <li>Added Captcha module support.</li>
      <li>Reworked labeling of form elements to be XHTML compliant</li>
      <li>Added Paul Noone&#039;s new, improved contact form templates</li>
      <li>Implementation of Email Subject Field</li>
      <li>Added admin-specifiable values to hidden field type, which may contain parsable smarty tags</li>
      <li>Text Area Field now allows specification of rows and cols in the admin, instead of CSS</li>
      <li>Added Drag&#039;n&#039;Drop reordering of form fields.</li>
      <li>Added non-blank field name and unique field name global configuration options and validation</li>
      <li>Implemented templated display of form results upon submission in addition to page redirecting</li>
      <li></li>
   </ul>
</li>
<li>Version 0.2.4 - 09 May 2007
   <p>Big release:<ul>
   <li>Added &quot;Email Form to User-Supplied Address&quot; disposition.</li>
   <li>Added &quot;TimePicker&quot; field type. Split &quot;Link&quot; field into a &quot;User-supplied Link&quot; field and a &quot;Static Link&quot; field.</li>
   <li>Added HTML email option and auto-templates for all email dispositions.</li>
   <li>Added primitive anti-spam features.</li>
   <li>Added XML-based import and export of forms.</li>
   </ul>
   </p>
</li>
<li>Version 0.2.3
   <p>Add the ability to call a selectable user defined tag upon disposition of the form.</p>
</li>
<li>Version 0.2.2
   <p>Many thanks to Utter Design for sponsoring some changes and bugfixes, which include:
   <ul>
      <li>Added file upload capabilities to the email disposition</li>
      <li>Add PageSetStart and PageSetEnd field types
      <p>These field types allow you to create fieldsets in your form, and organise
      your fields logically for the user.  You can even nest fieldsets, and
      associate a style with them appropriately.  The default template was changed
      to prevent it from wrapping a div around these types of fields.
      </p>
      </li>
      <li>Fixed a problem with DATETIME fields on install
      <p>This solves a problem when on install the response table would sometimes not get created when using adodb lite</li>
      </li>
   </ul>
   </p>
</li>
<li>Version 0.2 - 14 November 2006. Calguy &amp;amp; tsw&#039;s bug fixes for field re-ordering and custom templates. Additional bug fixes for field labels.</li>
<li>Version 0.1 - 8 July 2006. Initial Release</li>
</ul>
';
$lang['utma'] = '156861353.292497676.1205805073.1222875714.1222881356.78';
$lang['utmz'] = '156861353.1222506840.75.14.utmcsr=dev.cmsmadesimple.org|utmccn=(referral)|utmcmd=referral|utmcct=/frs/admin/editrelease.php';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/de_DE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'FormBuilder';
$lang['field_type_'] = 'Feldtyp wurde nicht definiert';
$lang['field_type_CatalogerItemsField'] = 'W&auml;hlen Sie einen (oder mehrere) Cataloger-Eintr&auml;ge aus';
$lang['field_type_FieldsetEnd'] = '- Feldeinstellungen Ende';
$lang['field_type_FieldsetStart'] = '- Feldeinstellungen Start';
$lang['field_type_TextField'] = 'Textfeld';
$lang['field_type_TextFieldExpandable'] = 'Textfeld (Mehrfach)';
$lang['field_type_TextAreaField'] = 'Textbereich';
$lang['field_type_CheckboxField'] = 'Kontrollk&auml;stchen';
$lang['field_type_CheckboxGroupField'] = 'Kontrollk&auml;stchen-Gruppe';
$lang['field_type_PulldownField'] = 'Listenfeld';
$lang['field_type_MultiselectField'] = 'Mehrfachauswahl';
$lang['field_type_StatePickerField'] = 'Auswahl des U.S.-Staates';
$lang['field_type_ProvincePickerField'] = 'Auswahl der kanadischen Provinz';
$lang['field_type_CountryPickerField'] = 'Auswahl des Landes';
$lang['field_type_DatePickerField'] = 'Auswahl des Datums';
$lang['field_type_TimePickerField'] = 'Auswahl der Zeit';
$lang['field_type_RadioGroupField'] = 'Optionsfeld-Gruppe';
$lang['field_type_DispositionDirector'] = '*Ergebnisse per Email an Auswahl aus dem Listenfeld senden';
$lang['field_type_DispositionFileDirector'] = '*Ergebnisse in eine Datei aus der Listenfeldauswahl speichern';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Die Ergebnisse in Datei(en) aus der Mehrfachlisten-Auswahl speichern';
$lang['field_type_DispositionPageRedirector'] = '*Auf die Seite aus dem Listenfeld weiterleiten';
$lang['field_type_DispositionEmail'] = '*Ergebnisse per Email an vorgegebene Adresse(n) senden';
$lang['field_type_DispositionEmailConfirmation'] = '*&Uuml;berpr&uuml;fung &uuml;ber die Email-Adresse';
$lang['field_type_DispositionFile'] = '*Ergebnisse in eine Datei schreiben';
$lang['field_type_DispositionDatabase'] = '*Ergebnisse in der Datenbank speichern';
$lang['field_type_DispositionFormBrowser'] = '*Ergebnisse f&uuml;r das FormBrowser Module v.3 speichern';
$lang['field_type_DispositionUserTag'] = '*Einen benutzerdefinierten Tag mit den Ergebnissen als Parameter aufrufen';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Ergebnisse per Email an eine benutzerdefinierte Email-Adresse versenden';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Email an den CMS-Administrator';
$lang['field_type_PageBreakField'] = '- Seitenumbruch';
$lang['field_type_FileUploadField'] = 'Hochladen von Dateien';
$lang['field_type_FromEmailAddressField'] = 'Emailfeld &quot;Von (Email)&quot;';
$lang['field_type_FromEmailNameField'] = 'Emailfeld &quot;Von (Name)&quot;';
$lang['field_type_FromEmailSubjectField'] = 'Emailfeld &quot;Betreff&quot;';
$lang['field_type_StaticTextField'] = '- Statischer Text';
$lang['field_type_SystemLinkField'] = '- Statischer Link';
$lang['field_type_LinkField'] = 'Link (vom Benutzer eingegeben)';
$lang['field_type_HiddenField'] = '- Verborgenes Feld';
$lang['field_type_ComputedField'] = '- Berechnetes Feld';
$lang['field_type_UniqueIntegerField'] = '- Eindeutige Ganzzahl (Serie)';
$lang['validation_none'] = 'Keine &Uuml;berpr&uuml;fung';
$lang['validation_numeric'] = 'Nummerisch';
$lang['validation_integer'] = 'Ganzzahl';
$lang['validation_email_address'] = 'Email-Adresse';
$lang['validation_usphone'] = 'Telefonnummer (US)';
$lang['validation_must_check'] = 'Muss &uuml;berpr&uuml;ft werden';
$lang['validation_regex_match'] = 'Entspricht dem zul&auml;ssigen Wert';
$lang['validation_regex_nomatch'] = 'Entspricht nicht dem zul&auml;ssigen Wert';
$lang['required_field_missing'] = 'F&uuml;r ein Pflichtfeld wurde kein Wert eingegeben';
$lang['please_enter_a_value'] = 'Bitte geben Sie f&uuml;r &quot;%s&quot; einen Wert ein';
$lang['please_enter_a_number'] = 'Bitte geben Sie f&uuml;r &quot;%s&quot; eine Zahl ein ';
$lang['please_enter_valid'] = 'Bitte geben Sie f&uuml;r &quot;%s&quot; einen g&uuml;ltigen Wert ein';
$lang['please_enter_an_integer'] = 'Bitte geben Sie f&uuml;r &quot;%s&quot; einen ganzzahligen Wert ein ';
$lang['please_enter_an_email'] = 'Bitte geben Sie f&uuml;r &quot;%s&quot; eine g&uuml;ltige Email-Adresse ein ';
$lang['please_enter_a_phone'] = 'Bitte geben Sie f&uuml;r &quot;%s&quot; eine g&uuml;ltige Telefonnummer ein';
$lang['not_valid_email'] = '&quot;%s&quot; scheint keine g&uuml;ltige Emailadresse zu sein!';
$lang['please_enter_no_longer'] = 'Bitte geben Sie einen Wert ein, der nicht l&auml;nger als %s Zeichen ist ';
$lang['title_list_delimiter'] = 'Zeichen, das als Trenner verwendet wird, wenn mehr als ein Wert als Ergebnis zur&uuml;ckgegeben wird';
$lang['you_need_permission'] = 'Sie ben&ouml;tigen die Berechtigung &quot;%s&quot;, um diese Aktion auszuf&uuml;hren.';
$lang['lackpermission'] = 'Sie haben nicht die erforderliche Berechtigung, um auf diesen Bereich zuzugreifen.';
$lang['field_order_updated'] = 'Feldreihenfolge aktualisiert.';
$lang['form_deleted'] = 'Formular gel&ouml;scht.';
$lang['field_deleted'] = 'Feld gel&ouml;scht.';
$lang['configuration_updated'] = 'Konfigurationen aktualisiert.';
$lang['you_must_check'] = 'Bevor Sie weitermachen, m&uuml;ssen Sie &quot;%s&quot; &uuml;berpr&uuml;fen.';
$lang['must_specify_one_destination'] = 'Sie m&uuml;ssen hier mindestens eine Zieladresse angeben!';
$lang['are_you_sure_delete_form'] = 'Wollen Sie das Formular %s wirklich l&ouml;schen?';
$lang['are_you_sure_delete_field'] = 'Wollen Sie das Feld %s wirklich l&ouml;schen?';
$lang['notice_select_type'] = 'Die erweiterten Optionen sind erst verf&uuml;gbar, wenn der Feldtyp festgelegt wurde.';
$lang['field_name_in_use'] = 'Der Feldname &quot;%s&quot; wird bereits verwendet. Bitte verwenden Sie eindeutige Feldnamen oder deaktivieren die Verwendung eindeutiger Feldnamen in der FormBuilder-Konfiguration.';
$lang['field_no_name'] = 'Die Felder m&uuml;ssen einen Namen erhalten, oder Sie deaktivieren dies in der FormBuilder-Konfiguration.';
$lang['anonymous'] = 'Anonym';
$lang['abbreviation_length'] = 'L&auml;nge: %s';
$lang['boxes'] = '%s Kontrollk&auml;stchen';
$lang['options'] = '%s Optionen';
$lang['text_length'] = '%s Zeichen.';
$lang['order'] = 'Reihenfolge';
$lang['unspecified'] = '(nicht definiert)';
$lang['added'] = 'hinzugef&uuml;gt';
$lang['updated'] = 'aktualisiert';
$lang['sort_options'] = 'Optionen zur Sortierung bei der Ausgabe';
$lang['select_one'] = 'Bitte einen ausw&auml;hlen';
$lang['select_type'] = 'Einen Typ ausw&auml;hlen';
$lang['to'] = 'An';
$lang['yes'] = 'Ja';
$lang['no'] = 'Nein';
$lang['recipients'] = 'Empf&auml;nger';
$lang['file_count'] = '%s verf&uuml;gbare Dateien';
$lang['destination_count'] = '%s Ziele';
$lang['save'] = 'Speichern';
$lang['add'] = 'Hinzuf&uuml;gen';
$lang['update'] = 'Aktualisieren';
$lang['save_and_continue'] = 'Speichern und Bearbeitung fortsetzen';
$lang['information'] = 'Information';
$lang['automatic'] = 'Automatisch';
$lang['forms'] = 'Formulare';
$lang['form'] = 'Formular %s';
$lang['configuration'] = 'Konfiguration';
$lang['field_requirement_updated'] = 'Feldstatus aktualisiert.';
$lang['maximum_size'] = 'Max. Gr&ouml;&szlig;e';
$lang['permitted_extensions'] = 'Endungen';
$lang['permitted_filetypes'] = 'Erlaubte Dateitypen';
$lang['file_too_large'] = 'Die hochgeladene Datei ist zu gro&szlig;! Die maximale Gr&ouml;&szlig;e ist:';
$lang['illegal_file_type'] = 'Dieser Dateityp darf nicht hochgeladen werden. Bitte pr&uuml;fen Sie, ob die Dateiendung korrekt ist.';
$lang['upload'] = 'Hochladen';
$lang['form_imported'] = 'Formular importiert.';
$lang['form_import_failed'] = 'Formular-Import abgebrochen! Es ist ein Problem mit dem Format der XML-Datei aufgetreten.';
$lang['rows'] = '%s Zeilen';
$lang['cols'] = '%s Spalten';
$lang['12_hour'] = '12-Stunden-Anzeige';
$lang['24_hour'] = '24-Stunden-Anzeige';
$lang['hour'] = 'Stunde';
$lang['min'] = 'Minute';
$lang['merid'] = 'Meridian';
$lang['date_range'] = 'Bereich: %s - %s';
$lang['thanks'] = 'Vielen Dank! Ihre Eingaben wurden erfolgreich versandt.';
$lang['edit'] = 'Bearbeiten';
$lang['delete'] = 'L&ouml;schen';
$lang['day'] = 'Tag';
$lang['mon'] = 'Monat';
$lang['year'] = 'Jahr';
$lang['none'] = '(keine Angabe)';
$lang['uninstalled'] = 'Modul deinstalliert.';
$lang['installed'] = 'Modulversion %s installiert.';
$lang['upgraded'] = 'Modul auf Version %s aktualisiert.';
$lang['button_previous'] = 'Zur&uuml;ck ...';
$lang['button_submit'] = 'Formular absenden';
$lang['button_continue'] = 'Weiter ...';
$lang['value_checked'] = 'Gepr&uuml;ft';
$lang['value_unchecked'] = 'Ungepr&uuml;ft';
$lang['tab_main'] = 'Hauptseite';
$lang['tab_symbol'] = 'Einstellungen f&uuml;r die Formularanzeige';
$lang['tab_submit'] = 'Formular-Versand';
$lang['tab_captcha'] = 'Captcha-Einstellungen';
$lang['tab_advanced'] = 'Erweiterte Einstellungen';
$lang['tab_templatelayout'] = 'Formular-Template';
$lang['tab_submissiontemplate'] = 'Versand-Template';
$lang['canuse_smarty'] = '<em>In diesem Feld sind auch Smarty-Variablen g&uuml;ltige Werte.<em>';
$lang['add_options'] = 'Weitere Optionen hinzuf&uuml;gen';
$lang['delete_options'] = 'Markierte Optionen l&ouml;schen';
$lang['add_checkboxes'] = 'Weitere Kontrollk&auml;stchen hinzuf&uuml;gen';
$lang['delete_checkboxes'] = 'Markierte Kontrollk&auml;stchen l&ouml;schen';
$lang['add_address'] = 'Eine weitere Adresse hinzuf&uuml;gen';
$lang['delete_address'] = 'Markierte Adressen l&ouml;schen';
$lang['add_destination'] = 'Ein weiteres Ziel hinzuf&uuml;gen';
$lang['delete_destination'] = 'Markierte Ziele l&ouml;schen';
$lang['suspected_spam'] = 'Von Ihrer IP-Adresse wurden zu viele Emails generiert. Es wurde daher ein Anti-Spam-Code ausgegeben.';
$lang['suspected_spam_log'] = 'Verd&auml;chtiger Spam von der IP %s wurde gestoppt.';
$lang['reorder'] = 'Felder neu ordnen';
$lang['cancel'] = 'Abbrechen';
$lang['value_set'] = 'Wert gesetzt: %s';
$lang['help_cataloger_attribute_fields'] = 'Below is a list of the attributes available from the Cataloger module.<br/>You can optionally specify valid ranges, values, or numerous values to be used in filtering the list of items that is displayed to the user.<br/>
<br/>
<strong>Ranges:</strong><br/>
Ranges can be specified by signifying a minimum and maximum value using this syntax: &quot;range: minvalue to maxvalue&quot;<br/>
<br/>
<strong>Multiple Values:</strong><br/>
To specify multiple values for an attribute use the syntax &quot;multi: value1|value2|value3&quot;<br/>
<br/>
<strong>Values from hidden fields</strong><br/>
To specify a value from a hidden field use the syntax {$fld_id}<br/>
<br/>';
$lang['help_name_regex'] = 'A regular expression to allow filtering cataloger items by name';
$lang['help_field_height'] = 'Die H&ouml;he des Multiselect Feldes';
$lang['title_name_regex'] = 'Cataloger Item Name Regular Expression';
$lang['title_field_height'] = 'Feld H&ouml;he';
$lang['title_file_path'] = 'Zielverzeichnis f&uuml;r die ausgegebenen Dateien';
$lang['title_udt_name'] = 'Benutzerdefinierte Tags';
$lang['title_uploads_destpage'] = 'Seite, auf der der Uploads-Link dargestellt werden soll';
$lang['title_uploadmodule_summary'] = 'Mit dem FormBuilder-Modul versandt ';
$lang['title_uploads_category'] = 'Uploads-Kategorie';
$lang['title_sendto_uploads'] = 'Diese Datei an das Uploads-Modul &uuml;bergeben';
$lang['title_legend'] = 'Legende';
$lang['title_maximum_length'] = 'Maximale L&auml;nge';
$lang['title_checkbox_label'] = 'Beschriftung des Kontrollk&auml;stchens';
$lang['title_radio_label'] = 'Beschriftung des Optionsfeldes';
$lang['title_checked_value'] = 'Wert nach erfolgter Aktivierung';
$lang['title_unchecked_value'] = 'Wert ohne erfolgte Aktivierung';
$lang['title_checkbox_details'] = 'Details zur Kontrollk&auml;stchen-Gruppe';
$lang['title_delete'] = 'L&ouml;schen?';
$lang['title_select_one_message'] = 'Text f&uuml;r &quot;Bitte ausw&auml;hlen&quot;';
$lang['title_selection_value'] = 'Auswahl Wert';
$lang['title_selection_displayname'] = 'Auswahl des angezeigten Namens';
$lang['title_selection_subject'] = 'Auswahl des &quot;Betreffs&quot;';
$lang['title_select_default_country'] = 'Standardauswahl';
$lang['title_select_default_state'] = 'Standardauswahl';
$lang['title_select_default_province'] = 'Standardauswahl';
$lang['title_option_name'] = 'Name der Option';
$lang['title_option_value'] = '&Uuml;bermittelter Wert';
$lang['title_pulldown_details'] = 'Listenfeld-Optionen';
$lang['title_multiselect_details'] = 'Optionen zur Mehrfachauswahl';
$lang['title_destination_address'] = 'Ziel-Emailadresse';
$lang['title_destination_filename'] = 'Name der Zieldatei';
$lang['title_email_from_name'] = '&quot;Von (Name)&quot; der Email';
$lang['title_relaxed_email_regex'] = 'Lockere Email-&Uuml;berpr&uuml;fung verwenden';
$lang['title_relaxed_regex_long'] = 'Verwendet eine lockere &Uuml;berpr&uuml;fung der Email (erlaubt z. Bsp. &quot;x@y&quot; anstatt des erforderlichen &quot;x@y.de&quot;)';
$lang['title_email_from_address'] = '&quot;Von (Email-Adresse)&quot; der Email';
$lang['title_email_encoding'] = 'Zeichenkodierung der Email';
$lang['title_director_details'] = 'Listenfeldbasierte Email-Details';
$lang['title_file_name'] = 'Dateiname';
$lang['title_email_subject'] = 'Betreff-Zeile der Email';
$lang['title_form_name'] = 'Formularname';
$lang['title_form_status'] = 'Formularstatus';
$lang['title_ready_for_deployment'] = 'Einsatzbereit';
$lang['title_not_ready1'] = 'Nicht einsatzbereit';
$lang['title_redirect_page'] = 'Seite, auf die nach dem Versand gesprungen werden soll';
$lang['title_not_ready2'] = 'Bitte f&uuml;gen Sie ein Feld hinzu, mit dem die Benutzereingaben verarbeitet werden. Sie k&ouml;nnen';
$lang['title_not_ready_link'] = 'diese Tastenkombination verwenden,';
$lang['title_form_alias'] = 'Formular-Alias';
$lang['title_form_fields'] = 'Formularfelder';
$lang['title_field_id'] = 'Feld-ID';
$lang['title_show_fieldaliases'] = 'Den Feld-Alias anzeigen';
$lang['title_show_fieldaliases_long'] = 'Aktivieren Sie dies, wenn beim Bearbeiten des Formulars der Feld-Alias angezeigt werden soll';
$lang['title_field_name'] = 'Feldname';
$lang['title_field_alias'] = 'Feld-Alias';
$lang['title_radiogroup_details'] = 'Details zur Optionsfeld-Gruppe';
$lang['title_field_type'] = 'Feldtyp';
$lang['title_not_ready3'] = 'um ein Feld zur Formularverarbeitung zu erstellen.';
$lang['title_add_new_form'] = 'Neues Formular hinzuf&uuml;gen';
$lang['title_show_version'] = 'Version des FormBuilder-Moduls anzeigen?';
$lang['title_show_version_long'] = 'Als Hilfe zur Fehlerberseitigung wird die Versionsnummer des FormBuilder-Moduls in einem Kommentar eingebettet.';
$lang['title_add_new_field'] = 'Neues Feld hinzuf&uuml;gen';
$lang['title_form_submit_button'] = 'Text f&uuml;r den &quot;Absenden&quot;-Button';
$lang['title_submit_button_safety'] = 'Soll dem Versenden-Knopf ein Javascript hinzugef&uuml;gt werden, um den mehrfachen Versand des Formulars zu verhindern?';
$lang['title_submit_button_safety_help'] = 'Sicherheitsscript hinzuf&uuml;gen';
$lang['title_form_next_button'] = 'Text f&uuml;r den &quot;Weiter&quot;-Button (f&uuml;r mehrseitige Formulare)';
$lang['title_form_prev_button'] = 'Text f&uuml;r den &quot;Zur&uuml;ck&quot;-Button (f&uuml;r mehrseitige Formulare)';
$lang['title_field_validation'] = 'Feld-&Uuml;berpr&uuml;fung';
$lang['title_form_css_class'] = 'CSS-Klasse f&uuml;r dieses Formular';
$lang['title_field_css_class'] = 'CSS-Klasse f&uuml;r dieses Feld';
$lang['title_form_required_symbol'] = 'Symbol zur Kennzeichnung der Pflichtfelder';
$lang['title_field_required'] = 'Erforderlich';
$lang['title_field_required_long'] = 'Erfordert zwingend eine Antwort in diesem Feld';
$lang['title_hide_label'] = 'Beschriftung verbergen';
$lang['title_hide_label_long'] = 'Diesen Feldnamen im Formular verbergen';
$lang['title_text'] = 'Anzuzeigender statischer Text';
$lang['title_field_regex'] = 'Regex-&Uuml;berpr&uuml;fung';
$lang['title_lines_to_show'] = 'Anzahl der anzuzeigenden Zeilen';
$lang['no_default'] = 'Keine Voreinstellung';
$lang['redirect_after_approval'] = 'Seite, auf die nach &Uuml;berpr&uuml;fung weitergeleitet wird';
$lang['title_regex_help'] = 'This regular expression will only be used if &quot;validation type&quot; is set to a regex-related option. Include a full Perl-style regex, including the start/stop slashes and flags (z. Bsp. &quot;/image\.(\d+)/i&quot;)';
$lang['title_field_required_abbrev'] = 'Erforderl.';
$lang['title_hide_errors'] = 'Fehler verbergen';
$lang['title_form_displaytype'] = 'Anzeigetyp des Formulars';
$lang['title_hide_errors_long'] = 'Fehler-Meldungen vor den Benutzern verbergen.';
$lang['title_email_template'] = 'Email-Template';
$lang['title_maximum_size'] = 'Maximale Gr&ouml;&szlig;e f&uuml;r hochzuladende Dateien (kilobyte)';
$lang['title_maximum_size_long'] = 'Dieses Limit ist eine Erg&auml;nzung der Vorgaben aus der PHP- oder Server-Konfiguration.';
$lang['title_permitted_extensions'] = 'Zugelassene Datei-Endungen';
$lang['title_permitted_extensions_long'] = 'Geben Sie hier eine Aufz&auml;hlung der zugelassenen Datei-Endungen jeweils getrennt duch ein Komma ein (ohne Punkt - z.B. &quot;jpg,gif,jpeg&quot;). Leerzeichen werden ignoriert. Ohne Eintrag gelten keine Beschr&auml;nkungen.';
$lang['title_show_limitations'] = 'Beschr&auml;nkungen anzeigen?';
$lang['title_show_limitations_long'] = 'Beschr&auml;nkungen der Gr&ouml;&szlig;e und der Datei-Endungen mit dem Upload-Feld anzeigen?';
$lang['title_form_template'] = 'Template f&uuml;r die Formularanzeige';
$lang['title_page_x_of_y'] = 'Seite %s von %s';
$lang['title_no_advanced_options'] = 'Das Feld hat keine erweiterten Optionen.';
$lang['title_form_unspecified'] = 'Text, der bei ungenauen Eingaben zur&uuml;ckgegeben wird';
$lang['title_enable_fastadd_long'] = 'Aktiviert das schnelle Hinzuf&uuml;gen von Listenfeldern in Formularen';
$lang['title_enable_fastadd'] = 'Das schnelle Hinzuf&uuml;gen von Listenfeldern aktivieren?';
$lang['title_fastadd'] = 'Schnelle Felderstellung';
$lang['title_enable_antispam_long'] = 'Wenn Sie hier klicken, k&ouml;nnen von der vorgegebenen IP-Adresse maximal 10 Emails versandt werden (pro Stunde).';
$lang['title_enable_antispam'] = 'Einfachen Anti-Spam-Schutz aktivieren?';
$lang['title_show_fieldids'] = 'Feld-IDs anzeigen';
$lang['title_show_fieldids_long'] = 'Wenn Sie dieses Feld aktivieren, werden die Feld-IDs beim Bearbeiten des Formulars angezeigt';
$lang['title_xml_to_upload'] = 'Ein Formular als XML-Datei hochladen';
$lang['title_xml_upload_formname'] = 'Diesen Formularnamen verwenden';
$lang['title_import_legend'] = 'XML-Formular-Import';
$lang['title_xml_upload_formalias'] = 'Diesen Formular-Alias verwenden';
$lang['title_html_email'] = 'Eine HTML-Email erzeugen?';
$lang['title_link_autopopulate'] = 'Automatisch ver&ouml;ffentlichen?';
$lang['title_link_autopopulate_help'] = 'Automatisch mit der URL der Formularseite ver&ouml;ffentlichen? (dies &uuml;berschreibt die weiter unten benannte Seiten-Link-Option)';
$lang['title_default_link'] = 'Standard-Link-URL';
$lang['title_default_link_title'] = 'Standard-Link-Text';
$lang['title_link_to_sitepage'] = 'Link auf die Seite';
$lang['title_captcha_not_installed'] = 'Wenn Sie das Captcha-Modul installieren, k&ouml;nnen Sie &uuml;ber ein <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a> Ihr Formular vor Spam sch&uuml;tzen. Weitere Informationen finden Sie im <a href="http://dev.cmsmadesimple.org/projects/captcha/">Captcha-Project</a>.';
$lang['title_use_captcha'] = 'Captcha verwenden, um den Formularversand zu sch&uuml;tzen?';
$lang['title_use_captcha_help'] = 'Klicken Sie hier, um Ihr Formular mittels <a href="http://www.wikipedia.org/wiki/Captcha" target="_BLANK">&quot;Captcha&quot;</a> vor Spam zu sch&uuml;tzen.';
$lang['title_user_captcha'] = 'Bitte best&auml;tigen Sie, dass Sie kein maschinelles Script sind, indem Sie die Buchstaben aus dem Bild eingeben.';
$lang['title_user_captcha_error'] = 'Text bei falsch eingegebenem Captcha';
$lang['wrong_captcha'] = 'Der eingegebene Captcha-Text war falsch.';
$lang['title_title_user_captcha'] = 'Hilfetext f&uuml;r Captcha';
$lang['title_dont_submit_unchecked'] = 'Don&#039;t submit values for unchecked boxes';
$lang['title_dont_submit_unchecked_help'] = 'Check this if you only want checked boxes to return values.';
$lang['link_label'] = 'Beschriftung des Links';
$lang['link_destination'] = 'Ziel-URL des Links';
$lang['title_default_set'] = 'Standardm&auml;&szlig;ig &uuml;berpr&uuml;fen?';
$lang['title_24_hour'] = '24-Stunden-Anzeige verwenden?';
$lang['title_before_noon'] = 'A.M.';
$lang['title_after_noon'] = 'P.M.';
$lang['title_smarty_eval'] = 'Smarty-Tags in den Feldern verarbeiten?';
$lang['title_textarea_rows'] = 'Zeilen (Hinweis: Dies kann durch CSS &uuml;berschrieben werden)';
$lang['title_textarea_cols'] = 'Spalten (Hinweis: Dies kann durch CSS &uuml;berschrieben werden)';
$lang['title_form_main'] = 'Details des Hauptformulars';
$lang['title_show_username'] = 'Den Login-Namen des Benutzers anzeigen?';
$lang['title_show_userfirstname'] = 'Den Vornamen des Benutzers anzeigen?';
$lang['title_show_userlastname'] = 'Den Nachnamen des Benutzers anzeigen?';
$lang['title_restrict_to_group'] = 'Die Benutzerliste auf Benutzer der spezifizierten Gruppe beschr&auml;nken';
$lang['restricted_to_group'] = 'Nur in Gruppe %s';
$lang['title_show_to_user'] = 'Dem Benutzer anzeigen?';
$lang['help_leaveempty'] = 'Dieses Feld kann leer gelassen werden';
$lang['help_variables_for_template'] = 'Variablen f&uuml;r das Template';
$lang['help_variables_for_computation'] = 'Verf&uuml;gbare Variablen';
$lang['help_php_variable_name'] = 'PHP-Variable';
$lang['help_submission_date'] = 'Versanddatum';
$lang['help_server_name'] = 'Ihr Server';
$lang['help_sub_source_ip'] = 'IP-Adresse des Formularabsenders';
$lang['help_sub_url'] = 'URL der Formularseite';
$lang['help_fb_version'] = 'FormBuilder Version';
$lang['help_tab'] = 'Tab-Zeichen';
$lang['help_other_fields'] = 'Alternative Feldnamen k&ouml;nnen wechselweise verwendet werden (dies ist insbesondere n&uuml;tzlich, wenn Smarty Probleme mit Zeichen au&szlig;erhalb von ASCII 32-126 hat). <br />Wenn Sie diese dem Formular hinzuf&uuml;gen, sind weitere Felder verf&uuml;gbar.';
$lang['help_array_fields'] = 'Auf Felder, die mehrere Werte haben, kann via Smarty &uuml;ber $feldname_array oder $fld_#_array zugegriffen werden.';
$lang['help_date_format'] = 'Informationen zur Formatierung finden Sie <a href="http://www.php.net/manual/en/function.date.php" target="_BLANK">in der PHP-Beschreibung</a>.';
$lang['help_variable_name'] = 'Variable';
$lang['help_form_field'] = 'Feld repr&auml;sentiert';
$lang['link_back_to_form'] = '&amp;#171; Zur&uuml;ck zum Formular';
$lang['title_create_sample_template'] = 'Ein Beispiel-Template erstellen';
$lang['title_create_sample_html_template'] = 'Ein Beispiel-HTML-Template erstellen';
$lang['title_create_sample_header_template'] = 'Eine Beispiel-Header-Vorlage erstellen';
$lang['title_create_sample_header'] = 'Einen Muster-Header erstellen';
$lang['help_tab_symbol'] = 'ein Tab-Zeichen';
$lang['title_file_template'] = 'Template f&uuml;r eine Zeile der ausgegebenen Datei';
$lang['title_file_header'] = 'Template f&uuml;r den Header der ausgegebenen Datei';
$lang['title_confirmation_url'] = 'URL zur Best&auml;tigung des Formulars';
$lang['title_value'] = 'Wert (siehe Registerkarte Erweiterungen, wenn Sie Smarty-Tags verwenden)';
$lang['title_date_format'] = 'Datums-Format (siehe <a href="http://www.php.net/manual/en/function.date.php" target="_blank">PHP Datumsformat</a>)';
$lang['title_use_wysiwyg'] = 'WYSIWYG-Editor f&uuml;r den Textbereich verwenden (nur in der Administration)?';
$lang['title_submit_actions'] = 'Verhalten nach dem Formular-Versand';
$lang['title_submit_labels'] = 'Beschriftung der Versand-Button';
$lang['title_sortable_field'] = 'Sortierbares Feld #%s';
$lang['title_submit_help'] = 'Auf dieser Seite k&ouml;nnen Sie den Formularversand anpassen. (Es wird jedoch nicht festgelegt, wie die versandten Daten verarbeitet werden. Dies k&ouml;nnen Sie festlegen, indem Sie Ihrem Formular ein Feld &quot;Disposition&quot; hinzuf&uuml;gen.)';
$lang['title_start_year'] = 'Jahresbereich Beginn';
$lang['title_end_year'] = 'Jahresbereich Ende';
$lang['title_default_year'] = 'Voreingestelltes Jahr';
$lang['title_default_year_help'] = '(Mit -1 wird das aktuelle Jahr als Voreinstellung verwendet)';
$lang['title_submit_action'] = 'Nachdem das Formular versandt wurde';
$lang['title_submit_response'] = 'Anzuzeigende Antwort';
$lang['display_text'] = '&quot;Versand-Template&quot; anzeigen';
$lang['redirect_to_page'] = 'Weiterleiten auf die Seite';
$lang['title_submit_response_help'] = 'Dieses Template wird angezeigt, nachdem das Formular versandt wurde. Dieses Template wird nicht verwendet, um Emails zu erzeugen oder andere Formular-Optionen auszuf&uuml;hren. Falls erw&uuml;nscht, k&ouml;nnen Sie diese Templates (falls erw&uuml;nscht) in der &quot;erweiterten&quot; Registerkarte f&uuml;r diese Felder festlegen.';
$lang['title_destination_page'] = 'Zielseite';
$lang['title_require_fieldnames'] = 'Erfordert Feldnamen';
$lang['title_require_fieldnames_long'] = 'Soll f&uuml;r die Felder ein Name festgelegt werden?';
$lang['title_unique_fieldnames'] = 'Erfordert eindeutige Feldnamen';
$lang['title_unique_fieldnames_long'] = 'Soll f&uuml;r die Felder ein eindeutiger Name festgelegt werden?';
$lang['title_reorder_form'] = 'Felder neu ordnen';
$lang['title_load_template'] = 'Template laden';
$lang['title_add_button_text'] = 'Einen Button-Text hinzuf&uuml;gen';
$lang['title_del_button_text'] = 'Den Button-Text l&ouml;schen';
$lang['title_string_or_number_eval'] = 'Variablen als Zahl oder String interpretieren';
$lang['title_order'] = 'Interpretations-Reihenfolge';
$lang['title_order_help'] = 'Wenn mehr als ein Feld berechnet werden muss, werden die Berechnung von der niedrigsten zur h&ouml;chsten Ordnungsnummer hin durchgef&uuml;hrt';
$lang['title_compute_value'] = 'Zu berechnender Wert';
$lang['title_string'] = 'Zeichenkette';
$lang['title_numeric'] = 'Zahl';
$lang['title_inline_form'] = 'Das Formular inline anzeigen?';
$lang['title_inline_form_help'] = 'Inline bedeutet, dass das Formular den {cms_module}-Tag ersetzt, anderenfalls wird der {content}-Tag ersetzt.';
$lang['title_field_default_value'] = 'Standardwert f&uuml;r Felder';
$lang['title_clear_default'] = 'Bei Klick auf das Feld die voreingestellten Werte entfernen?';
$lang['title_clear_default_help'] = 'Aktivieren Sie dieses Feld, wenn der voreingestellte Wert bei Klick auf das Feld entfernt werden soll';
$lang['title_remove_file_from_server'] = 'Delete uploaded file from server after processing (email dispositions)';
$lang['title_field_javascript'] = 'Javascript f&uuml;r Feld';
$lang['title_field_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;';
$lang['title_submit_javascript'] = 'Javascript f&uuml;r den Formularversand';
$lang['title_submit_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;.<br />This will probably not work well if you use the &quot;safety script&quot; option above.';
$lang['email_from_addr_help'] = 'Do not just pick a random address here -- many ISPs will<br />not deliver the mail if you are using a different domain name than your actual<br />host name (i.e., use something like name@%s)';
$lang['title_switch_advanced'] = 'Werden mehr Feldtypen ben&ouml;tigt?';
$lang['title_switch_basic'] = 'Zu viele verwirrende Feldtypen?';
$lang['title_switch_advanced_link'] = 'Zu erweiterten Modus wechseln';
$lang['title_switch_basic_link'] = 'Zu einfachen Modus wechseln';
$lang['title_file_root'] = 'Datei in folgendem Verzeichnis speichern';
$lang['title_file_root_help'] = 'This needs to be a directory that your web server has permissions to write in.<br />Chmod it 777 if you have problems/doubts.<br />Also, check to see that you do not have PHP directory restrictions.';
$lang['error_cataloger_module_not_available'] = '<strong>Das &quot;Cataloger&quot; Modul scheint nicht installiert zu sein.</strong>';
$lang['warning'] = 'WARNUNG!';
$lang['default_template'] = 'Standard-Template';
$lang['table_left_template'] = 'Tabellen-Template, Titel links';
$lang['table_top_template'] = 'Tabellen-Template, Titel oben';
$lang['form_template_name'] = 'Template von %s';
$lang['template_are_you_sure'] = 'Wollen Sie wirklich Ihr Template mit dem ausgew&auml;hlten Template &uuml;berschreiben? (Auch, wenn Sie dies best&auml;tigen, m&uuml;ssen Sie die &Auml;nderung speichern)';
$lang['title_bad_function'] = 'Fehler beim Berechnen von &quot;%s&quot;.';
$lang['no_referrer_info'] = 'Keine Informationen &uuml;ber den HTTP_REFERER verf&uuml;gbar (wahrscheinlich aufgrund der verwendeten Email-Pr&uuml;fung)';
$lang['validation_param_error'] = 'Fehler beim &Uuml;berpr&uuml;fen der Parameter. Bitte stellen Sie sicher, dass die URL aus Ihrer Email korrekt kopiert wurde!';
$lang['validation_response_error'] = 'Fehler bei der &Uuml;berpr&uuml;fung. Bitte stellen Sie sicher, dass die URL aus Ihrer Email korrekt kopiert wurde!';
$lang['validation_no_field_error'] = 'Fehler bei der &Uuml;berpr&uuml;fung. Dieses Formular enth&auml;lt kein Feld zur &Uuml;berpr&uuml;fung der Email!';
$lang['upgrade03to04'] = 'Form Template was updated automatically as part of the version 0.3 to version 0.4 upgrade. You may need to make some fixes. If you&#039;re using the default form, simply replace this template with &quot;default&quot; using the pulldown above.';
$lang['admindesc'] = 'Hinzuf&uuml;gen, Bearbeiten und Verwalten von interaktiven Formularen';
$lang['operators_help'] = 'If you use String evaluation, the only operation available is concatenation (+), while if you use Number evaluation you have basic, very simple math (, +, -, *, /, ).';
$lang['date_january'] = 'Januar';
$lang['date_february'] = 'Februar';
$lang['date_march'] = 'M&auml;rz';
$lang['date_april'] = 'April';
$lang['date_may'] = 'Mai';
$lang['date_june'] = 'Juni';
$lang['date_july'] = 'Juli';
$lang['date_august'] = 'August';
$lang['date_september'] = 'September';
$lang['date_october'] = 'Oktober';
$lang['date_november'] = 'November';
$lang['date_december'] = 'Dezember';
$lang['submission_error'] = 'Bei der Verarbeitung des versandten Formulars ist ein Fehler aufgetreten.';
$lang['submit_error'] = 'Fehler beim Versand: %s';
$lang['uploads_error'] = 'Fehler bei der &Uuml;bergabe der Datei an das Uploads-Modul: %s';
$lang['nouploads_error'] = 'Konnte das Uploads-Modul nicht finden';
$lang['upload_attach_error'] = 'Fehler beim Hochladen der Datei %s (tempor&auml;rer Name %s des Typs %s)';
$lang['submission_error_file_lock'] = 'Fehler. Datei konnte nicht gesperrt werden.';
$lang['unchecked_by_default'] = 'Standard: nicht ausgew&auml;hlt';
$lang['checked_by_default'] = 'Standard: ausgew&auml;hlt';
$lang['email_default_template'] = 'FormBuilder-Versand';
$lang['email_template_not_set'] = '<br/>Das Email-Template wurde noch nicht festgelegt!';
$lang['missing_cms_mailer'] = 'FormBuilder: Konnte das erforderliche CMSMailer-Modul nicht finden!';
$lang['user_approved_submission'] = 'Benutzergepr&uuml;fte &Uuml;bermittlung %s von %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Ausf&uuml;hren, wenn ein Formular mit FormBuilder versandt wurde';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Ausf&uuml;hren, wenn beim Versand eines FormBuilder-Formulars ein Fehler aufgetreten ist';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Ausf&uuml;hren, wenn ein FormBuilder-Formular angezeigt wurde';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Ausf&uuml;hren, wenn ein Formular mit FormBuilder versandt wurde.</p>
<h4>Parameter</h4>
<ul>
<li><em>form_name</em> - der Name des Formulars (string)</li>
<li><em>form_id</em> - die interne ID des Formulars (int)</li>
<li><em>value_<name></em> - &uuml;bermittelt einen vorgegebenen Wert an ein festgelegtes Feld.</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Ausf&uuml;hren, wenn beim Versand eines FormBuilder-Formulars ein Fehler aufgetreten ist</p>
<h4>Parameter</h4>
<ul>
<li><em>form_name</em> - Name des Formulars (string)</li>
<li><em>form_id</em> - interne ID des Formulars (int)</li>
<li><em>error</em> - eine Liste aller bekannte Fehler (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Ausf&uuml;hren, wenn ein FormBuilder-Formular angezeigt wurde</p>
<h4>Parameter</h4>
<ul>
<li><em>form_name</em> - Name des Formulars (string)</li>
<li><em>form_id</em> - interne ID des Formulars (int)</li>
</ul> ';
$lang['formbuilder_params_response_id'] = 'Response-ID. Wird vom FormBrowser-Modul verwendet';
$lang['formbuilder_params_passed_from_tag'] = 'Standardwerte der Felder; siehe Modul-Hilfe';
$lang['formbuilder_params_field_id'] = 'Feld-ID f&uuml;r interne Operationen';
$lang['formbuilder_params_form_name'] = 'Formular-Name';
$lang['formbuilder_params_form_id'] = 'Formular-ID f&uuml;r interne Operationen';
$lang['formbuilder_params_general'] = 'Allgemeine Parameter f&uuml;r interne Operationen';
$lang['template_variable_help'] = '<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the &amp;#123;$fb_hidden} and &amp;#123;$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., &amp;#123;$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>';
$lang['post_install'] = '<p>Stellen Sie sicher, dass die Berechtigung &quot;Modify Forms&quot; 
f&uuml;r die Benutzer gesetzt ist, welche die Feedback-Formulare administrieren werden. Sollen die Werte aus dem Formular per Email versandt werden, 
stellen Sie ebenfalls sicher, dass die Konfiguration entsprechend aktualisiert wurde.</p>
<p>ACHTUNG: W&auml;hrend der Bearbeitung darf das jeweilige Feedback-Formular 
Bearbeitung nicht aktiv sein (=nutzbar f&uuml;r die G&auml;ste Ihrer Homepage). Sie sollten daher den Feedbackformular-Tag erst dann in eine aktive Inhaltsseite einf&uuml;gen, wenn das Formular komplett erstellt ist. Anderenfalls kann es zu fehlerhaften Ergebnissen kommen.</p>
<p>Hinweis: Diese Version unterst&uuml;tzt keine parallele Bearbeitung von Formularen durch mehrere Administratoren. Stellen Sie daher sicher, dass ein Formular jeweils nur von einem Administrator bearbeitet wird.</p>';
$lang['help'] = '<h3>Was macht dieses Modul?</h3>
<p>Das FormBuilder-Modul erlaubt Ihnen, Feedback-Formulare zu erstellen (logisch, es ist der Nachfolger des FeedbackForm-Moduls), erweitert um die F&auml;higkeit, eingegebene Daten auch in einer Datenbank ablegen zu k&ouml;nnen. Zusammen mit dem FormBrowser-Modul k&ouml;nnen Sie einsetzen, um einfache Datenbank-Anwendungen selbst zu erstellen.</p>
<p>Die von FormBuilder erzeugten Formulare k&ouml;nnen in Templates 
und/oder Seiten eingef&uuml;gt werden. In die Formular k&ouml;nnen verschiedene Arten von Daten eingegeben werden. Diese Eingaben 
<p>Formularfeldern werden Namen zugewiesen. Diese Namen identifizieren Ihre Formularfelder, nicht nur auf dem Bildschirm als Bezeichnungen die dem Benutzer dienen, sondern auch in den Daten wenn sie verschickt werden. Damit wird sichergestellt dass Sie das sehen was der Nutzer eingegeben hat. <br>
Den Namen wie eine Frage zu gestalten ist eine sehr handliche Art und Weise dem Nutzer zu vermitteln was hier von ihm erwartet wird. <br>
Viele Felder haben beides, Namen und Werte. Die Namen, die dem Nutzer angezeigt werden und die Werte, das sind die die gespeichert werden wenn der Nutzer das Formular abschickt. Die Werte sind weder vom Benutzer einsehbar noch im HTML, somit ist es sicher sie f&uuml;r Emailadressen usw. zu verwenden. </p>
<p>Einige Felder k&ouml;nnen mehrere Werte oder Namen/Werte Paare haben. Wenn Sie zuerst ein solches Feld erstellen, kann es m&ouml;glich sein, dass nicht gen&uuml;gend Eingabefelder vorhanden sind, um die Werte einzutragen. Um mehr M&ouml;glichkeiten zu erhalten Werte einzutragen, benutzen Sie den Schalter am unteren Ende der Seite f&uuml;r weitere Optionen.</p>
<p>Feldern k&ouml;nnen Validierungsregeln zugewiesen werden, welche je nach Feldtyp unterschiedlich sein k&ouml;nnen. Diese Regeln helfen sicherzustellen dass der Nutzer g&uuml;ltige Daten eingibt. Au&szlig;erdem ist es m&ouml;glich, Felder seperat mit einem &quot;wird ben&ouml;tigt&quot; zu markieren, damit wird der Nutzer sozusagen &quot;gezwungen&quot; Eingaben zu machen. </p>
<p>Feldern k&ouml;nnen auch CSS-Klassen zugewiesen werden. Es werden die Eingabefelder mit einem DIV Tag und dazugeh&ouml;riger CSS-Klasse umgeben; somit k&ouml;nnen Sie Ihr Formular selbst gestalten. Um dies effizient nutzen zu k&ouml;nnen, sollten in den Quelltext des Formulares gehen und dann Ihren CSS-Code schreiben. </p>
<ul>
<li>Standard Eingabefelder
  <ul>
    <li>Text Eingabefeld. Dies ist das Standard Eingabefeld. Sie k&ouml;nnen die L&auml;nge der eigegebenen Zeichen w&auml;hlen und verschiedene Validierungsfunktionen auf diese Feld anwenden.</li>
    <li>Textbereich. Dies ist ein gro&szlig;es formfreies Texteingabefeld.</li>
    <li>Checkbox. Das ist die Standard Checkbox.</li>
    <li>Checkbox Gruppe. Das ist eine Sammlung von Checkboxen. Der einzige Unterschied besteht darin, dass dies eine Gruppe von Checkboxen mit einem Namen ist. Weiterhin k&ouml;nnen Sie einen oder mehrere als &quot;wird ben&ouml;tigt&quot; markieren. Somit ist der Nutzer &quot;gezwungen&quot; eine oder mehrere Checkboxen dieser Gruppe auszuw&auml;hlen.</li>
    <li>Radio Button Gruppe. Das ist eine Sammlung von Radio Buttons. Nur ein Radio Button in der Gruppe kann ausgew&auml;hlt werden.</li>
    <li>Pulldown. Das ist ein Standard Pulldown Men&uuml;. Vom Konzept her gesehen das gleiche wie die Radio Button Gruppe, aber besser wenn Sie viele Auswahlm&ouml;glichkeiten haben.</li>
    <li>Mehrfachauswahl. Das ist das Mehrfachauswahl Feld. Vom Konzept her gesehen das gleiche wie die Radio Button Gruppe, aber besser wenn Sie viele Auswahlm&ouml;glichkeiten haben und die Auswahl aber begrenzen m&ouml;chten.</li>

    <li>Bundesstaat. Dies ist eine Pulldown Liste mit s&auml;mtlichen Bundesstaaten der USA.</li>
<li>L&auml;nder. Dies ist eine Pulldown Liste s&auml;mtlicher sich auf der Erde befindlichen L&auml;nder.</li>
<li>Datumsauswahl. Dies ist eine dreifach Pulldown Liste, die dem Nutzer die M&ouml;glichkeit gibt ein Datum auzuw&auml;hlen.</li>
</ul></li>

<li>Email-spezifische Eingabefelder
  <ul>
    <li>Email Von  Adress Feld. Hier k&ouml;nnen Sie Ihre Emailadresse eingeben. Diese wird in der generierten Email im Feld Von (Mailadresse): angegeben.</li>
    <li>Email Von Name Feld. Hier k&ouml;nnen Sie Ihren Namen eingeben. Diese wird in der generierten Email im Feld Name (Absendername): angegeben.</li>

</ul></li>

<li>Kontrollfelder f&uuml;r die Anzeige<ul>
<li>Seitenumbruch - das erm&ouml;glicht Ihnen die Aufteilung Ihres Feedback-Formulars in mehrere Seiten. Die Eingaben jeder Seite werden
unabh&auml;ngig voneinander gepr&uuml;ft. Das ist insbesondere bei Online-Umfragen &auml;u&szlig;erst vorteilhaft.</li>
<li>-Statischer Text. Damit k&ouml;nnen Sie Ihrem Formular einfachen Text hinzuf&uuml;gen oder es beschriften. Dies ist f&uuml;r Ausf&uuml;llhinweise, Hilfen usw. sehr n&uuml;tzlich, insbesondere wenn Sie f&uuml;r die Anzeige des Formulars kein angepasstes Template verwenden.</li>
</ul></li>

<li>Formular &#039;Handling&#039;
  <ul>
    <li>*Email Ergebnis basierend auf dem Pulldown. Dies ist hilfreich f&uuml;r Internetseiten wo Kommentare &uuml;ber die Angelegenheit in den Betreff geschrieben werden. z.B. Bugs werden zum Entwickler gesendet, Marketing Fragen zu einer Person, Fragen zum Verkauf zu einer anderen Peson usw. Das Pulldown Men&uuml; wird mit Betreffs hinterlegt und jeder wird zu einer spezifischen Mailadresse versandt. Sie erstellen den jeweiligen Betreff wenn Sie ein solches Feld erstellen oder editieren. Wenn Sie ein solches Pulldown Men&uuml; benutzen, muss der Nutzer eine Auswahl des Betreffs w&auml;hlen um das Formular abschicken zu k&ouml;nnen. Dieses Auswahlfeld ist f&uuml;r den Nutzer sichtbar aber die Mailadressen die dahinter stehen werden weder Ihm noch im HTML angezeigt.</li>

    <li>*Email Ergebnis an Adresse(n) senden. Dies sendet die Daten an eine vorher angegebene Mailadresse. Die Mailadresse(n) k&ouml;nnen Sie angeben wenn Sie ein solches Feld generieren. Das Feld und der Name ist f&uuml;r den Nutzer nicht sichtbar. Auch nicht im Quelltext.</li>
    <li>*Daten in Datenbank speichern. Dies speichert die abgegebenen Daten in einer internen Datenbank. Diese Einstellung verwenden Sie meisten in Verbindung mit dem Modul FormBrowser.</li>
    <li>*Validierung &uuml;ber die Mailadresse. Dies ist ein sehr leistungsf&auml;higes Feld. Es stellt dem Benutzer ein vorgegebenes Eingabefeld f&uuml;r seine Mailadresse zur Verf&uuml;gung. Wenn dieser das Formular abschickt wird die &Uuml;bermittlung nicht direkt ausgef&uuml;hrt, sondern schickt dem Nutzer eine Mail mit einem codierten Link. Erst wenn dieser Link gedr&uuml;ckt wird wird das Formular validiert und die Eingaben abgeschickt.</li>
    <li>*In Datei Schreiben. Diese Option greift die Daten ab und schreibt sie in eine Textdatei. Sie k&ouml;nnen den Namen und das Dateiformat bestimmen. Diese Dateien werden in das Ausgabeverzeichnis des Modul Installations Verzeichnisses geschrieben. Vorrausgesetzt ist, dass der Server die notwendigen Schreibrechte vergeben hat.
    </ul></li></li></ul>

<h3>Templates f&uuml;r Email und einfache Dateien</h3>
<p>Man disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. Wenn Sie selbst kein Template erstellen wollen, wird FormBuilder die nach seiner Einsch&auml;tzung beste L&ouml;sung verwenden, die so funktioniert, wie Sie wollen oder auch nicht. Sie k&ouml;nnen jederzeit auf &quot;Ein Muster-Template erstellen&quot; klicken und dann die Ergebnisse anpassen.</p>
<p>Beachten Sie, dass neu hinzugef&uuml;gte Felder nicht mehr automatisch dem Template hinzugef&uuml;gt werden, wenn es einmal ge&auml;ndert wurde. Aus diesem Grund ist es das Beste, wenn Sie erst zum Schluss das Template f&uuml;r das Formular erstellen.</p>

<h3>Bekannte Probleme</h3>
<ul>
<li>Einige Feldtypen, die im FeedbackForm-Modul enthalten waren, sind in FormBuilder nicht implementiert. Wenn ein Bedarf f&uuml;r diese Felder vorhanden ist, werde ich sie hinzugef&uuml;gen.</li>
<li>Das FormBuilder-Modul kann gegenw&auml;rtig noch nicht auf die Daten des FrontendUsers-Moduls zugreifen. Dies ist aber geplant.</li>
<li>FormBuilder unterst&uuml;tzt gegenw&auml;rtig noch keine Pretty URLs, dies sollte jedoch kein Problem sein, da die Ausgaben Benutzerseite sehr einfach gehalten ist.</li>
</ul>

<h3>Fehlersuche</h3>
<ol><li> Als erstes sollten Sie pr&uuml;fen, ob Sie CMSms in einer Version > 1.0 verwenden.</li>
<li> Im zweiten Schritt sollten Sie die Probleme bei der Verwendung von WYSIWYG-Editoren im Abschnitt
 <em>Ein Formular einer Seite hinzuf&uuml;gen</em> lesen und verstehen.</li>
<li>Wenn Sie in einer von FormBuilder generierten Email bestimmte Felder vermissen, &uuml;berpr&uuml;fen Sie, ob die Felder im Template enthalten sind, und stellen Sie sicher, dass Sie die fehlenden Felder auch tats&auml;chlich definiert haben. Auch wenn es nicht klar ersichtlich scheint, kann es durchaus nur ein ganz einfacher Fehler sein.</li>
<li> Versuchen Sie, auf Links und Icons zu klicken und beobachten genau, was passiert.</li>
<li> Die letzte M&ouml;glichkeit ist, mir das Problem per Email mitzuteilen oder mich im IRC-Chat anzusprechen, damit wir das Problem gemeinsam beheben.</li>
</ol> 
<p>Dies ist eine sehr fr&uuml;he Version, ein ungetestetes Beta-Release, und sehr wahrscheinlich ist es fehlerhaft. Obwohl ich alles getan habe, was ich konnte, 
um sicherzustellen, dass sich keine gr&ouml;&szlig;eren &quot;Wanzen&quot; eingeschlichen haben, musste ich w&auml;hrend des Testens feststellen, dass das Programm 
sieben Kakerlaken, zwei Ohrw&uuml;rmer, eine kleine Familie von Blattl&auml;usen und eine Wanderstabheuschrecke enthielt. Sie fra&szlig;en auch
Nachbars b&ouml;sen kleinen kl&auml;ffenden Hund, wof&uuml;r ich unendlich dankbar war.</p>
<p>Das finale Release wird Bugfixes, eine Dokumentation und unbedingte Liebe enthalten.</p>
<h3>Support</h3>
<p>Dieses Modul beinhaltet keinen kommerziellen Support. Sie k&ouml;nnen jedoch &uuml;ber die folgende Wege Hilfe zu dem Modul erhalten:</p>
<ul>
<li>F&uuml;r die letzte Version dieses Moduls, FAQs, dem Versand eines Fehlerreports oder dem Kauf kommerziellen Support besuchen sie bitte calguys Homepage unter <a href="http://techcom.dyndns.org">techcom.dyndns.org</a>.</li>
<li>Eine weitere Diskussion zu diesem Modul ist auch in den Foren von <a href="http://forum.cmsmadesimple.org">CMS Made Simple</a> zu finden.</li>
<li>Der Autor calguy1000, ist h&auml;ufig im <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a> zu finden.</li>
<li>Letztlich erreichen Sie den Autor auch &uuml;ber eine direkte Email.</li>  
</ul>
<p>Nach der GPL wird diese Software so ver&ouml;ffentlicht, wie sie ist. Bitte lesen Sie den Lizenztext f&uuml;r den vollen Haftungsausschluss.</p>
<h3>Copyright und Lizenz</h3>
<p>Copyright &copy; 2006, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. Alle Rechte vorbehalten.</p>
<p>Dieses Modul wurde unter der <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a> ver&ouml;ffentlicht. Sie m&uuml;ssen dieser Lizenz zustimmen, bevor Sie das Modul verwenden.</p>';
$lang['changelog'] = '<ul>
<li>Version 0.5.3. 26 May 08. Bugfixes to previous set of bugfixes. Now ready for major upgrades for 0.6.</li>
<li>Version 0.5.2. 25 May 08. Bugfixes. Release in preparation for substantial reworking for 0.6</li>
<li>Version 0.5.1. 30 April 08. Bugfixes, rewrote some of the File Upload code to prevent white screen of annoyance.</li>
<li>Version 0.5. 19 April 08. Bugfixes, support for FormBrowser fixes and features, disposition type for upcoming FormBrowser version.</li>
<li>Version 0.4.4. 26 Sept 07. Bugfixes for radio button groups, fix for validation of DispositionDeliverToEmailAddressField.</li>
<li>Version 0.4.3. 18 Sept 07. Bugfixes for pulldowns using numbers, option to inline form, fixes for table-layouts provided by Ap Muthu, fix for requirability of Dispositions.</li>
<li>Version 0.4.2. 14 Sept 07. Bugfixes for XML export, RadioButton Group submission, and HTML labels.</li>
<li>Version 0.4.1. Bugfixes for File Disposition Types.</li>
<li>Version 0.4
	<ul>
		<li>Upped minimum CMS version to 1.1</li>
		<li>Numerous Bug fixes; too many to enumerate here</li>
		<li>Massive rejiggering of code to work with CMS MS 1.1 parameter sanitizing regime</li>
		<li>Added field types: &quot;TextField (Multiple)&quot; and &quot;Computed Field&quot;</li>
		<li>Added dispositions: &quot;Save Results to File Based on Pulldown&quot; and &quot;Save Results to File(s) Based on Multiple Selections&quot;(Calguy)</li>
		<li>Added neat-o AJAX-y template-copying for Form Templates, gave versions of old table-based templates to soothe the raging masses.</li>
		<li>Added ability to pass default values to form elements from module tag using value_FIELDNAME=&quot;value&quot; syntax (Calguy)</li>
		<li>Added option to display field ids in admin (Calguy)</li>
	</ul>
</li>
<li>Version 0.3
   <ul>
      <li>Added Captcha module support.</li>
      <li>Reworked labeling of form elements to be XHTML compliant</li>
      <li>Added Paul Noone&#039;s new, improved contact form templates</li>
      <li>Implementation of Email Subject Field</li>
      <li>Added admin-specifiable values to hidden field type, which may contain parsable smarty tags</li>
      <li>Text Area Field now allows specification of rows and cols in the admin, instead of CSS</li>
      <li>Added Drag&#039;n&#039;Drop reordering of form fields.</li>
      <li>Added non-blank field name and unique field name global configuration options and validation</li>
      <li>Implemented templated display of form results upon submission in addition to page redirecting</li>
      <li></li>
   </ul>
</li>
<li>Version 0.2.4 - 09 May 2007
   <p>Big release:<ul>
   <li>Added &quot;Email Form to User-Supplied Address&quot; disposition.</li>
   <li>Added &quot;TimePicker&quot; field type. Split &quot;Link&quot; field into a &quot;User-supplied Link&quot; field and a &quot;Static Link&quot; field.</li>
   <li>Added HTML email option and auto-templates for all email dispositions.</li>
   <li>Added primitive anti-spam features.</li>
   <li>Added XML-based import and export of forms.</li>
   </ul>
   </p>
</li>
<li>Version 0.2.3
   <p>Add the ability to call a selectable user defined tag upon disposition of the form.</p>
</li>
<li>Version 0.2.2
   <p>Many thanks to Utter Design for sponsoring some changes and bugfixes, which include:
   <ul>
      <li>Added file upload capabilities to the email disposition</li>
      <li>Add PageSetStart and PageSetEnd field types
      <p>These field types allow you to create fieldsets in your form, and organise
      your fields logically for the user.  You can even nest fieldsets, and
      associate a style with them appropriately.  The default template was changed
      to prevent it from wrapping a div around these types of fields.
      </p>
      </li>
      <li>Fixed a problem with DATETIME fields on install
      <p>This solves a problem when on install the response table would sometimes not get created when using adodb lite</li>
      </li>
   </ul>
   </p>
</li>
<li>Version 0.2 - 14 November 2006. Calguy &amp;amp; tsw&#039;s bug fixes for field re-ordering and custom templates. Additional bug fixes for field labels.</li>
<li>Version 0.1 - 8 July 2006. Initial Release</li>
</ul>';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/es_ES.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Constructor de Formularios';
$lang['field_type_'] = 'Sin Configurar Tipo de Campo';
$lang['field_type_CatalogerItemsField'] = 'Seleccionar uno (o mas) items de Cataloger';
$lang['field_type_FieldsetEnd'] = '-Fin de Fieldset';
$lang['field_type_FieldsetStart'] = '-Comienzo de Fieldset';
$lang['field_type_TextField'] = 'Entrada de Texto';
$lang['field_type_TextFieldExpandable'] = 'Entrada de Texto (M&uacute;ltiple)';
$lang['field_type_TextAreaField'] = '&Aacute;rea de Texto';
$lang['field_type_CheckboxField'] = 'Caja de Tilde';
$lang['field_type_CheckboxGroupField'] = 'Grupo Cajas de Tilde';
$lang['field_type_PulldownField'] = 'Desplegable';
$lang['field_type_MultiselectField'] = 'Multiselecci&oacute;n';
$lang['field_type_StatePickerField'] = 'Selector Estados de U.S.';
$lang['field_type_ProvincePickerField'] = 'Seleccionador de provincia Canadiense';
$lang['field_type_CountryPickerField'] = 'Selector de Paises';
$lang['field_type_DatePickerField'] = 'Selector de Fechas';
$lang['field_type_TimePickerField'] = 'Selector de Horas';
$lang['field_type_RadioGroupField'] = 'Grupo Bot&oacute;nes de Radio';
$lang['field_type_DispositionDirector'] = '*Enviar Email de Resultados Basado en Desplegable';
$lang['field_type_DispositionFileDirector'] = '*Guardar Resultados a Archivo Basado en Desplegable';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Guardar Resultados a Archivo(s) Basado(s) en M&uacute;ltiple Selecciones';
$lang['field_type_DispositionPageRedirector'] = '*Redireccionar a P&aacute;gina Basada en Desplegable';
$lang['field_type_DispositionEmail'] = '*Enviar Email de Resultados a Direcci&oacute;n(es) Configuradas';
$lang['field_type_DispositionEmailConfirmation'] = '*Validar-via-Direcci&oacute;n Email';
$lang['field_type_DispositionFromEmailAddressField'] = '*Campo Email &quot;De Direcci&oacute;n&quot;, y enviar copia';
$lang['field_type_DispositionFile'] = '*Escribir Resultados a Archivo Plano';
$lang['field_type_DispositionDatabase'] = '*Guardar Resultados en Base de Datos';
$lang['field_type_DispositionFormBrowser'] = '*Guardar Resultados para Modulo FormBrowser v.3';
$lang['field_type_DispositionUserTag'] = '*Llamar a una Tag definida por Usuario con los Resultados del Form';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Enviar Email a Direccion Email Suministrada por Usuario';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Enviar Email a Usuario Administrativo de CMS';
$lang['field_type_PageBreakField'] = '-Corte de P&aacute;gina';
$lang['field_type_FileUploadField'] = 'Subir Archivo';
$lang['field_type_FromEmailAddressField'] = 'Campo Email &quot;Desde Direcci&oacute;n&quot;';
$lang['field_type_FromEmailAddressAgainField'] = 'Campo Email &quot;De Direcci&oacute;n&quot; de nuevo';
$lang['field_type_FromEmailNameField'] = 'Campo Email &quot;Desde Nombre&quot;';
$lang['field_type_FromEmailSubjectField'] = 'Campo Email &quot;Asunto&quot;';
$lang['field_type_StaticTextField'] = '-Texto Est&aacute;tico';
$lang['field_type_SystemLinkField'] = '-Enlace Est&aacute;tico';
$lang['field_type_LinkField'] = 'Enlace (Entrado por Usuario)';
$lang['field_type_HiddenField'] = '-Campo Oculto';
$lang['field_type_ComputedField'] = '-Campo Computado';
$lang['field_type_UniqueIntegerField'] = '-Numero entero unico (serial)';
$lang['validation_none'] = 'Sin Validar';
$lang['validation_numeric'] = 'Num&eacute;rico';
$lang['validation_integer'] = 'Entero';
$lang['validation_email_address'] = 'Direcci&oacute;n Email';
$lang['validation_usphone'] = 'N&uacute;mero de Tel&eacute;fono (USA)';
$lang['validation_must_check'] = 'Debe Chequearse';
$lang['validation_regex_match'] = 'Iguala Expresi&oacute;n Regular';
$lang['validation_regex_nomatch'] = 'No Iguala Expresi&oacute;n Regular';
$lang['required_field_missing'] = 'No se indic&oacute; el valor para un campo requerido';
$lang['please_enter_a_value'] = 'Por favor ingrese un valor para &quot;%s&quot;';
$lang['please_enter_a_number'] = 'Por favor ingrese un n&uacute;mero para &quot;%s&quot;';
$lang['please_enter_valid'] = 'Por favor ingrese una entrada v&aacute;lida para &quot;%s&quot;';
$lang['please_enter_an_integer'] = 'Por favor ingrese un valor entero para &quot;%s&quot;';
$lang['please_enter_an_email'] = 'Por favor ingrese una direcci&oacute;n email v&aacute;lida para &quot;%s&quot;';
$lang['email_address_does_not_match'] = 'La direcci&oacute;n de Email no coincide con la de &quot;%s&quot;';
$lang['please_enter_a_phone'] = 'Por favor ingrese un n&uacute;mero de tel&eacute;fono v&aacute;lido para &quot;%s&quot;';
$lang['not_valid_email'] = '&iexcl;&quot;%s&quot; no parece ser una direcci&oacute;n de email v&aacute;lida!';
$lang['please_enter_no_longer'] = 'Por favor ingrese un valor que no tenga m&aacute;s de %s caracteres';
$lang['title_list_delimiter'] = 'Caracter a utilizar como delimitador en resultados que ofrecen m&aacute;s de un valor';
$lang['you_need_permission'] = 'Usted necesita tener el permiso &quot;%s&quot; para realizar la operaci&oacute;n.';
$lang['lackpermission'] = '&iexcl;Perd&oacute;n! Pero usted no tiene privilegios adecuados para ingresar a &eacute;sta secci&oacute;n.';
$lang['field_order_updated'] = 'Se actualiz&oacute; el orden de los campos.';
$lang['form_deleted'] = 'Formulario eliminado.';
$lang['field_deleted'] = 'Campo eliminado.';
$lang['configuration_updated'] = 'Configuraci&oacute;n Actualizada.';
$lang['you_must_check'] = 'Debe controlar a &quot;%s&quot; para poder continuar.';
$lang['must_specify_one_destination'] = '&iexcl;Debe indicar al menos una direcci&oacute;n de destino!';
$lang['are_you_sure_delete_form'] = '&iexcl;Est&aacute; seguro que quiere eliminar el formulario %s?';
$lang['are_you_sure_delete_field'] = '&iexcl;Est&aacute; seguro que quiere eliminar el campo %s?';
$lang['notice_select_type'] = 'Las opciones avanzadas no est&aacute;n disponibles hasta que no se haya fijado el tipo de campo.';
$lang['field_name_in_use'] = 'El nombre de campo &quot;%s&quot; ya est&aacute; en uso. Por favor use nombres de campos &uacute;nicos, o deshabilite nombres de campos &uacute;nicos en la configuraci&oacute;n del Constructor de Formularios.';
$lang['field_no_name'] = 'Los campos deben tener nombre, salvo que lo deshabilite en la configuraci&oacute;n del Constructor de Formularios.';
$lang['anonymous'] = 'An&oacute;nimo';
$lang['abbreviation_length'] = 'Long: %s';
$lang['boxes'] = '%s cajas';
$lang['options'] = '%s opciones';
$lang['text_length'] = '%s caract.';
$lang['order'] = 'Orden';
$lang['unspecified'] = '[sin especificar]';
$lang['added'] = 'agregado';
$lang['updated'] = 'actualizado';
$lang['sort_options'] = 'Ordenar opciones al salir';
$lang['select_one'] = 'Elegir Uno';
$lang['select_type'] = 'Elegir Tipo';
$lang['to'] = 'A';
$lang['yes'] = 'Si';
$lang['no'] = 'No ';
$lang['recipients'] = 'receptores';
$lang['file_count'] = '%s archivos posibles';
$lang['destination_count'] = '%s destinos';
$lang['save'] = 'Guardar';
$lang['add'] = 'Agregar';
$lang['update'] = 'Actualizar';
$lang['save_and_continue'] = 'Guardar y Continuar Editando';
$lang['information'] = 'Informaci&oacute;n';
$lang['automatic'] = 'Autom&aacute;tico';
$lang['forms'] = 'Formularios';
$lang['form'] = 'Formulario %s';
$lang['configuration'] = 'Configuraci&oacute;n';
$lang['field_requirement_updated'] = 'Estado de campo requerido actualizado.';
$lang['maximum_size'] = 'Tama&ntilde;o M&aacute;x.';
$lang['permitted_extensions'] = 'Extenciones';
$lang['permitted_filetypes'] = 'Tipos de archivos permitidos';
$lang['file_too_large'] = '&iexcl;Archivo subido es muy grande! Tama&ntilde;o m&aacute;x. es:';
$lang['illegal_file_type'] = 'Este tipo de archivo no puede ser subido. Por favor controlar que la extensi&oacute;n es correcta.';
$lang['upload'] = 'Subir';
$lang['form_imported'] = 'Formulario Importado.';
$lang['form_import_failed'] = '&iexcl;Fall&oacute; la importaci&oacute;n del formulario! No hay problema con el formato del archivo XML.';
$lang['rows'] = '%s filas';
$lang['cols'] = '%s columnas';
$lang['12_hour'] = 'Reloj de 12 Horas';
$lang['24_hour'] = 'Reloj de 24 Horas';
$lang['hour'] = 'Hora';
$lang['min'] = 'Minuto';
$lang['merid'] = 'Meridiano';
$lang['date_range'] = 'Rango: %s - %s';
$lang['thanks'] = '&iexcl;Gracias! Se recibi&oacute; su env&iacute;o.';
$lang['edit'] = 'Editar';
$lang['delete'] = 'Eliminar';
$lang['day'] = 'D&iacute;a';
$lang['mon'] = 'Mes';
$lang['year'] = 'A&ntilde;o';
$lang['none'] = '(ninguno)';
$lang['uninstalled'] = 'M&oacute;dulo desinstalado.';
$lang['installed'] = 'Instalada versi&oacute;n %s del m&oacute;dulo.';
$lang['upgraded'] = 'Se actualizo el m&oacute;dulo a la versi&oacute;n %s.';
$lang['button_previous'] = 'Volver...';
$lang['button_submit'] = 'Enviar Formulario';
$lang['button_continue'] = 'Continuar...';
$lang['value_checked'] = 'Chequeado';
$lang['value_unchecked'] = 'Sin chequear';
$lang['tab_main'] = 'Principal';
$lang['tab_symbol'] = 'Configurar Vista del Form';
$lang['tab_submit'] = 'Env&iacute;o del Formulario';
$lang['tab_captcha'] = 'Configuraciones de Captcha';
$lang['tab_advanced'] = 'Config. Avanzadas';
$lang['tab_templatelayout'] = 'Plantilla del Formulario';
$lang['tab_submissiontemplate'] = 'Plantilla de Enviado';
$lang['canuse_smarty'] = '<em>Las variables Smarty son v&aacute;lidas en este campo.</em>';
$lang['add_options'] = 'Agregar M&aacute;s Opciones';
$lang['delete_options'] = 'Eliminar Opciones Marcadas';
$lang['add_checkboxes'] = 'Agregar M&aacute;s Cajas de Tildar';
$lang['delete_checkboxes'] = 'Eliminar Cajas de Tildar Marcadas';
$lang['add_address'] = 'Agregar Otra Direcci&oacute;n';
$lang['delete_address'] = 'Eliminar Direcciones Marcadas';
$lang['add_destination'] = 'Agregar Otro Destino';
$lang['delete_destination'] = 'Eliminar Destinos Marcados';
$lang['suspected_spam'] = 'Se han generado demasiados  emails desde su Direcci&oacute;n IP. C&oacute;digo Anti-Spam ha prevenido el env&iacute;o.';
$lang['suspected_spam_log'] = 'Se interrumpi&oacute; envio sospechado por Spam desde IP %s.';
$lang['reorder'] = 'Reordenar Campos';
$lang['cancel'] = 'Cancelar';
$lang['value_set'] = 'Valor configurado: %s';
$lang['help_cataloger_attribute_fields'] = 'Below is a list of the attributes available from the Cataloger module.<br/>You can optionally specify valid ranges, values, or numerous values to be used in filtering the list of items that is displayed to the user.<br/>
<br/>
<strong>Ranges:</strong><br/>
Ranges can be specified by signifying a minimum and maximum value using this syntax: &quot;range: minvalue to maxvalue&quot;<br/>
<br/>
<strong>Multiple Values:</strong><br/>
To specify multiple values for an attribute use the syntax &quot;multi: value1|value2|value3&quot;<br/>
<br/>
<strong>Values from hidden fields</strong><br/>
To specify a value from a hidden field use the syntax {$fld_id}<br/>
<br/>';
$lang['help_name_regex'] = 'Una expresi&oacute;n regular para permitir filtrar items de Cataloger por nombre';
$lang['help_field_height'] = 'Altura del campo de selecci&oacute;n multiple';
$lang['title_name_regex'] = 'Cataloger Item Name Regular Expression';
$lang['title_field_height'] = 'Altura de campo';
$lang['title_file_path'] = 'Directorio Destino de archivos de salida';
$lang['title_udt_name'] = 'Tag Definida por Usuario';
$lang['title_uploads_destpage'] = 'P&aacute;gina a donde volver con enlaces subidos';
$lang['title_uploadmodule_summary'] = 'Enviado con el constructor de formularios';
$lang['title_uploads_category'] = 'Categor&iacute;a de subidas';
$lang['title_sendto_uploads'] = 'Enviar este archivo al m&oacute;dulo de subidas';
$lang['title_legend'] = 'Leyenda';
$lang['title_maximum_length'] = 'Longitud M&aacute;xima';
$lang['title_checkbox_label'] = 'Etiqueta de Caja de Tilde';
$lang['title_radio_label'] = 'Etiqueta de Bot&oacute;n de Radio';
$lang['title_checked_value'] = 'Valor cuando tiene tilde.';
$lang['title_unchecked_value'] = 'Valor cuando no tiene tilde.';
$lang['title_checkbox_details'] = 'Detalles de Grupo de Caja de Tilde';
$lang['title_delete'] = '&iquest;Eliminar?';
$lang['title_select_one_message'] = 'Texto &quot;Elegir Uno&quot;';
$lang['title_selection_value'] = 'Valor de selecci&oacute;n';
$lang['title_selection_displayname'] = 'Nombre de Selecci&oacute;n a Mostrar';
$lang['title_selection_subject'] = 'Asunto de Selecci&oacute;n';
$lang['title_select_default_country'] = 'Selecci&oacute;n por Defecto';
$lang['title_select_default_state'] = 'Selecci&oacute;n por Defecto';
$lang['title_select_default_province'] = 'Selecci&oacute;n por defecto';
$lang['title_option_name'] = 'Nombre de Opci&oacute;n';
$lang['title_option_value'] = 'Valor Enviado';
$lang['title_pulldown_details'] = 'Opciones de Desplegable';
$lang['title_multiselect_details'] = 'Opciones de Multiselecci&oacute;n';
$lang['title_destination_address'] = 'Direcci&oacute;n Email de Destino';
$lang['title_destination_filename'] = 'Nombre de Archivo de Destino';
$lang['title_email_from_name'] = '&quot;Desde nombre&quot; para email';
$lang['title_relaxed_email_regex'] = 'Usar validaci&oacute;n de email relajada';
$lang['title_relaxed_regex_long'] = 'Usar validaci&oacute;n de direcci&oacute;n email relajada (p.ej., permite &quot;x@y&quot; en vez de requerir a &quot;x@y.tld&quot;)';
$lang['title_email_from_address'] = '&quot;Desde direcci&oacute;n&quot; para email';
$lang['title_email_encoding'] = 'Configuraci&oacute;n de c&oacute;dificaci&oacute;n de caracteres de Email';
$lang['title_director_details'] = 'Detalles para Emisor-Email con base Desplegable';
$lang['title_file_name'] = 'Nombre de archivo';
$lang['title_email_subject'] = 'L&iacute;nea Asunto de Email';
$lang['title_form_name'] = 'Nombre de Formulario';
$lang['title_form_status'] = 'Estado de Formulario';
$lang['title_ready_for_deployment'] = 'Listo para su Desarrollo';
$lang['title_not_ready1'] = 'No est&aacute; Listo';
$lang['title_redirect_page'] = 'P&aacute;gina a donde dirigirse luego del env&iacute;o';
$lang['title_not_ready2'] = 'Por favor agregue un campo al formulario para que lo ingresado por el usuario pueda ser manejado.';
$lang['title_not_ready_link'] = 'Puede usar este atajo';
$lang['title_form_alias'] = 'Alias de Formulario';
$lang['title_form_fields'] = 'Campos de Formulario';
$lang['title_field_id'] = 'Id de Campo';
$lang['title_show_fieldaliases'] = 'Mostrar Aliases de los campos';
$lang['title_show_fieldaliases_long'] = 'Marcar esto va a mostrar los aliases de campos cuando se agrega o edita una forma';
$lang['title_field_name'] = 'Nombre de Campo';
$lang['title_field_alias'] = 'Alias de Campo';
$lang['title_radiogroup_details'] = 'Detalles de Grupo Bot&oacute;n de Radio';
$lang['title_field_type'] = 'Tipo de Campo';
$lang['title_not_ready3'] = 'para crear un campo de manejo del formulario.';
$lang['title_add_new_form'] = 'Agregar Nuevo Formulario';
$lang['title_show_version'] = '&iquest;Mostrar Versi&oacute;n del M&oacute;dulo?';
$lang['title_show_version_long'] = 'La versi&oacute;n del m&oacute;dulo Constructor de Formularios instalado se incluir&aacute; en comentarios, ayuda al hacer debug';
$lang['title_add_new_field'] = 'Agregar Nuevo Campo';
$lang['title_form_submit_button'] = 'Bot&oacute;n de Prueba Env&iacute;o de Formulario';
$lang['title_submit_button_safety'] = '&iquest;Agregamos Javascript al Bot&oacute;n de Env&iacute;o que ayudar&aacute; a prevenir m&uacute;ltiples env&iacute;os del formulario?';
$lang['title_submit_button_safety_help'] = 'Agregar script de seguridad';
$lang['title_form_next_button'] = 'Texto para Bot&oacute;n &quot;Siguiente&quot; del Form (se usa en form&#039;s multip&aacute;gina)';
$lang['title_form_prev_button'] = 'Texto para Bot&oacute;n &quot;Previo&quot; del Form (se usa en form&#039;s multip&aacute;gina)';
$lang['title_field_validation'] = 'Validaci&oacute;n de Campo';
$lang['title_field_to_validate'] = 'Campo a Validar';
$lang['title_form_css_class'] = 'Clase CSS para este form';
$lang['title_field_css_class'] = 'Clase CSS para este campo';
$lang['title_form_required_symbol'] = 'S&iacute;mbolo para identificar campos requeridos';
$lang['title_field_required'] = 'Requerido';
$lang['title_field_required_long'] = 'Se requiere una respuesta para este Campo';
$lang['title_hide_label'] = 'Ocultar Etiqueta';
$lang['title_hide_label_long'] = 'Ocultar el nombre de este campo en el Form';
$lang['title_text'] = 'Texto est&aacute;tico a mostrar';
$lang['title_field_regex'] = 'Validaci&oacute;n de Regex';
$lang['title_lines_to_show'] = 'N&uacute;mero de L&iacute;neas a mostrar';
$lang['no_default'] = 'No es Por Defecto';
$lang['redirect_after_approval'] = 'P&aacute;gina a donde ir despu&eacute;s de aprobar';
$lang['title_regex_help'] = 'Esta expresi&oacute;n regular se usar&aacute; s&oacute;lo si &quot;validation type&quot; es puesto a una opci&oacute;n regex-relacionada. Incluye un completo regex estilo Perl, incluyendo adem&aacute;s las barras de comienzo/parar y flags (e.g., &quot;/image\.(\d+)/i&quot;)';
$lang['title_field_required_abbrev'] = 'Req&#039;do';
$lang['title_hide_errors'] = 'Ocultar Errores';
$lang['title_form_displaytype'] = 'Tipo de Formulario Mostrado';
$lang['title_hide_errors_long'] = 'Prevenir que mensajes de debug / error los vea el usuario.';
$lang['title_email_template'] = 'Plantilla de Email';
$lang['title_maximum_size'] = 'Tama&ntilde;o m&aacute;ximo de archivo a subir (kilobytes)';
$lang['title_maximum_size_long'] = 'Esta limitaci&oacute;n se agrega a las fijadas por la configuraci&oacute;n de php y el servidor web';
$lang['title_permitted_extensions'] = 'Extensiones Permitidas';
$lang['title_permitted_extensions_long'] = 'Entrar una lista separada por comas, excluyendo el punto (p.ej., &quot;jpg,gif,jpeg&quot;). Los espacios son ignorados. Si deja esto en blanco significa que no hay restricciones.';
$lang['title_show_limitations'] = '&iquest;Mostrar restricciones?';
$lang['title_show_limitations_long'] = '&iquest;Mostrar cualquier restricci&oacute;n de tama&ntilde;o y extensi&oacute;n con el archivo a subir?';
$lang['title_form_template'] = 'Plantilla a utilizar para Mostrar Formulario';
$lang['title_page_x_of_y'] = 'P&aacute;gina %s de %s';
$lang['title_no_advanced_options'] = 'El campo no tiene opciones avanzadas.';
$lang['title_form_unspecified'] = 'Texto a devolver para valores de campo sin especificar';
$lang['title_enable_fastadd_long'] = '&iquest;Habilita desplegable de agregado r&aacute;pido de campos en formularios?';
$lang['title_enable_fastadd'] = '&iquest;Habilitamos desplegable de agregado r&aacute;pido de campos?';
$lang['title_fastadd'] = 'Agregar r&aacute;pidamente campos';
$lang['title_enable_antispam_long'] = 'Haciendo click aqu&iacute; permitir&aacute; s&oacute;lo 10 emails a ser disparados por una direcci&oacute;n IP dada (por hora).';
$lang['title_enable_antispam'] = '&iquest;Habilitar caracter&iacute;sticas elementales para anti-spam?';
$lang['title_show_fieldids'] = 'Mostrar IDs de Campo';
$lang['title_show_fieldids_long'] = 'Haciendo click aqu&iacute; permitir&aacute; ver ids de campos cuando se agrega o edita un formulario';
$lang['title_xml_to_upload'] = 'Subir formulario desde archivo XML';
$lang['title_xml_upload_formname'] = 'Usar este nombre de formulario';
$lang['title_import_legend'] = 'Importar Formulario XML';
$lang['title_xml_upload_formalias'] = 'Usar este alias de formulario';
$lang['title_html_email'] = '&iquest;Generar email HTML?';
$lang['title_link_autopopulate'] = '&iquest;Publicar autom&aacute;ticamente?';
$lang['title_link_autopopulate_help'] = '&iquest;Publicarlo autom&aacute;ticamente con la URL de la p&aacute;gina que contiene el formulario? (esto sobrescribe la opci&oacute;n de abajo de enlace de p&aacute;gina del sitio)';
$lang['title_default_link'] = 'Url por defecto del enlace';
$lang['title_default_link_title'] = 'Texto por defecto del enlace';
$lang['title_link_to_sitepage'] = 'Enlace a p&aacute;gina del sitio';
$lang['title_captcha_not_installed'] = 'Usted puede usar a <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a> para proteger el env&iacute;o de los formularios. Para eso instale el m&oacute;dulo. Por m&aacute;s informaci&oacute;n, de una vuelta por el <a href="http://dev.cmsmadesimple.org/projects/captcha/">projecto Captcha</a>.';
$lang['title_use_captcha'] = '&iquest;Usar Captcha para protejer el env&iacute;o de formularios?';
$lang['title_use_captcha_help'] = 'Observe aqu&iacute; para proteger a su formulario con <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a>.';
$lang['title_user_captcha'] = 'Por favor confirme que usted no es un script ingresando los caracteres de la imagen.';
$lang['title_user_captcha_error'] = 'Error en el texto para Captcha';
$lang['wrong_captcha'] = 'El Captcha no es correcto.';
$lang['title_title_user_captcha'] = 'Texto de ayuda para Captcha';
$lang['title_dont_submit_unchecked'] = 'No enviar valores de cajas sin tildar';
$lang['title_dont_submit_unchecked_help'] = 'Tildar esto si desea que las cajas tildadas regresen un valor';
$lang['link_label'] = 'Etiqueta de Enlace';
$lang['link_destination'] = 'Url de Destino de Enlace';
$lang['title_default_set'] = '&iquest;Chequear por Defecto?';
$lang['title_24_hour'] = '&iquest;Usamos reloj de 24-horas?';
$lang['title_before_noon'] = 'am';
$lang['title_after_noon'] = 'pm';
$lang['title_smarty_eval'] = '&iquest;Procesamos smarty tags dentro de campos?';
$lang['title_textarea_rows'] = 'Filas (nota: esto puede ser sobrescrito por CSS)';
$lang['title_textarea_cols'] = 'Columnas (nota: esto puede ser sobrescrito por CSS)';
$lang['title_form_main'] = 'Detalles de Formulario Principal';
$lang['title_show_username'] = 'Mostrar el Nombre del Usuario?';
$lang['title_show_userfirstname'] = 'Mostrar el Primer Nombre del Usuario?';
$lang['title_show_userlastname'] = 'Mostrar el Apellido del Usuario?';
$lang['title_restrict_to_group'] = 'Restringir lista de usuarios a usuarios de un grupo especifico';
$lang['restricted_to_group'] = 'Solo en el grupo %s';
$lang['title_show_to_user'] = 'Mostrar al usuario?';
$lang['help_leaveempty'] = 'Este campo puede dejarse vac&iacute;o';
$lang['help_variables_for_template'] = 'Variables para Plantilla';
$lang['help_variables_for_computation'] = 'Variables Disponibles';
$lang['help_php_variable_name'] = 'Variable PHP';
$lang['help_submission_date'] = 'Fecha de Env&iacute;o';
$lang['help_server_name'] = 'Su servidor';
$lang['help_sub_source_ip'] = 'Direcci&oacute;n IP de la persona que usa el formulario';
$lang['help_sub_url'] = 'URL de la p&aacute;gina que contiene el formulario';
$lang['help_fb_version'] = 'Versi&oacute;n FormBuilder ';
$lang['help_tab'] = 'S&iacute;mbolo de tabulaci&oacute;n';
$lang['help_other_fields'] = 'Nombres de campo alternados se pueden usar en forma intercambiable (especialmente &uacute;til si Smarty se atasca con caracteres fuera del rango ASCII 32-126). <br />Otros campos estar&aacute;n disponibles as&iacute; como los agregue al formulario.';
$lang['help_array_fields'] = 'A los campos que tienen valores m&uacute;ltiples se puede tambi&eacute;n llegar a ellos v&iacute;a el valor smarty de $fieldname_array  o  $fld_#_array.';
$lang['help_date_format'] = 'Vea <a href="http://www.php.net/manual/en/function.date.php" target=_NEW>el Manual PHP</a> para ayuda de formatos.';
$lang['help_variable_name'] = 'Variable ';
$lang['help_form_field'] = 'Campo Representado';
$lang['link_back_to_form'] = '&laquo; Volver al Form';
$lang['title_create_sample_template'] = 'Crear Plantilla de Ejemplo';
$lang['title_create_sample_html_template'] = 'Crear Plantilla de Ejemplo HTML';
$lang['title_create_sample_header_template'] = 'Crear Plantilla con Encabezado de Muestra';
$lang['title_create_sample_header'] = 'Crear Encabezado de Ejemplo';
$lang['help_tab_symbol'] = 'un caracter tab';
$lang['title_file_template'] = 'Plantilla para archivo de salida de una l&iacute;nea';
$lang['title_file_header'] = 'Plantilla para el encabezado de archivo de salida';
$lang['title_confirmation_url'] = 'URL donde hacer click para confirmar el formulario';
$lang['title_value'] = 'Valor (vea la solapa Avanzado si usted usa tags smarty';
$lang['title_date_format'] = 'Formato de Fecha (est&aacute;ndar <a href="http://www.php.net/manual/en/function.date.php">Formatos de Fecha PHP</a>)';
$lang['title_use_wysiwyg'] = 'Usar editor WYSIWYG para &Aacute;rea de texto (&iquest;s&oacute;lo para Admin?)';
$lang['title_submit_actions'] = 'Comportamiento del Formulario de Env&iacute;o';
$lang['title_submit_labels'] = 'Etiquetas de Bot&oacute;nes de Env&iacute;o';
$lang['title_sortable_field'] = 'Campo Ordenable #%s';
$lang['title_submit_help'] = 'Esta p&aacute;gina le permite adaptar a su gusto el Env&iacute;o del Formulario. No determina que har&aacute; el Constructor de Formularios con la data enviada. Esto &uacute;ltimo lo puede establecer agregando campos de  &quot;Disposici&oacute;n&quot; a su formulario.';
$lang['title_start_year'] = 'Comienza rango de a&ntilde;o';
$lang['title_end_year'] = 'Fin rango de a&ntilde;o';
$lang['title_default_year'] = 'A&ntilde;o por Defecto';
$lang['title_default_year_help'] = '(Poner a -1 para que el a&ntilde;o por defecto sea el actual)';
$lang['title_submit_action'] = 'Luego que el formulario sea enviado';
$lang['title_submit_response'] = 'Respuesta a mostrar';
$lang['display_text'] = 'Mostrar &quot;Plantilla de Enviado&quot;';
$lang['redirect_to_page'] = 'Redirigir a p&aacute;gina del sitio';
$lang['title_submit_response_help'] = 'Esta plantilla es para ser mostrada al usuario una vez enviado el formulario. Esta plantilla no afecta a los emails generados u otras disposiciones para el formulario -- puede configurar a estas &uacute;ltimas plantillas (donde sea apropiado) en la solapa &quot;avanzado&quot; para los campos que tienen la disponibilidad.';
$lang['title_destination_page'] = 'P&aacute;gina Destino';
$lang['title_require_fieldnames'] = 'Requerir Nombre de Campos';
$lang['title_require_fieldnames_long'] = '&iquest;Se requiere que los campos tengan nombre?';
$lang['title_unique_fieldnames'] = 'Requerir Nombre de Campos &Uacute;nicos';
$lang['title_unique_fieldnames_long'] = '&iquest;Se requiere que los nombres de campos sean &uacute;nicos?';
$lang['title_reorder_form'] = 'Reordenar Campos';
$lang['title_load_template'] = 'Cargar plantilla';
$lang['title_add_button_text'] = 'Agregar texto de Bot&oacute;n';
$lang['title_del_button_text'] = 'Eliminar texto de Bot&oacute;n';
$lang['title_string_or_number_eval'] = 'Interpretar las variables como si fueran n&uacute;meros o frases';
$lang['title_order'] = 'Orden de Interpretaci&oacute;n';
$lang['title_order_help'] = 'Si existe m&aacute;s de un Campo Computado, el orden de los c&aacute;lculos ir&aacute; desde aquellos de n&uacute;mero de orden m&aacute;s bajo a los de n&uacute;mero de orden m&aacute;s alto';
$lang['title_compute_value'] = 'Valor a computar';
$lang['title_string'] = 'Frase';
$lang['title_numeric'] = 'Num&eacute;rico';
$lang['title_inline_form'] = '&iquest;Mostrar el formulario inline?';
$lang['title_inline_form_help'] = 'Inline significa que cualquier resultado del formulario reemplaza el tag {cms_module}, non-inline reemplaza el tag {content}.';
$lang['title_field_default_value'] = 'Valor por defecto para el campo';
$lang['title_clear_default'] = '&iquest;Limpiar por defecto al seleccionar?';
$lang['title_clear_default_help'] = 'Seleccione esto para limpiar el valor por defecto cuando un usuario seleccione este campo';
$lang['title_remove_file_from_server'] = 'Borrar archivo subido despues de procesar (disposiciones de email)';
$lang['title_field_javascript'] = 'Javascript para el campo';
$lang['title_field_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;';
$lang['title_submit_javascript'] = 'Javascript de Envio de Forma';
$lang['title_submit_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;.<br />This will probably not work well if you use the &quot;safety script&quot; option above.';
$lang['email_from_addr_help'] = 'Do not just pick a random address here -- many ISPs will<br />not deliver the mail if you are using a different domain name than your actual<br />host name (i.e., use something like name@%s)';
$lang['title_switch_advanced'] = 'Necesita mas tipos de archivos?';
$lang['title_switch_basic'] = 'Demasiados tipos de archivos? ';
$lang['title_switch_advanced_link'] = 'Cambiar a Modo Avanzado';
$lang['title_switch_basic_link'] = 'Cambiar a Modo Simple';
$lang['title_file_root'] = 'Directorio para guarar el archivo';
$lang['title_file_root_help'] = 'This needs to be a directory that your web server has permissions to write in.<br />Chmod it 777 if you have problems/doubts.<br />Also, check to see that you do not have PHP directory restrictions.';
$lang['title_newline_replacement'] = 'Simbolo de reemplazo para retorno/nueva linea';
$lang['title_newline_replacement_help'] = 'Dejar vacio para permitir despliegue de retorno/nuevas lineas ';
$lang['title_send_usercopy'] = 'Enviar una copia del envio al usuario?';
$lang['title_send_usercopy_label'] = 'Etiquera para la caja de tildar (elecci&oacute;n del usuario)';
$lang['title_send_me_a_copy'] = 'Enviarme una copia de la forma';
$lang['option_never'] = 'Nunca';
$lang['option_user_choice'] = 'Dar opci&oacute;n al usuario (caja de tildar)';
$lang['option_always'] = 'Siempre';
$lang['error_cataloger_module_not_available'] = '<strong>El modulo Cataloger no parece estar instalado/activo.</strong>';
$lang['warning'] = 'ADVERTENCIA!';
$lang['default_template'] = 'Plantilla por Defecto';
$lang['table_left_template'] = 'Plantilla de Tabla, T&iacute;tulos a la izquierda';
$lang['table_top_template'] = 'Plantilla de Tabla, T&iacute;tulos al tope';
$lang['form_template_name'] = 'Plantilla de %s';
$lang['template_are_you_sure'] = '&iquest;Est&aacute; seguro que quiere sobre escribir su plantilla con la plantilla seleccionada? (A&uacute;n cuando usted diga OK, necesitar&aacute; guardar los cambios)';
$lang['title_bad_function'] = 'Error al calcular &quot;%s&quot;.';
$lang['no_referrer_info'] = 'No hay info disponible de HTTP_REFERER (probablemente debido al uso de la Validaci&oacute;n del  Email de Usuario)';
$lang['validation_param_error'] = 'Error de Par&aacute;metro de Validaci&oacute;n. &iexcl;Por favor aseg&uacute;rese que ha copiado el URL de su direcci&oacute;n email correctamente!';
$lang['validation_response_error'] = 'Error en Respuesta de Validaci&oacute;n. &iexcl;Por favor aseg&uacute;rese que ha copiado el URL de su direcci&oacute;n email correctamente!';
$lang['validation_no_field_error'] = 'Error en Respuesta de Validaci&oacute;n. &iexcl;No hay campo de validaci&oacute;n de email en este formulario!';
$lang['upgrade03to04'] = 'La plantilla del formulario fue puesta al d&iacute;a autom&aacute;ticamente como parte del actualizado de la versi&oacute;n 0.3 a la versi&oacute;n 0.4. Usted deber&aacute; hacer algunos ajustes. Si est&aacute; utilizando el formulario por defecto, simplemente remplace esta plantilla con &quot;default&quot; usando el desplegable de arriba.';
$lang['admindesc'] = 'Agregue, edite y administre Formularios interactivos';
$lang['operators_help'] = 'Si usted utiliza evaluaci&oacute;n de String, la &uacute;nica operaci&oacute;n disponible es concatenaci&oacute;n (+), mientras que si usa evaluaci&oacute;n num&eacute;rica usted tiene c&aacute;lculos matem&aacute;ticos b&aacute;sicos y muy simples (, +, -, *, /, ).';
$lang['date_january'] = 'Enero';
$lang['date_february'] = 'Febrero';
$lang['date_march'] = 'Marzo';
$lang['date_april'] = 'Abril';
$lang['date_may'] = 'Mayo';
$lang['date_june'] = 'Junio';
$lang['date_july'] = 'Julio';
$lang['date_august'] = 'Agosto';
$lang['date_september'] = 'Septiembre';
$lang['date_october'] = 'Octubre';
$lang['date_november'] = 'Noviembre';
$lang['date_december'] = 'Diciembre';
$lang['submission_error'] = '&iexcl;Perd&oacute;n! Se present&oacute; un error en el manejo del env&iacute;o de su formulario.';
$lang['submit_error'] = 'Error de env&iacute;o del Constructor de Formularios: %s';
$lang['uploads_error'] = 'Error cometido por archivo al m&oacute;dulo de subidas: %s';
$lang['nouploads_error'] = 'No se pudo hallar el m&oacute;dulo de subidas';
$lang['upload_attach_error'] = 'Subir/Adjunto, error en archivo %s (nombre_tmp: %s, del tipo %s)';
$lang['submission_error_file_lock'] = 'Error. No se puede obtener bloqueo de archivo.';
$lang['unchecked_by_default'] = 'Predeterminado: sin tildar';
$lang['checked_by_default'] = 'Predeterminado: tildado';
$lang['email_default_template'] = 'Env&iacute;o del Constructor de Formularios';
$lang['email_template_not_set'] = '<br/>&iexcl;La plantilla de email todav&iacute;a no se configur&oacute;!';
$lang['missing_cms_mailer'] = 'Constructor de Formularios: &iexcl;No se encuentra el m&oacute;dulo requerido CMSMailer!';
$lang['user_approved_submission'] = 'Env&iacute;o de usuario aprobado %s desde %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Acontecimiento disparado cuando un formulario del Constructor de Formularios es enviado';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Acontecimiento disparado si hay un error cuando un formulario del Constructor de Formularios es enviado';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Acontecimiento disparado cuando un formulario del Constructor de Formularios es mostrado';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Acontecimiento disparado cuando un formulario del Constructor de Formularios es enviado.</p>
<h4>Par&aacute;metros</h4>
<ul>
<li><em>form_name</em> - El nombre del formulario (string)</li>
<li><em>form_id</em> - id interno del formulario (int)</li>
<li><em>value_<name></em> - Provee un valor por defecto a un campo con el nombre especificado.</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Acontecimiento disparado si hay un error cuando un formulario del Constructor de Formularios es enviado</p>
<h4>Par&aacute;metros</h4>
<ul>
<li><em>form_name</em> - El nombre del formulario (string)</li>
<li><em>form_id</em> - id interno del formulario (int)</li>
<li><em>error</em> - Una lista de todos los errores conocidos (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Acontecimiento disparado cuando un formulario del Constructor de Formularios es mostrado</p>
<h4>Par&aacute;metros</h4>
<ul>
<li><em>form_name</em> - El nombre del formulario (string)</li>
<li><em>form_id</em> - id interno del formulario (int)</li>
</ul> ';
$lang['formbuilder_params_response_id'] = 'ID de respuesta. Usado por el Explorador de Formularios';
$lang['formbuilder_params_passed_from_tag'] = 'Valor por defecto de campo; ver ayuda del m&oacute;dulo';
$lang['formbuilder_params_field_id'] = 'ID de campo para operaciones internas';
$lang['formbuilder_params_form_name'] = 'Nombre de Formulario';
$lang['formbuilder_params_form_id'] = 'ID de Formulario para operaciones internas';
$lang['formbuilder_params_general'] = 'Par&aacute;metros generales para operaciones internas';
$lang['template_variable_help'] = '<h3>Variables de Plantilla de Formulario</h3>
<p>Usted puede editar a la plantilla para hacer que el layout del formulario se vea de la forma que a usted m&aacute;s guste.
   Para que el formulario funcione, usted debe siempre incluir las tags {$fb_hidden} y {$submit}.</p>

<p>Usted puede llegar hasta los campos de su formulario, bien usando el array de $fields o directamente ingresar utilizando los nombres de los campos (p.ej., {$myfield->input} )</p>


<p>Cada campo tiene los siguientes atributos:</p>
<table>
<tr><th>Campo</th><th>Valor</th></tr>
<tr><td>field->display</td><td>1 si el campo debe ser mostrado, 0 de otra forma</td></tr>
<tr><td>field->required</td><td>1 si el campo debe ser mostrado, 0 de otra forma</td></tr>
<tr><td>field->required_symbol</td><td>el s&iacute;mbolo para campos requeridos</td></tr>
<tr><td>field->css_class</td>
<td>la clase CSS especificada para este campo</td>
</tr>
<tr><td>field->valid</td>
<td>1 si el campo ha pasado la validaci&oacute;n, 0 de otra forma</td>
</tr>
<tr><td>field->error</td>
<td>Texto del problema de validaci&oacute;n, en el caso que este campo no sea validado</td>
</tr>
<tr><td>field->hide_name</td>
<td>1 si el nombre del campo debe ser ocultado, 0 de otra forma </td>
</tr>
<tr><td>field->has_label</td>
<td>1 si el tipo de campo tiene una etiqueta</td>
</tr>
<tr><td>field->needs_div</td>
<td>1 si el campo necesita ser envuelto por una DIV (o fila de tabla, si este es la canci&oacute;n que usted baila)</td>
</tr>
<tr><td>field->name</td>
<td>el nombre del campo</td>
</tr>
<tr><td>field->input</td>
<td>el control de entrada de campo (p.ej., el campo de entrada en si mismo)</td>
</tr>
<tr><td>field->op</td>
<td>un bot&oacute;n de control asociado al campo si es aplicable (p.ej., el bot&oacute;n eliminar para entradas de texto expandibles)</td>
</tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td>
<td>el tipo de datos del campo</td>
</tr>

<tr><td>field->multiple_parts</td>
<td>1 si el campo->entrada es en realidad una colecci&oacute;n de controles</td>
</tr>
<tr><td>field->label_parts</td>
<td>1 si la colecci&oacute;n de controles tiene etiquetas separadas para cada control</td>
</tr>
</table>

<p>En algunos caso, campo->entrada es en relidad un array de objetos m&aacute;s que una entrada. Esto pasa, por ejemplo, en Grupos de Cajas de Tilde o Grupos de Botones de Radio. Para ellos, usted puede hacer una iteraci&oacute;n a traves de campo->entrada->nombre y campo->entrada->entradas.</p>

<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th>
<th>Valor</th>
</tr>
<tr><td>total_pages</td>
<td>n&uacute;meros de p&aacute;ginas para formularios multip&aacute;ginas</td>
</tr>
<tr><td>this_page</td>
<td>n&uacute;mero para la corriente p&aacute;gina para formularios multip&aacute;ginas </td>
</tr>
<tr><td>title_page_x_of_y</td>
<td>muestra a &quot;p&aacute;gina x de y&quot; para formularios multip&aacute;ginas</td>
</tr>
<tr><td>css_class</td>
<td>Clase CSS para el formulario</td>
</tr>
<tr><td>form_name</td>
<td>Nombre del formulario</td>
</tr>
<tr><td>form_id</td>
<td>ID del formulario en la base de datos</td>
</tr>
<tr><td>prev</td>
<td>Bot&oacute;n &quot;Volver&quot; para formularios multipartes</td>
</tr>
<tr><td>submit</td>
<td>Botones &quot;Continuar&quot; o &quot;Enviar&quot; para formularios multipartes, se ajusta autom&aacute;ticamente</td>
</tr>
</table>
<p>No se para que quiere usted algunos de esos, pero all&iacute; est&aacute;n...</p>';
$lang['post_install'] = '<p>Tenga por seguro en activar el permiso &quot;Modificar Formularios&quot; para aquellos usuarios o grupos de usuarios que administrar&aacute;n los formularios de contacto. Tambi&eacute;n, si usted va a enviar el resultado de los formularios por email, haga una actualizaci&oacute;n de la Configuraci&oacute;n en forma apropiada.</p>
<p>Por favor tenga en cuenta que un formulario de contacto no debe estar activo (p.ej., en uso por el p&uacute;blico) mientras usted est&aacute; en el proceso de editarlo. Usted debe crear el formulario, y luego colocar el tag correspondiente en una p&aacute;gina de contenido activa s&oacute;lo cuando haya terminado de editarlo. De otra forma, puede obtener resultados con errores.</p>
<p>Adem&aacute;s, esta versi&oacute;n no soporta el editado paralelo de los formularios. Por favor instruya a los administradores para que tengan el cuidado de editar en forma exclusiva un formulario, evitando coincidir en la tarea con otro administrador.</p>';
$lang['help'] = '<h3>Whyat Does This Do?</h3>
<p>The Form Builder Module allows you to create feedback forms (in fact, it&#039;s a replacement of the original Feedback Form module), with the added power of database storage. With its companion module Form Browser, you can use it to create simple database applications.</p>
<p>The forms created using the Form Builder may be inserted
into templates and/or content pages. Forms may contain many kinds of inputs, and may have
validation applied to these inputs. The results of these forms may be handled in a variety of ways.</p>

<h3>How Do I Use it?</h3>
<P>Install it, and poke around the menus. Play with it. Try creating forms, and adding them to your content.
If you get stuck, chat with me on the #cms IRC channel, post to the forum, send me email, or, if you&#039;re
really desperate, read the rest of this page.</P>

<h3>How Do I Create a Form</h3>
<p>In the CMS Admin Menu, you should get a new menu item called FormBuilder. Click on this. On the page
that gets shown, there are options (at the bottom of the list of Forms) to Add a New Form or Modify
Configuration.</p>

<h3>Adding a Form to a Page</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module=&#039;FormBuilder&#039; form=&#039;sample_form&#039;}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page&#039;s content if you use a WYSIWYG editor such as TinyMCE, FCKEdit, or HTMLArea. These editors may stealthily
change the quote marks (&quot;) into HTML entities (&amp;quot;), and the forms will not show up. Try using
single quotes (&#039;) or editing the HTML directly.</p>

<h3>Working with Forms</h3>
<p>By clicking on a Form&#039;s name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you&#039;ll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing.</p>
<p>Below this, if you have it enabled, is the &quot;fast field adder&quot; pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Form Submission</h4>
<p>When the form is submitted, you can either redirect the user to another page of your site, or you can present the user some message (which can contain any of the user&#039;s form entries, or just static text). In this tab, you select which of these approaches you wish to use, and, if you chose redirection, it allows you to pick the page to redirect users to after a successful form submission.</p>
<p>Also on this page, you can specify the labels of various submission buttons (&quot;Previous&quot;, &quot;next&quot;, &quot;submit&quot;). You can also opt to have some Javascript added to the last page of a form that will prevent multiple submissions (useful on slow servers).</p>
<h4>Form Display Options</h4>
<p>This tab allows for other form customizations, like the symbol to show for required fields.</p>
<h4>Captcha Settings</h4>
<p>If you have installed the Captcha module, this tab lets you configure the Captcha settings for your form.</p>
<h4>Form Template</h4>
<p>This is where you do your customization work of your form&#039;s Smarty Template. See the section called Form Template Variables below.</p>
<p>The form should default to a Custom template that documents the Smarty tags available to you.</p>
<p>Unless you&#039;re a Smarty expert, you probably don&#039;t want to mess around with this. If you are a Smarty expert, this is where you can unleash your magic.</p>
<h4>Submission Template</h4>
<p>If, in the Form Submission tab, you selected &#039;Display &quot;Submission Template&quot;, this is where you can create that template. There is a display of which smarty variables are available to you, and a button to generate a sample template.</p>
<p>If you&#039;re a Smarty expert, you can do all manner of creative and powerful things here. If you&#039;re not a Smarty expert, you might just want to use the default.
</p>

<h3>Adding Fields to your Form</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it&#039;s submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it&#039;s safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked &quot;Required&quot;, which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to &quot;view source&quot; on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It&#039;s really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It&#039;s really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
<li>Time Picker. This is a set of pulldowns allowing the user to select a time (using 12 or 24 hour clock).</li>
<li>File Upload. This is a file upload field.</li>
<li>Link (User Entered). This creates a double input field for getting a link URL and link title.</li>
<li>Text Field (Multiple). This field creates one or more text inputs with add and delete buttons, effectively giving the end user a way of creating variable-length lists.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the &quot;From&quot; field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the &quot;From&quot; field.</li>
<li>Email Subject Field. This allows users to provide a subject for their email. The email generated when the form gets handled will use this in the &quot;Subject&quot; field. This may cause trouble with certain dispositions that want to control the Email Subject, so use it with caution.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Fieldset Start. Combined with Fieldset End, this allows you to group various fields within your form. Use this to start a given grouping.</li>
<li>-Fieldset End. Combined with Fieldset Start, this allows you to group various fields within your form. Use this to end a given grouping.</li>
<li>-Hidden Field. This allows you to embed a hidden field in your form.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you&#039;re not using a Custom Template to render your form.</li>
<li>-Static Link. This allows you to put a link to a given page into your form. Optionally, you can have it autopopulate with the page where the form is embedded (useful if you\&#039;re sending results via email).</li>
<li>-Computed Field. This allows you to embed a computed field in your form. It is not visible to the user until after the form is submitted. It allows you to do simple arithmetic or string concatenation.</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<ul><li>*Call a User Defined Tag With the Form Results. This submits all the form results to the User-Defined Tag you specify. The UDT can handle the results however it wants.</li>
<li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these &quot;Director&quot; pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email to User-Supplied Address. This puts an input field in the form for the user to populate with an email address. The form results get sent to that address. Beware of Spam abuse! Active the primitive anti-spam features in the FormBuilder configuration screen.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Redirect to Page Based on Pulldown. This allows you to redirect the form to a different site page depending on its value. If you have multiple dispositions, make sure this is used last.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered &quot;approved,&quot; and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the &quot;output&quot; directory under the
module&#039;s installation directory, assuming the web server has permission to write there.</li>
<li>*Save Results to File Based on Pulldown. Like the Flat File disposition, except the value of a pull-down determines which file results get written to.</li>
<li>*Save Results to File(s) Based on Multiple Selections. Like the Flat File disposition, except the value(s) of checkboxes  determines which file(s) results get written to.</li>
</ul></li></li></ul>


<h3>Passing Default Values to Forms</h3>
<p>Calguy added a nice feature, which is that you can pass default field values to your form via the module tag. This allows you to have
the same form in multiple places, but with different default values. It may not work for more exotic field types, but for fields that have
a single value, you can specify like:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_<i>FIELDNAME</i>=&#039;default_value&#039;}</p>
<p>This will set the field with <i>FIELDNAME</i> to &#039;default_value&#039;.</p>
<p>This can be problematic, as sometimes field names are unweildy or contain characters that don&#039;t work well with Smarty. So there is an
alternative like this:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_fld<i>NUMBER</i>=&#039;default_value&#039;}</p>
<p>That uses field <i>NUMBER</i>, where <i>NUMBER</i> is the internal FormBuilder field id. You might wonder how you know what that id is. Simply go into the FormBuilder configuration tab,
and check &quot;Show Field IDs&quot;</p>

<h3>Email and Flat File Templates</h3>
<p>Many disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it&#039;s own best guess, which may or may not work out to your liking. You can always click on the &quot;Create Sample Template&quot; and then customize the results.</p>
<p>To the right, you&#039;ll find a legend which lists all of the variables that are available to you to use in your template. As of version 0.3, variables have two names, one based on the field name, the other based on the field ID. If you use field names that have characters outside of the ASCII 32-126 range, it will be safer to use the ID-based variables.</p>
<p><strong>Note that once you&#039;ve changed a template, it will no longer automatically add new fields.</strong> For this reason, it&#039;s usually best to create your templates as the last step of creating your form.</p>
<p>As of version 0.2.4, you can opt to send any of these emails as HTML email. There should be a checkbox at the top of the template page for this. There is also a &quot;Create Sample HTML Template&quot; button over in the legend area. For HTML email, the email body will also provide the default text-only values.</p>

<h3>Configuration</h3>
<p>There are some global configuration options for FormBuilder:</p>
<ul>
<li>Enable fast field add pulldown. This enables the pulldown on the Form Edit page which saves a step in the creation of new fields.</li>
<li>Hide Errors. This is set by default. Unchecking it will cause more detailed errors to be displayed if there are problems when you submit your form.</li>
<li>Require Field Names. Typically, you will want form fields to be named so you can tell which is which. However, in some cases, you might want to have nameless fields. Uncheck this if you want to allow nameless fields.</li>
<li>Unique Field Names. Typically, you will want form fields to have unique names so you can tell which is which. Uncheck this if you want to allow fields to share names.</li>
<li>Use relaxed email validation. This uses a less restrictive regular expression for validating email; e.g., x@y will be allowed, where typically x@y.tld is required.</li>
<li>Show Form Builder Version. Displays the version of FormBuilder you&#039;re using in a comment when the form is generated. Typically only useful when debugging.</li>
<li>Enable primitive anti-spam features. When turned on, this allows any given IP address to only generate 10 emails per hour.</li>
<li>Show Field IDs. When turned on, FormBuilder will display field ids when adding or editing a form.</li>
</ul>
<h3>Styling and CSS</h3>
<p>Paul Noone graciously provides us all with a pretty good standard CSS that you can use for forms:</p>
<pre>
	/* Sample FormBuilder CSS base */
	form {margin-top:0}
	form, td, th, li { font-size: 100%}
	form div {margin-bottom:0}
	fieldset div {
		margin-bottom:0.5em;
		margin-left:1em;
	}
	fieldset div div {
		margin-top:0.5em;
		margin-left:1em
	}
	fieldset {
		margin-bottom:1em;
		border:1px solid #F60;
		padding:0.5em
	}
	fieldset label {
		width:auto;
	}
	legend {
		color:#FFF;
		background:#F60;
		font-style:italic;
		font-size:1.2em;
		margin-bottom:0.5em;
		padding:0.2em;
		width:auto;
		border:1px solid #CCC
	}
	textarea {
		margin: 0.5em 0;
		width:98%;
		height: 6em
	}

	/* Apply this class to text/select input fields with shorter labels
		to help alignment */
	.short-label label {float:left; width:10em}
	.short-label fieldset div input,
	.short-label fieldset div select {width:16em}

	/* Pretty up your Captcha image output */
	.captcha {
		margin:0.5em 0;
		width:200px;
		text-align:center
	}
	.captcha img {border:1px solid #F60; margin-bottom:0.5em}
	.captcha input {width:196px; margin-top:0.5em}

	/* Just a bit more room for the Submit button */
	.submit {margin-top:0.5em}
</pre>

<h3>Form Template Variables</h3>

<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>


<h3>Known Issues</h3>
<ul>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder cannot yet be inlined. That should be a simple upgrade down the line.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn&#039;t matter since the user side is pretty simple.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you&#039;re running CMS 1.1 or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you&#039;re missing fields in an email that gets generated, check the disposition field&#039;s template, and make sure you&#039;re specifying the missing fields. Seems obvious, but it&#039;s an easy mistake to make.</li>
<li>Uncheck the &quot;Hide Errors&quot; checkbox in the global options, and see what message gets displayed when you submit your form.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is no longer a particularly early version, but it is probably still buggy. While I&#039;ve done all I can
to make sure no egregious bugs have crept in, I have to admit that during early testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor&#039;s nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>.</li>
<li>Additional discussion of this module may also be found in the <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2007, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '<ul>
<li>Version 0.4.4. 26 Sept 07. Bugfixes for radio button groups, fix for validation of DispositionDeliverToEmailAddressField.</li>
<li>Version 0.4.3. 18 Sept 07. Bugfixes for pulldowns using numbers, option to inline form, fixes for table-layouts provided by Ap Muthu, fix for requirability of Dispositions.</li>
<li>Version 0.4.2. 14 Sept 07. Bugfixes for XML export, RadioButton Group submission, and HTML labels.</li>
<li>Version 0.4.1. Bugfixes for File Disposition Types.</li>
<li>Version 0.4
	<ul>
		<li>Upped minimum CMS version to 1.1</li>
		<li>Numerous Bug fixes; too many to enumerate here</li>
		<li>Massive rejiggering of code to work with CMS MS 1.1 parameter sanitizing regime</li>
		<li>Added field types: &quot;TextField (Multiple)&quot; and &quot;Computed Field&quot;</li>
		<li>Added dispositions: &quot;Save Results to File Based on Pulldown&quot; and &quot;Save Results to File(s) Based on Multiple Selections&quot;(Calguy)</li>
		<li>Added neat-o AJAX-y template-copying for Form Templates, gave versions of old table-based templates to soothe the raging masses.</li>
		<li>Added ability to pass default values to form elements from module tag using value_FIELDNAME=&quot;value&quot; syntax (Calguy)</li>
		<li>Added option to display field ids in admin (Calguy)</li>
	</ul>
</li>
<li>Version 0.3
   <ul>
      <li>Added Captcha module support.</li>
      <li>Reworked labeling of form elements to be XHTML compliant</li>
      <li>Added Paul Noone&#039;s new, improved contact form templates</li>
      <li>Implementation of Email Subject Field</li>
      <li>Added admin-specifiable values to hidden field type, which may contain parsable smarty tags</li>
      <li>Text Area Field now allows specification of rows and cols in the admin, instead of CSS</li>
      <li>Added Drag&#039;n&#039;Drop reordering of form fields.</li>
      <li>Added non-blank field name and unique field name global configuration options and validation</li>
      <li>Implemented templated display of form results upon submission in addition to page redirecting</li>
      <li></li>
   </ul>
</li>
<li>Version 0.2.4 - 09 May 2007
   <p>Big release:<ul>
   <li>Added &quot;Email Form to User-Supplied Address&quot; disposition.</li>
   <li>Added &quot;TimePicker&quot; field type. Split &quot;Link&quot; field into a &quot;User-supplied Link&quot; field and a &quot;Static Link&quot; field.</li>
   <li>Added HTML email option and auto-templates for all email dispositions.</li>
   <li>Added primitive anti-spam features.</li>
   <li>Added XML-based import and export of forms.</li>
   </ul>
   </p>
</li>
<li>Version 0.2.3
   <p>Add the ability to call a selectable user defined tag upon disposition of the form.</p>
</li>
<li>Version 0.2.2
   <p>Many thanks to Utter Design for sponsoring some changes and bugfixes, which include:
   <ul>
      <li>Added file upload capabilities to the email disposition</li>
      <li>Add PageSetStart and PageSetEnd field types
      <p>These field types allow you to create fieldsets in your form, and organise
      your fields logically for the user.  You can even nest fieldsets, and
      associate a style with them appropriately.  The default template was changed
      to prevent it from wrapping a div around these types of fields.
      </p>
      </li>
      <li>Fixed a problem with DATETIME fields on install
      <p>This solves a problem when on install the response table would sometimes not get created when using adodb lite</li>
      </li>
   </ul>
   </p>
</li>
<li>Version 0.2 - 14 November 2006. Calguy &amp; tsw&#039;s bug fixes for field re-ordering and custom templates. Additional bug fixes for field labels.</li>
<li>Version 0.1 - 8 July 2006. Initial Release</li>
</ul>
';
$lang['utma'] = '156861353.3874850749547776000.1214866856.1222883830.1222885883.147';
$lang['utmz'] = '156861353.1222819569.144.15.utmccn=(organic)|utmcsr=google|utmctr=cmsms pretty urls|utmcmd=organic';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353.1.10.1222885883';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/et_EE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Vormi Ehitaja';
$lang['field_type_'] = 'V&auml;lja T&uuml;&uuml;p M&auml;&auml;ramata';
$lang['field_type_TextField'] = 'Tekstisisend';
$lang['field_type_TextAreaField'] = 'Tekstiv&auml;li';
$lang['field_type_CheckboxField'] = 'Linnuke';
$lang['field_type_CheckboxGroupField'] = 'Linnukeste Grupp';
$lang['field_type_PulldownField'] = 'Valikmen&uuml;&uuml;';
$lang['field_type_MultiselectField'] = 'Multivalik';
$lang['field_type_StatePickerField'] = 'USA Osariikide Valik';
$lang['field_type_CountryPickerField'] = 'Riigi Valik';
$lang['field_type_DatePickerField'] = 'Kuup&auml;eva Valik';
$lang['field_type_RadioGroupField'] = 'Raadionuppude Grupp';
$lang['field_type_DispositionDirector'] = '*Saada tulemused E-mailiga Valikmen&uuml;&uuml; p&otilde;hjal';
$lang['field_type_DispositionEmail'] = '*Saada tulemused E-mailiga Aadressi(de)le';
$lang['field_type_DispositionEmailConfirmation'] = '*Valideeri E-maili teel';
$lang['field_type_DispositionFile'] = '*Salvesta tulemused Faili';
$lang['field_type_DispositionDatabase'] = '*Salvesta tulemused Andmebaasi';
$lang['field_type_PageBreakField'] = '-J&auml;rgmine leht';
$lang['field_type_FileUploadField'] = 'Faili &Uuml;leslaadimine';
$lang['field_type_FromEmailAddressField'] = 'E-maili &quot;Aadressilt&quot; V&auml;li';
$lang['field_type_FromEmailNameField'] = 'E-maili &quot;Kellelt&quot; V&auml;li';
$lang['field_type_StaticTextField'] = '-Staatiline tekst';
$lang['validation_none'] = 'Ei valideerita';
$lang['validation_numeric'] = 'Arv';
$lang['validation_integer'] = 'T&auml;isarv';
$lang['validation_email_address'] = 'E-maili Aadress';
$lang['validation_must_check'] = 'Linnuke N&otilde;utud';
$lang['validation_regex_match'] = 'Match Regular Expression';
$lang['validation_regex_nomatch'] = 'Doesn&#039;t match Regular Expression';
$lang['please_enter_a_value'] = 'Palun t&auml;ida lahter &quot;%s&quot;';
$lang['please_enter_a_number'] = 'Palun sisesta lahtrisse &quot;%s&quot; arv';
$lang['please_enter_valid'] = 'Palun t&auml;ida lahter &quot;%s&quot; korrektselt';
$lang['please_enter_an_integer'] = 'Palun sisesta lahtrisse &quot;%s&quot; t&auml;isarv';
$lang['please_enter_an_email'] = 'Palun sisesta lahtrisse &quot;%s&quot; korrektne e-maili aadress';
$lang['not_valid_email'] = '&quot;%s&quot; ei ole korrektne e-maili aadress!';
$lang['please_enter_no_longer'] = 'Palun sisesta v&auml;&auml;rtus, mis ei ole pikem kui %s t&auml;hem&auml;rki';
$lang['title_list_delimiter'] = 'T&auml;hem&auml;rk, mida kasutaja eraldajana tulemustes, milles on rohkem kui &uuml;ks v&auml;&auml;rtus';
$lang['you_need_permission'] = 'Selle funktsiooni jaoks on sul vaja &quot;%s&quot; &otilde;igusi';
$lang['lackpermission'] = 'Vabandust! Sellele sektsioonile ligi p&auml;&auml;semiseks ei ole sul piisavalt &otilde;igusi.';
$lang['field_order_updated'] = 'V&auml;ljade j&auml;rjekord uuendatud.';
$lang['form_deleted'] = 'Vorm kustutatud.';
$lang['field_deleted'] = 'V&auml;li kustutatud.';
$lang['configuration_updated'] = 'Konfiguratsioon Uuendatud.';
$lang['you_must_check'] = 'J&auml;tkamiseks pead tegema linnukese &quot;%s&quot; kasti.';
$lang['must_specify_one_destination'] = 'Sa pead sisestama v&auml;hemalt &uuml;he sihtaadressi!';
$lang['are_you_sure_delete_form'] = 'Oled kindel, et soovid kustutada %s vormi?';
$lang['are_you_sure_delete_field'] = 'Oled kindel, et soovid kustutada %s v&auml;lja?';
$lang['notice_select_type'] = 'Laiendatud seaded ei ole saadaval niikaua, kuni pole m&auml;&auml;ratud v&auml;lja t&uuml;&uuml;pi.';
$lang['field_name_in_use'] = 'V&auml;lja nimi &quot;%s&quot; on juba kasutusel. Palun kasuta unikaalseid v&auml;lja nimesid.';
$lang['abbreviation_length'] = 'Pikkus: %s';
$lang['boxes'] = '%s kasti';
$lang['options'] = '%s valikut';
$lang['text_length'] = '%s t&auml;hem&auml;rki.';
$lang['order'] = 'J&auml;rjekord';
$lang['unspecified'] = '[m&auml;&auml;ramata]';
$lang['added'] = 'lisatud';
$lang['updated'] = 'uuendatud';
$lang['select_one'] = 'Vali &Uuml;ks';
$lang['select_type'] = 'Vali T&uuml;&uuml;p';
$lang['to'] = 'Kellele';
$lang['recipients'] = 'saajad';
$lang['destination_count'] = '%s sihtaadressi';
$lang['save'] = 'Salvesta';
$lang['add'] = 'Lisa';
$lang['update'] = 'Uuenda';
$lang['save_and_continue'] = 'Salvesta ja J&auml;tka Toimetamist';
$lang['information'] = 'Informatsioon';
$lang['automatic'] = 'Automaatne';
$lang['forms'] = 'Vormid';
$lang['form'] = '%s Vorm';
$lang['configuration'] = 'Konfiguratsioon';
$lang['tab_main'] = 'Peamine';
$lang['tab_additional'] = 'Vormi Seaded';
$lang['tab_advanced'] = 'Laiendatud Seaded';
$lang['tab_tablelayout'] = 'Tabelip&otilde;hise K&uuml;ljenduse Valikud';
$lang['tab_templatelayout'] = 'Mallip&otilde;hise K&uuml;ljenduse Valikud';
$lang['field_requirement_updated'] = 'V&auml;lja &#039;kohustuslik&#039; staatus uuendatud.';
$lang['maximum_size'] = 'Max. Suurus';
$lang['permitted_extensions'] = 'Laiendused';
$lang['permitted_filetypes'] = 'Lubatud failit&uuml;&uuml;bid';
$lang['file_too_large'] = '&Uuml;les laetud fail on liiga suur! Maksimaalne suurus on:';
$lang['illegal_file_type'] = 'Seda t&uuml;&uuml;pi faili ei ole lubatud &uuml;les laadida. Palun kontrolli, et faili laiend on korrektne.';
$lang['uninstalled'] = 'Moodul eemaldatud.';
$lang['installed'] = 'Mooduli versioon %s installeeritud.';
$lang['upgraded'] = 'Moodul uuendatud versioonile %s.';
$lang['button_previous'] = 'Tagasi...';
$lang['button_submit'] = 'Saada Vorm';
$lang['button_continue'] = 'J&auml;tka...';
$lang['value_checked'] = 'M&auml;rgitud';
$lang['value_unchecked'] = 'M&auml;rkimata';
$lang['add_options'] = 'Lisa Veel Valikuid';
$lang['delete_options'] = 'Kustuta M&auml;rgitud Valikud';
$lang['add_checkboxes'] = 'Lisa Veel Linnukesi';
$lang['delete_checkboxes'] = 'Kustuta M&auml;rgitud Linnukesed';
$lang['add_address'] = 'Lisa Veel &Uuml;ks Aadress';
$lang['delete_address'] = 'Kustuta M&auml;rgitud Aadressid';
$lang['add_destination'] = 'Lisa Sihtaadress';
$lang['delete_destination'] = 'Kustuta M&auml;rgitud Sihtaadressid';
$lang['title_maximum_length'] = 'Maksimaalne Pikkus';
$lang['title_checkbox_label'] = 'Valiku pealkiri';
$lang['title_checked_value'] = 'V&auml;&auml;rtus m&auml;rgituna';
$lang['title_unchecked_value'] = 'V&auml;&auml;rtus m&auml;rkimata';
$lang['title_checkbox_details'] = 'Linnukeste Grupi Detailid';
$lang['title_delete'] = 'Kustuta?';
$lang['title_select_one_message'] = '&quot;Vali &Uuml;ks&quot; Tekst';
$lang['title_selection_subject'] = 'Valiku Nimi';
$lang['title_select_default_country'] = 'Algne Valik';
$lang['title_select_default_state'] = 'Algne Valik';
$lang['title_option_name'] = 'Valiku Nimi';
$lang['title_option_value'] = 'V&auml;&auml;rtus';
$lang['title_pulldown_details'] = 'Valikmen&uuml;&uuml; Valikud';
$lang['title_multiselect_details'] = 'Multivaliku Valikud';
$lang['title_destination_address'] = 'Sihtaadress';
$lang['title_email_from_name'] = 'E-maili &quot;Kellelt&quot; v&auml;li';
$lang['title_relaxed_email_regex'] = 'Kasuta l&otilde;tva e-maili valideerimist';
$lang['title_relaxed_regex_long'] = 'Kasuta l&otilde;tva e-maili valideerimist (nt., luba &quot;x@y&quot; selle asemel, et n&otilde;uda &quot;x@y.tld&quot;)';
$lang['title_email_from_address'] = 'E-maili &quot;Aadressilt&quot; v&auml;li';
$lang['title_email_encoding'] = 'E-maili kodeering';
$lang['title_director_details'] = 'Valikmen&uuml;&uuml; p&otilde;hise E-maileri Detailid';
$lang['title_file_name'] = 'Failinimi';
$lang['title_email_subject'] = 'E-maili Teema';
$lang['title_form_name'] = 'Vormi Nimi';
$lang['title_form_status'] = 'Vormi Staatus';
$lang['title_ready_for_deployment'] = 'Valmis avaldamiseks';
$lang['title_not_ready1'] = 'Ei ole valmis';
$lang['title_redirect_page'] = 'Leht, kuhu suunata peale vormi saatmist';
$lang['title_not_ready2'] = 'Palun lisa vormile v&auml;li, et kasutaja sisestusi k&auml;sitletaks.';
$lang['title_not_ready_link'] = 'kasuta seda otseteed';
$lang['title_form_alias'] = 'Vormi Alias';
$lang['title_form_fields'] = 'Vormi V&auml;ljad';
$lang['title_field_name'] = 'V&auml;lja Nimi';
$lang['title_radiogroup_details'] = 'Raadionuppude Grupi Detailid';
$lang['title_field_type'] = 'V&auml;lja T&uuml;&uuml;p';
$lang['title_not_ready3'] = 'loomaks vormi k&auml;sitlemise v&auml;li.';
$lang['title_add_new_form'] = 'Lisa Uus Vorm';
$lang['title_show_version'] = 'N&auml;ita Vormi Ehitaja Versiooni?';
$lang['title_show_version_long'] = 'See sisaldab sinu Vormi Ehitaja installeeritud versiooni kommentaarides, et aidata vigade otsimisel.';
$lang['title_add_new_field'] = 'Lisa Uus V&auml;li';
$lang['title_form_submit_button'] = 'Vormi Saatmisnupu Tekst';
$lang['title_form_next_button'] = 'Vormi &quot;J&auml;rgmine&quot; - nupu tekst (kasutatakse mitmelehek&uuml;ljelise vormi puhul)';
$lang['title_form_prev_button'] = 'Vormi &quot;Eelmine&quot; - nupu tekst (kasutatakse mitmelehek&uuml;ljelise vormi puhul)';
$lang['title_field_validation'] = 'V&auml;lja Valideermine';
$lang['title_form_css_class'] = 'Vormi CSS klass';
$lang['title_field_css_class'] = 'V&auml;lja CSS klass';
$lang['title_form_required_symbol'] = 'S&uuml;mbol, millega m&auml;rkida kohustuslikud v&auml;ljad';
$lang['title_field_required'] = 'Kohustuslik';
$lang['title_field_required_long'] = 'T&auml;itmine kohustuslik';
$lang['title_hide_label'] = 'Peida Pealkiri';
$lang['title_hide_label_long'] = 'Peida v&auml;lja nimi vormil';
$lang['title_text'] = 'Kuvatav staatiline tekst';
$lang['title_field_regex'] = 'Valideerimise Regex';
$lang['title_lines_to_show'] = 'Kuvatav ridade arv';
$lang['no_default'] = 'Puudub';
$lang['redirect_after_approval'] = 'Lehkt, millele suunata p&auml;rast n&otilde;usoleku kinnitamist.';
$lang['title_regex_help'] = 'This regular expression will only be used if &quot;validation type&quot; is set to a regex-related option. Include a full Perl-style regex, including the start/stop slashes and flags (e.g., &quot;/image\.(\d+)/i&quot;)';
$lang['title_field_required_abbrev'] = 'Kohust.';
$lang['title_title_position'] = 'V&auml;lja Tiitli Asukoht (mitte-CSS k&uuml;ljenduse puhul)';
$lang['title_table_layout_left'] = 'Tiitel Vasakul';
$lang['title_table_layout_above'] = 'Tiitel &Uuml;leval';
$lang['title_hide_errors'] = 'Peida Vead';
$lang['title_form_displaytype'] = 'Vormi Kuvamise Viis';
$lang['title_hide_errors_long'] = '&Auml;ra n&auml;ita kasutajatele veateateid';
$lang['title_email_template'] = 'E-maili Mall';
$lang['title_maximum_size'] = 'Maksimaalne &uuml;leslaetava faili suurus (kilobaitides)';
$lang['title_permitted_extensions'] = 'Lubatud Laiendused';
$lang['title_permitted_extensions_long'] = 'Sisesta komadega eraldatud nimekiri, j&auml;ta v&auml;lja punktid (n.t., &quot;jpg,gif,jpeg&quot;). T&uuml;hikuid ignoreeritakse. J&auml;ttes selle v&auml;lja t&uuml;hjaks ei kehti &uuml;htegi piirangut.';
$lang['title_show_limitations'] = 'N&auml;ita piiranguid?';
$lang['title_show_limitations_long'] = 'Display any size and extension restrictions with the upload field?';
$lang['title_form_template'] = 'Vormi Vaate jaoks kasutatav Mall';
$lang['title_page_x_of_y'] = 'Leht: %s kokku lehti: %s';
$lang['title_no_advanced_options'] = 'V&auml;ljal ei ole laiendatud seadeid';
$lang['title_form_unspecified'] = 'T&auml;itmata v&auml;ljade tekst';
$lang['title_enable_fastadd_long'] = 'Luba kasutada Kiirvalikud vormide ehitamisel?';
$lang['title_enable_fastadd'] = 'Luba kasutada Kiirvalikuid?';
$lang['title_fastadd'] = 'Kiirvalik';
$lang['help_variables_for_template'] = 'Malli Muutujad';
$lang['help_submission_date'] = 'Saadetud';
$lang['help_server_name'] = 'Sinu server';
$lang['help_sub_source_ip'] = 'IP address of person using form';
$lang['help_sub_url'] = 'URL of page containing form';
$lang['help_other_fields'] = 'Other fields will be available as you add them to the form.';
$lang['help_date_format'] = 'See <a href=&quot;http://www.php.net/manual/en/function.date.php&quot; target=_NEW>the PHP Manual</a> for formatting help.';
$lang['help_variable_name'] = 'Muutuja';
$lang['help_form_field'] = 'Vastav V&auml;li';
$lang['link_back_to_form'] = '&laquo; Back to Form';
$lang['title_create_sample_template'] = 'Loo N&auml;idismall';
$lang['title_create_sample_header'] = 'Loo N&auml;idisp&auml;is';
$lang['help_tab_symbol'] = 'a tab character';
$lang['title_file_template'] = 'Template for one line of output file';
$lang['title_file_header'] = 'Template for the header of output file';
$lang['title_confirmation_url'] = 'URL to click for form confirmation';
$lang['no_referrer_info'] = 'No HTTP_REFERER info available (probably due to use of User Email Validation)';
$lang['validation_param_error'] = 'Validation Parameter Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_response_error'] = 'Validation Repsonse Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_no_field_error'] = 'Validation Repsonse Error. No email validation field in this form!';
$lang['title_date_format'] = 'Date Format (standard <a href=&quot;http://www.php.net/manual/en/function.date.php&quot;>PHP Date Formats</a>)';
$lang['title_use_wysiwyg'] = 'Kasuta tekstiv&auml;ljal WYSIWYG-toimetajat?';
$lang['disptype_table'] = 'Tabel/CSS';
$lang['disptype_css'] = 'Ainult CSS';
$lang['disptype_template'] = 'Mall';
$lang['admindesc'] = 'Add, edit and manage interactive Forms';
$lang['date_january'] = 'Jaanuar';
$lang['date_february'] = 'Veebruar';
$lang['date_march'] = 'M&auml;rts';
$lang['date_april'] = 'Aprill';
$lang['date_may'] = 'Mai';
$lang['date_june'] = 'Juuni';
$lang['date_july'] = 'Juuli';
$lang['date_august'] = 'August';
$lang['date_september'] = 'September';
$lang['date_october'] = 'Oktoober';
$lang['date_november'] = 'November';
$lang['date_december'] = 'Detsember';
$lang['submission_error'] = 'Sorry! There was an error handling your form submission.';
$lang['submit_error'] = 'FormBuilder submit error: %s';
$lang['upload_attach_error'] = 'Upload/Attachment error on file %s (tmp_name: %s, of type %s)';
$lang['submission_error_file_lock'] = 'Error. Unable to obtain lock for file.';
$lang['email_default_template'] = 'FormBuilder Submission
';
$lang['email_template_not_set'] = '<br/>Email Template not yet set!';
$lang['missing_cms_mailer'] = 'FormBuilder: Cannot find required module CMSMailer!';
$lang['user_approved_submission'] = 'User approved submission %s from %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Event triggered when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Event triggered if there is an error when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Event triggered when a FormBuilder form is displayed';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Event triggered when a FormBuilder form is submitted.</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Event triggered if there is an error when a FormBuilder form is submitted</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>error</em> - A list of all known errors (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Event triggered when a FormBuilder form is displayed</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
</ul> ';
$lang['post_install'] = '<p>Make sure to set the &quot;Modify Forms&quot; permissions
on users who will be administering feedback forms. Also, if you&#039;ll be emailing form
results, be sure to update the Configuration appropriately.</p>
<p>Please be aware that a feedback form should not be active (e.g., usable by the public) while
you are still editing the form. You should create the form, and place the tag into an active
content page only when you have finished editing. Otherwise, erroneous results could be returned.</p>
<p>Additionally, this version does not support parallel editing of forms. Please take care that
only one admin is editing a given form at a given time.</p>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create feedback forms (in fact, it&#039;s a replacement of the original Feedback Form module), with the added power of database storage. With its companion module Form Browser, you can use it to create simple database applications.</p>
<p>The forms created using the Form Builder may be inserted
into templates and/or content pages. Forms may contain many kinds of inputs, and may have
validation applied to these inputs. The results of these forms may be handled in a variety of ways.</p>

<h3>How Do I Use it?</h3>
<P>Install it, and poke around the menus. Play with it. Try creating forms, and adding them to your content.
If you get stuck, chat with me on the #cms IRC channel, post to the forum, send me email, or, if you&#039;re
really desperate, read the rest of this page.</P>

<h3>How Do I Create a Form</h3>
<p>In the CMS Admin Menu, you should get a new menu item called FormBuilder. Click on this. On the page
that gets shown, there are options (at the bottom of the list of Forms) to Add a New Form or Modify
Configuration.</p>

<h3>Adding a Form to a Page</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module=&#039;FormBuilder&#039; form=&#039;sample_form&#039;}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page&#039;s content if you use a WYSIWYG editor such as TinyMCE or HTMLArea. These editors may stealthily
change the quote marks (&quot;) into HTML entities (&amp;quot;), and the forms will not show up. Try using
single quotes (&#039;) or editing the HTML directly.

<h3>Working with Forms</h3>
<p>By clicking on a Form&#039;s name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you&#039;ll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing. You also select the display type. Your choices are:</p>
<ul>
<li>Table/CSS. The form is created using HTML tables. If you don&#039;t know what to choose, this is the easiest option, and will probably do most of what you want. You can still use CSS to style the form if you want.</li>
<li>Pure CSS. The form is created, with all the fields wrapped in <div> tags. You can then style the form as you see fit.</li>
<li>Custom Template. Basically, you get a smarty template, a bunch of variables, and you&#039;re on your own. You have the power to create whatever you want.</li>
</ul>
<p>Below this, if you have it enabled, is the &quot;fast field adder&quot; pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Form Settings</h4>
<p>Form Settings allows you to customize a lot of the messages and text in the controls for your form. It also allows you to pick a page to redirect users to after a successful form submission.</p>
<h4>Table-based Layout Options</h4>
<p>Table-layouts have gotten simpler, so your only option here is the position of the field names relative to the inputs. If you&#039;re using a Table/CSS layout, you can use this tab to select the field name positions.</p>
<h4>Template Layout Options</h4>
<p>This is where you do your customization work if your form uses a Custom Template.</p>
<p>The form should default to a a Custom template that documents the smarty tags available to you. Unless you&#039;re a smarty expert, you probably don&#039;t want to mess around with this. If you are a smarty expert, this is where you can unleash your magic.</p>
<h3>Adding Fields to your Form</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it&#039;s submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it&#039;s safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked &quot;Required&quot;, which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to &quot;view source&quot; on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It&#039;s really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It&#039;s really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the &quot;From&quot; field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the &quot;From&quot; field.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you&#039;re not using a Custom Template to render your form.</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<ul><li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these &quot;Director&quot; pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered &quot;approved,&quot; and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the &quot;output&quot; directory under the
module&#039;s installation directory, assuming the web server has permission to write there.
</ul></li></li></ul>

<h3>Email and Flat File Templates</h3>
<p>Man disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it&#039;s own best guess, which may or may not work out to your liking. You can always click on the &quot;Create Sample Template&quot; and then customize the results.</p>
<p>Note that once you&#039;ve changed a template, it will no longer automatically add new fields. For this reason, it&#039;s usually best to create your templates as the last step of creating your form.</p>

<h3>Known Issues</h3>
<ul>
<li>Some field types from FeedbackForms are not implemented in FormBuilder. If there is demand for them, they will be added.</li>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder cannot yet be inlined. That should be a simple upgrade down the line.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn&#039;t matter since the user side is pretty simple.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you&#039;re running CMS 1.0-svn or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you&#039;re missing fields in an email that gets generated, check the disposition field&#039;s template, and make sure you&#039;re specifying the missing fields. Seems obvious, but it&#039;s an easy mistake to make.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is a fairly early version, if not a rank beta release, and it is probably still buggy. While I&#039;ve done all I can
to make sure no egregious bugs have crept in, I have to admit that during testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor&#039;s nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href=&quot;http://dev.cmsmadesimple.org&quot;>Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href=&quot;mailto:sjg@cmsmodules.com&quot;><sjg@cmsmodules.com></a>.</li>
<li>Additional discussion of this module may also be found in the <a href=&quot;http://forum.cmsmadesimple.org&quot;>CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href=&quot;irc://irc.freenode.net/#cms&quot;>CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>  
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2006, Samuel Goldstein <a href=&quot;mailto:sjg@cmsmodules.com&quot;><sjg@cmsmodules.com></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&quot;http://www.gnu.org/licenses/licenses.html#GPL&quot;>GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '		    <ul>
		    <li>Versioon 0.1 - 8 July 2006. Esmane v&auml;ljalase</li>
		';
$lang['utma'] = '156861353.1526332053.1157121618.1157896763.1158163211.7';
$lang['utmz'] = '156861353.1157121618.1.1.utmccn=(direct)|utmcsr=(direct)|utmcmd=(none)';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/fi_FI.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Lomake editori';
$lang['field_type_'] = 'Kent&auml;n tyyppi&auml; ei ole asetettu';
$lang['field_type_CatalogerItemsField'] = 'Valitse yksi tai useampia cataloger itemeit&auml;';
$lang['field_type_FieldsetEnd'] = '-Fieldset alku';
$lang['field_type_FieldsetStart'] = '-Fieldset loppu';
$lang['field_type_TextField'] = 'Tekstikentt&auml;';
$lang['field_type_TextFieldExpandable'] = 'Tekstikentt&auml; (useita)';
$lang['field_type_TextAreaField'] = 'Tekstialue';
$lang['field_type_CheckboxField'] = 'Valintalaatikko';
$lang['field_type_CheckboxGroupField'] = 'Valintalaatikko ryhm&auml;';
$lang['field_type_PulldownField'] = 'Alasvetovalikko';
$lang['field_type_MultiselectField'] = 'Monivainta';
$lang['field_type_StatePickerField'] = 'Osavaltiovalikko (USA)';
$lang['field_type_ProvincePickerField'] = 'Kanadan provinssit -valikko';
$lang['field_type_CountryPickerField'] = 'Maavalinta';
$lang['field_type_DatePickerField'] = 'P&auml;iv&auml;ysvalinta';
$lang['field_type_TimePickerField'] = 'Aikavalinta';
$lang['field_type_RadioGroupField'] = 'Valintapalloryhm&auml;';
$lang['field_type_DispositionDirector'] = '* L&auml;het&auml; vastaukset alasvetovalikon mukaisesti';
$lang['field_type_DispositionFileDirector'] = '* Tallenna vastaukset alasvetovalikon mukaisesti';
$lang['field_type_DispositionMultiselectFileDirector'] = '* Tallenna vastaukset useisiin tiedostoihin eri valintojen mukaan';
$lang['field_type_DispositionPageRedirector'] = '* Ohjaa sivulle alasvetovalikon mukaan';
$lang['field_type_DispositionEmail'] = '* L&auml;het&auml; vastaukset asetettuihin email osoitteisiin';
$lang['field_type_DispositionEmailConfirmation'] = '* Tarkista email osoite';
$lang['field_type_DispositionFile'] = '* Tallenna vastaukset tiedostoon';
$lang['field_type_DispositionDatabase'] = '* Tallenna vastaukset tietokantaan';
$lang['field_type_DispositionFormBrowser'] = '* Tallenna tulokset FormBrowser v.3 modulille';
$lang['field_type_DispositionUserTag'] = '* Kustsu k&auml;ytt&auml;j&auml;n m&auml;&auml;rittelem&auml;&auml; tagia lomakkeen tuloksilla';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '* L&auml;het&auml; k&auml;ytt&auml;j&auml;n m&auml;&auml;rittelem&auml;&auml;n email-osoitteeseen';
$lang['field_type_DispositionEmailSiteAdmin'] = '* L&auml;het&auml; email CMS:n yll&auml;pitok&auml;ytt&auml;j&auml;lle';
$lang['field_type_PageBreakField'] = '- Sivun vaihto';
$lang['field_type_FileUploadField'] = 'Tiedoston lataus';
$lang['field_type_FromEmailAddressField'] = 'Email &quot;Osoite&quot; kentt&auml;';
$lang['field_type_FromEmailNameField'] = 'Email &quot;Nimi&quot; kentt&auml;';
$lang['field_type_FromEmailSubjectField'] = 'Email &quot;Aihe&quot; kentt&auml;';
$lang['field_type_StaticTextField'] = '- Kiinte&auml; teksti';
$lang['field_type_SystemLinkField'] = '- Kiinte&auml; linkki';
$lang['field_type_LinkField'] = 'Linkki (K&auml;ytt&auml;j&auml;n sy&ouml;tt&auml;m&auml;)';
$lang['field_type_HiddenField'] = '- Piilotettu kentt&auml;';
$lang['field_type_ComputedField'] = '- Laskettu kentt&auml;';
$lang['field_type_UniqueIntegerField'] = '- Yksil&ouml;iv&auml; kokonaisluku (sarjanumero)';
$lang['validation_none'] = 'Ei tarkistusta';
$lang['validation_numeric'] = 'Numeerinen';
$lang['validation_integer'] = 'Kokonaisluku';
$lang['validation_email_address'] = 'Email-osoite';
$lang['validation_usphone'] = 'Puhelinnumero (US)';
$lang['validation_must_check'] = 'Valinta vaaditaan';
$lang['validation_regex_match'] = 'Tarkista s&auml;&auml;nn&ouml;nmukaisella lausekkeella';
$lang['validation_regex_nomatch'] = 'Kent&auml;n arvo ei ole m&auml;&auml;rittelyn mukainen';
$lang['required_field_missing'] = 'Vaaditusta kent&auml;st&auml; puuttuu arvo';
$lang['please_enter_a_value'] = 'Ole hyv&auml; ja anna arvo kentt&auml;&auml;n &quot;%s&quot;';
$lang['please_enter_a_number'] = 'Sy&ouml;t&auml; numero kentt&auml;&auml;n &quot;%s&quot;';
$lang['please_enter_valid'] = 'Arvoa ei sallittu kent&auml;ss&auml; &quot;%s&quot;';
$lang['please_enter_an_integer'] = 'Sy&ouml;t&auml; kokonaisluku kentt&auml;&auml;n &quot;%s&quot;';
$lang['please_enter_an_email'] = 'Sy&ouml;t&auml; email osoite kentt&auml;&auml;n &quot;%s&quot;';
$lang['please_enter_a_phone'] = 'Sy&ouml;t&auml; puhelinnumero kentt&auml;&auml;n &quot;%s&quot;';
$lang['not_valid_email'] = '&quot;%s&quot; ei n&auml;yt&auml; olevan email-osoite';
$lang['please_enter_no_longer'] = 'Kent&auml;n maksimipituus on %s merkki&auml;';
$lang['title_list_delimiter'] = 'Erotinmerkki kentille jotka palauttavat enemm&auml;n kuin yhden arvon';
$lang['you_need_permission'] = 'Tarvitset &quot;%s&quot; oikeudet k&auml;ytt&auml;&auml;ksesi t&auml;t&auml; toimintoa';
$lang['lackpermission'] = 'Sinulla ei ole tarvittavia oikeuksia';
$lang['field_order_updated'] = 'Kenttien j&auml;rjestys p&auml;ivitetty';
$lang['form_deleted'] = 'Lomake poistettu';
$lang['field_deleted'] = 'Kentt&auml; poistettu';
$lang['configuration_updated'] = 'Asetukset p&auml;ivitetty';
$lang['you_must_check'] = 'Sinun tarvitsee valita &quot;%s&quot; jatkaaksesi';
$lang['must_specify_one_destination'] = 'V&auml;hint&auml;&auml;n yksi kohde tarvitaan';
$lang['are_you_sure_delete_form'] = 'Haluatko varmasti poistaa lomakkeen &quot;%s&quot;';
$lang['are_you_sure_delete_field'] = 'Haluatko varmasti poistaa kent&auml;n &quot;%s&quot;';
$lang['notice_select_type'] = 'Lis&auml;asetukset eiv&auml;t ole valittavissa ennen kent&auml;n tyypin valintaa';
$lang['field_name_in_use'] = 'Kent&auml;n nimi &quot;%s&quot; on jo k&auml;yt&ouml;ss&auml;.';
$lang['field_no_name'] = 'Kent&auml;ll&auml; tulee olla nimi';
$lang['anonymous'] = 'Tuntematon';
$lang['abbreviation_length'] = 'pituus: %s';
$lang['boxes'] = '%s laatikkoa';
$lang['options'] = '%s valintaa';
$lang['text_length'] = '%s merkki&auml;.';
$lang['order'] = 'J&auml;rjestys';
$lang['unspecified'] = '[ei m&auml;&auml;ritetty]';
$lang['added'] = 'lis&auml;tty';
$lang['updated'] = 'p&auml;ivitetty';
$lang['sort_options'] = 'J&auml;rjestys asetukset tulosteessa';
$lang['select_one'] = 'Valitse yksi';
$lang['select_type'] = 'Valitse tyyppi';
$lang['to'] = 'To';
$lang['yes'] = 'Kyll&auml;';
$lang['no'] = 'Ei';
$lang['recipients'] = 'vastaanottajat';
$lang['file_count'] = '%s mahdollista tiedostoa';
$lang['destination_count'] = '%s m&auml;&auml;r&auml;np&auml;&auml;t&auml;';
$lang['save'] = 'Tallenna';
$lang['add'] = 'Lis&auml;&auml;';
$lang['update'] = 'P&auml;ivit&auml;';
$lang['save_and_continue'] = 'Tallenna ja jatka muokkausta';
$lang['information'] = 'Tietoa';
$lang['automatic'] = 'Automaattinen';
$lang['forms'] = 'Lomakkeet';
$lang['form'] = 'Lomake %s';
$lang['configuration'] = 'Asetukset';
$lang['field_requirement_updated'] = 'Kent&auml;n &quot;vaadittu&quot; tila p&auml;ivitetty';
$lang['maximum_size'] = 'Maksimi koko';
$lang['permitted_extensions'] = 'P&auml;&auml;tteet';
$lang['permitted_filetypes'] = 'Sallitut tiedostotyypit';
$lang['file_too_large'] = 'Ladattu tiedosto on liian suuri. Suurin sallittu koko on:';
$lang['illegal_file_type'] = 'Tiedoston tyyppi&auml; ei ole sallittu. Tarkista tiedoston tyyppi.';
$lang['upload'] = 'Lataa';
$lang['form_imported'] = 'Lomake tuotu';
$lang['form_import_failed'] = 'Lomakkeen tuonti ep&auml;onnistui. XML-tiedostovirhe.';
$lang['rows'] = '%s rivi&auml;';
$lang['cols'] = '%s saraketta';
$lang['12_hour'] = '12 tunnin kello';
$lang['24_hour'] = '24 tunnin kello';
$lang['hour'] = 'Tunti';
$lang['min'] = 'Minuutti';
$lang['merid'] = 'Meridiaani';
$lang['date_range'] = 'Alue: %s - %s';
$lang['thanks'] = 'Kiitos. Lomake on tallennettu';
$lang['edit'] = 'Muokkaa';
$lang['delete'] = 'Poista';
$lang['day'] = 'P&auml;iv&auml;';
$lang['mon'] = 'Kuukausi';
$lang['year'] = 'Vuosi';
$lang['none'] = '(ei mit&auml;&auml;n)';
$lang['uninstalled'] = 'Moduulin asennus poistettu';
$lang['installed'] = 'Moduulin versio %s asennettu.';
$lang['upgraded'] = 'Moduuli p&auml;ivitetty versioon %s.';
$lang['button_previous'] = 'Takaisin...';
$lang['button_submit'] = 'L&auml;het&auml; lomake';
$lang['button_continue'] = 'Jatka';
$lang['value_checked'] = 'Valittu';
$lang['value_unchecked'] = 'Ei valittu';
$lang['tab_main'] = 'P&auml;&auml;sivu';
$lang['tab_symbol'] = 'Lomakkeen tulostusasetukset';
$lang['tab_submit'] = 'Lomakkeen l&auml;hetys';
$lang['tab_captcha'] = 'Captcha-asetukset';
$lang['tab_advanced'] = 'Lis&auml;asetukset';
$lang['tab_templatelayout'] = 'Lomakkeen pohja';
$lang['tab_submissiontemplate'] = 'L&auml;hetyspohja';
$lang['canuse_smarty'] = '<em>T&auml;ss&auml; kent&auml;ss&auml; voit k&auml;ytt&auml;&auml; smarty-muuttujia</em>';
$lang['add_options'] = 'Lis&auml;&auml; valintoja';
$lang['delete_options'] = 'Poista valitut valinnat';
$lang['add_checkboxes'] = 'Lis&auml;&auml; valintalaatikoita';
$lang['delete_checkboxes'] = 'Poista valitut valintalaatikot';
$lang['add_address'] = 'Lis&auml;&auml; uusi osoite';
$lang['delete_address'] = 'Poista valitut osoitteet';
$lang['add_destination'] = 'Lis&auml;&auml; uusi kohde';
$lang['delete_destination'] = 'Poista valitut kohteet';
$lang['suspected_spam'] = 'IP-osoitteestasi on tullut liian monta emailia. Roskapostitunnistus on est&auml;nyt l&auml;hetykset.';
$lang['suspected_spam_log'] = 'Mahdollinen spam-viestitys IP:st&auml; %s estetty.';
$lang['reorder'] = 'J&auml;rjest&auml; kentti&auml;';
$lang['cancel'] = 'Peru';
$lang['value_set'] = 'Arvo: %s';
$lang['help_cataloger_attribute_fields'] = 'Below is a list of the attributes available from the Cataloger module.<br/>You can optionally specify valid ranges, values, or numerous values to be used in filtering the list of items that is displayed to the user.<br/>
<br/>
<strong>Ranges:</strong><br/>
Ranges can be specified by signifying a minimum and maximum value using this syntax: &quot;range: minvalue to maxvalue&quot;<br/>
<br/>
<strong>Multiple Values:</strong><br/>
To specify multiple values for an attribute use the syntax &quot;multi: value1|value2|value3&quot;<br/>
<br/>
<strong>Values from hidden fields</strong><br/>
To specify a value from a hidden field use the syntax {$fld_id}<br/>
<br/>';
$lang['help_name_regex'] = 'A regular expression to allow filtering cataloger items by name';
$lang['help_field_height'] = 'Monivalintakent&auml;n korkeus';
$lang['title_name_regex'] = 'Cataloger Item Name Regular Expression';
$lang['title_field_height'] = 'Kent&auml;n korkeus';
$lang['title_file_path'] = 'Tallennuskansio tiedostoille';
$lang['title_udt_name'] = 'K&auml;ytt&auml;j&auml;n m&auml;&auml;rittelem&auml; tagi';
$lang['title_uploads_destpage'] = 'Page to return to with uploads link';
$lang['title_uploadmodule_summary'] = 'Submitted with formbuilder';
$lang['title_uploads_category'] = 'Uploads category';
$lang['title_sendto_uploads'] = 'Send this file to the uploads module';
$lang['title_legend'] = 'Selite';
$lang['title_maximum_length'] = 'Maksimipituus';
$lang['title_checkbox_label'] = 'Valintalaatikon otsikko';
$lang['title_radio_label'] = 'Valintapallon otsikko';
$lang['title_checked_value'] = 'Arvo kun valittu';
$lang['title_unchecked_value'] = 'Arvo kun ei valittu';
$lang['title_checkbox_details'] = 'Valintalaatikko ryhm&auml;n tiedot';
$lang['title_delete'] = 'Poista?';
$lang['title_select_one_message'] = '&quot;Valitse yksi&quot; teksti';
$lang['title_selection_value'] = 'Selection Value';
$lang['title_selection_displayname'] = 'Valinnan n&auml;ytt&ouml; nimi';
$lang['title_selection_subject'] = 'Valinnan otsikko';
$lang['title_select_default_country'] = 'Oletusvalinta';
$lang['title_select_default_state'] = 'Oletusvalinta';
$lang['title_select_default_province'] = 'Oletusvalinta';
$lang['title_option_name'] = 'Valinnan nimi';
$lang['title_option_value'] = 'Arvo';
$lang['title_pulldown_details'] = 'Alasvetovalikon valinnat';
$lang['title_multiselect_details'] = 'Monivalinnan vaihtoehdot';
$lang['title_destination_address'] = 'Vastaanottajan email-osoite';
$lang['title_destination_filename'] = 'Kohdetiedoston nimi';
$lang['title_email_from_name'] = '&quot;Nimi&quot; emailiin';
$lang['title_relaxed_email_regex'] = 'K&auml;yt&auml; l&ouml;ys&auml;&auml; email-tarkistusta';
$lang['title_relaxed_regex_long'] = 'K&auml;yt&auml; l&ouml;ys&auml;&auml; email-tarkistusta (esim. &quot;x@y&quot; sallitaan &quot;x@y.tld&quot; sijasta)';
$lang['title_email_from_address'] = '&quot;L&auml;hett&auml;j&auml;n osoitel&quot; (From:) emailiin';
$lang['title_email_encoding'] = 'Emailin merkist&ouml;koodaus';
$lang['title_director_details'] = 'Pulldown-based Emailer Details';
$lang['title_file_name'] = 'Tiedostonimi';
$lang['title_email_subject'] = 'Email aihe rivi';
$lang['title_form_name'] = 'Lomakkeen nimi';
$lang['title_form_status'] = 'Lomakkeen tila';
$lang['title_ready_for_deployment'] = 'Valmis k&auml;ytett&auml;v&auml;ksi';
$lang['title_not_ready1'] = 'Ei valmis!';
$lang['title_redirect_page'] = 'Sivu, jolle l&auml;hetyksen j&auml;lkeen siirryt&auml;&auml;n';
$lang['title_not_ready2'] = 'Lomake tarvitsee jonkun kohteen k&auml;ytt&auml;j&auml;n sy&ouml;tteelle';
$lang['title_not_ready_link'] = 'k&auml;ytt&auml;&auml; t&auml;t&auml; oikopolkua';
$lang['title_form_alias'] = 'Lomakkeen alias';
$lang['title_form_fields'] = 'Lomakkeen kent&auml;t';
$lang['title_field_id'] = 'Kent&auml;n id';
$lang['title_show_fieldaliases'] = 'N&auml;yt&auml; kenttien aliasnimet';
$lang['title_show_fieldaliases_long'] = 'Clicking this will display field aliases when adding or editing a form';
$lang['title_field_name'] = 'Kent&auml;n nimi';
$lang['title_field_alias'] = 'Kent&auml;n alias';
$lang['title_radiogroup_details'] = 'Valintapallo ryhm&auml;n tiedot';
$lang['title_field_type'] = 'Kent&auml;n tyyppi';
$lang['title_not_ready3'] = 'to create a form handling field.';
$lang['title_add_new_form'] = 'Lis&auml;&auml; uusi lomake';
$lang['title_show_version'] = 'N&auml;yt&auml; Lomage generaattorin versio?';
$lang['title_show_version_long'] = 'This will embed your installed version number of Form Builder module in a comment, to aid in debugging';
$lang['title_add_new_field'] = 'Lis&auml;&auml; uusi kentt&auml;';
$lang['title_form_submit_button'] = 'Lomakkeen l&auml;het&auml; kent&auml;n teksti';
$lang['title_submit_button_safety'] = 'Lis&auml;&auml; lomakkeen l&auml;het&auml; nappiin javascripti koodi joka auttaa est&auml;m&auml;&auml;n tupla l&auml;hetyksen';
$lang['title_submit_button_safety_help'] = 'Lis&auml;&auml; turva scripti';
$lang['title_form_next_button'] = 'Lomakkeen &quot;Seuraava&quot; napin teksti (K&auml;ytet&auml;&auml;n vain useampi sivuisilla lomakkeilla)';
$lang['title_form_prev_button'] = 'Lomakkeen &quot;Edellinen&quot; napin teksti (K&auml;ytet&auml;&auml;n vain useampi sivuisilla lomakkeilla)';
$lang['title_field_validation'] = 'Kent&auml;n validointi';
$lang['title_form_css_class'] = 'Lomakkeen CSS class';
$lang['title_field_css_class'] = 'Kent&auml;n CSS class';
$lang['title_form_required_symbol'] = 'Vaadittujen kenttien symboli';
$lang['title_field_required'] = 'Vaaditaan';
$lang['title_field_required_long'] = 'T&auml;st&auml; kent&auml;st&auml; vaaditaan sy&ouml;te';
$lang['title_hide_label'] = 'Piilota otsikko';
$lang['title_hide_label_long'] = 'Piilota kent&auml;n nimi lomakkeella';
$lang['title_text'] = 'N&auml;ytett&auml;v&auml; kiinte&auml; teksti';
$lang['title_field_regex'] = 'K&auml;ytett&auml;v&auml; s&auml;&auml;nn&ouml;nmukainen lauseke';
$lang['title_lines_to_show'] = 'Kuinka monta rivi&auml; n&auml;ytet&auml;&auml;n';
$lang['no_default'] = 'Ei oletusta';
$lang['redirect_after_approval'] = 'Sivu, jolle siirryt&auml;&auml;n hyv&auml;ksynn&auml;n j&auml;lkeen';
$lang['title_regex_help'] = 'This regular expression will only be used if &quot;validation type&quot; is set to a regex-related option. Include a full Perl-style regex, including the start/stop slashes and flags (e.g., &quot;/image\.(\d+)/i&quot;)';
$lang['title_field_required_abbrev'] = 'Req&#039;d';
$lang['title_hide_errors'] = 'Piilota virheet';
$lang['title_form_displaytype'] = 'Lomakkeen n&auml;yt&ouml;n tyyppi';
$lang['title_hide_errors_long'] = 'Est&auml; kaikkien debug viestien n&auml;ytt&auml;minen';
$lang['title_email_template'] = 'Email pohja';
$lang['title_maximum_size'] = 'Siirrett&auml;v&auml;n tiedoston maksimikoko (kilotavuina)';
$lang['title_maximum_size_long'] = 'Tiedoston maksimikokoon vaikuttaa t&auml;m&auml;n m&auml;&auml;rityksen lis&auml;ksi php-tulkin ja web-palvelimen asetuksissa olevat rajoitukset.';
$lang['title_permitted_extensions'] = 'Sallitut p&auml;&auml;tteet';
$lang['title_permitted_extensions_long'] = 'Sy&ouml;t&auml; pilkuilla erotettu lista p&auml;&auml;tteist&auml;, ilman pistett&auml; (esim. &quot;jpg,gif,jpeg&quot;). V&auml;lily&ouml;ntej&auml; ei huomioida. Jos j&auml;t&auml;t t&auml;m&auml;n tyhj&auml;ksi, rajoitusta ei ole.';
$lang['title_show_limitations'] = 'N&auml;yt&auml; rajoitukset';
$lang['title_show_limitations_long'] = 'Display any size and extension restrictions with the upload field?';
$lang['title_form_template'] = 'Lomakkeen n&auml;ytt&auml;miseen k&auml;ytett&auml;v&auml; pohja';
$lang['title_page_x_of_y'] = 'Sivu %s / %s';
$lang['title_no_advanced_options'] = 'Kent&auml;lle ei ole lis&auml;asetuksia';
$lang['title_form_unspecified'] = 'Text to return for unspecified field values';
$lang['title_enable_fastadd_long'] = 'Salli nopea kent&auml;n lis&auml;ys';
$lang['title_enable_fastadd'] = 'Salli nopea kent&auml;n lis&auml;ys';
$lang['title_fastadd'] = 'Pika lis&auml;ys';
$lang['title_enable_antispam_long'] = 'T&auml;m&auml; valinta sallii maksimissaan 10 emailia samasta IP osoittesta tunnissa';
$lang['title_enable_antispam'] = 'Aktivoi anti-spam toiminnot';
$lang['title_show_fieldids'] = 'N&auml;yt&auml; kenttien id:t';
$lang['title_show_fieldids_long'] = 'Clicking this will allow displaying field ids when adding or editing a form';
$lang['title_xml_to_upload'] = 'Upload form from XML file';
$lang['title_xml_upload_formname'] = 'K&auml;yt&auml; t&auml;t&auml; lomakkeen nime&auml;';
$lang['title_import_legend'] = 'XML Form -tuonti';
$lang['title_xml_upload_formalias'] = 'K&auml;yt&auml; t&auml;t&auml; lomakkeen aliasta';
$lang['title_html_email'] = 'K&auml;yt&auml; HTML emailia';
$lang['title_link_autopopulate'] = 'T&auml;yt&auml; automaattisesti';
$lang['title_link_autopopulate_help'] = 'Automatically populate with the URL of the page containing the form? (this overrides site page link option below)';
$lang['title_default_link'] = 'Oletus URL linkille';
$lang['title_default_link_title'] = 'Oletus teksti linkille';
$lang['title_link_to_sitepage'] = 'Linkki sivuston sivuun';
$lang['title_captcha_not_installed'] = 'You can use <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a> to protect form submissions if you install the Captcha module. For more information, <a href="http://dev.cmsmadesimple.org/projects/captcha/">check the Captcha project</a>.';
$lang['title_use_captcha'] = 'K&auml;ytet&auml;&auml;nk&ouml; Captcha-suojausta tiedostojen siirrossa?';
$lang['title_use_captcha_help'] = 'Check here to protect your form with a <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a>.';
$lang['title_user_captcha'] = 'Please confirm that you are not a script by entering the letters from the image.';
$lang['title_user_captcha_error'] = 'Failed text for Captcha';
$lang['wrong_captcha'] = 'Captcha was not correct.';
$lang['title_title_user_captcha'] = 'Avusteteksti Captchalle';
$lang['title_dont_submit_unchecked'] = 'Don&#039;t submit values for unchecked boxes';
$lang['title_dont_submit_unchecked_help'] = 'Check this if you only want checked boxes to return values.';
$lang['link_label'] = 'Linkin teksti';
$lang['link_destination'] = 'Linkin kohdeosoite';
$lang['title_default_set'] = 'Oletuksena valittu?';
$lang['title_24_hour'] = 'K&auml;yt&auml; 24 tunnin kelloa?';
$lang['title_before_noon'] = 'AM';
$lang['title_after_noon'] = 'PM';
$lang['title_smarty_eval'] = 'Process smarty tags within field?';
$lang['title_textarea_rows'] = 'Rows (note: this may be overridden by CSS)';
$lang['title_textarea_cols'] = 'Columns (note: this may be overridden by CSS)';
$lang['title_form_main'] = 'Main Form Details';
$lang['title_show_username'] = 'Display User&#039;s login name?';
$lang['title_show_userfirstname'] = 'Display User&#039;s first name?';
$lang['title_show_userlastname'] = 'Display User&#039;s last name?';
$lang['title_restrict_to_group'] = 'Restrict user list to users in specified group';
$lang['restricted_to_group'] = 'Vain ryhm&auml;ss&auml; %s';
$lang['title_show_to_user'] = 'N&auml;yt&auml; k&auml;ytt&auml;j&auml;lle?';
$lang['help_leaveempty'] = 'This field may be left empty';
$lang['help_variables_for_template'] = 'Pohjan muuttujat';
$lang['help_variables_for_computation'] = 'Saatavilla olevat muuttujat';
$lang['help_php_variable_name'] = 'PHP-muuttuja';
$lang['help_submission_date'] = 'L&auml;hetyspvm';
$lang['help_server_name'] = 'Palvelimesi';
$lang['help_sub_source_ip'] = 'Lomakek&auml;ytt&auml;j&auml;n IP-osoite';
$lang['help_sub_url'] = 'Lomakesivun URL';
$lang['help_fb_version'] = 'FormBuilder version';
$lang['help_tab'] = 'Sarkainmerkki';
$lang['help_other_fields'] = 'Alternate field names can be used interchangeably (especially useful if Smarty is choking on characters outside of ASCII 32-126). <br />Other fields will be available as you add them to the form.';
$lang['help_array_fields'] = 'Fields that have multiple values may also be accessed via the smarty value of $fieldname_array or $fld_#_array.';
$lang['help_date_format'] = 'See <a href="http://www.php.net/manual/en/function.date.php" target=_NEW>the PHP Manual</a> for formatting help.';
$lang['help_variable_name'] = 'Variable';
$lang['help_form_field'] = 'Field Represented';
$lang['link_back_to_form'] = '&laquo; Back to Form';
$lang['title_create_sample_template'] = 'Create Sample Template';
$lang['title_create_sample_html_template'] = 'Create Sample HTML Template';
$lang['title_create_sample_header_template'] = 'Create Sample Header Template';
$lang['title_create_sample_header'] = 'Create Sample Header';
$lang['help_tab_symbol'] = 'a tab character';
$lang['title_file_template'] = 'Template for one line of output file';
$lang['title_file_header'] = 'Template for the header of output file';
$lang['title_confirmation_url'] = 'URL to click for form confirmation';
$lang['title_value'] = 'Value (see Advanced Tab if you use Smarty tags)';
$lang['title_date_format'] = 'Date Format (standard <a href="http://www.php.net/manual/en/function.date.php">PHP Date Formats</a>)';
$lang['title_use_wysiwyg'] = 'Use WYSIWYG editor for text Area (Admin side only)?';
$lang['title_submit_actions'] = 'Form Submission Behavior';
$lang['title_submit_labels'] = 'Submission Button Labels';
$lang['title_sortable_field'] = 'Sortable Field #%s';
$lang['title_submit_help'] = 'This page lets you customize Form Submission. It doesn&#039;t determine what the Form Builder does with the submitted data. You can set that up by adding &quot;Disposition&quot; fields to your form.';
$lang['title_start_year'] = 'Year range start';
$lang['title_end_year'] = 'Year range end';
$lang['title_default_year'] = 'Default Year';
$lang['title_default_year_help'] = '(Set to -1 for default year to be the current year)';
$lang['title_submit_action'] = 'After form is submitted';
$lang['title_submit_response'] = 'Response to display';
$lang['display_text'] = 'Display &quot;Submission Template&quot;';
$lang['redirect_to_page'] = 'Redirect to site page';
$lang['title_submit_response_help'] = 'This template is for display to the user after the form is submitted. This template does not effect emails generated or other form dispositions -- you set those templates (where appropriate) in the &quot;advanced&quot; tab for those disposition fields.';
$lang['title_destination_page'] = 'Kohdesivu';
$lang['title_require_fieldnames'] = 'Vaadi kenttien nimet';
$lang['title_require_fieldnames_long'] = 'Vaaditaanko kentille nimi?';
$lang['title_unique_fieldnames'] = 'Vaadi yksil&ouml;lliset kentt&auml;nimet';
$lang['title_unique_fieldnames_long'] = 'Vaaditaanko kentille yksil&ouml;lliset nimet?';
$lang['title_reorder_form'] = 'Uudelleenj&auml;rjest&auml; kent&auml;t';
$lang['title_load_template'] = 'Lataa pohja';
$lang['title_add_button_text'] = 'Add Button text';
$lang['title_del_button_text'] = 'Delete Button text';
$lang['title_string_or_number_eval'] = 'Interpret variables as being numbers or strings';
$lang['title_order'] = 'Interpretation Order';
$lang['title_order_help'] = 'If more than one Computed Field exists, they will be computed from lowest order number to highest order number';
$lang['title_compute_value'] = 'Value to compute';
$lang['title_string'] = 'String';
$lang['title_numeric'] = 'Numeric';
$lang['title_inline_form'] = 'Display form inline?';
$lang['title_inline_form_help'] = 'Inline means any form followup replaces the {cms_module} tag, non-inline replaces the {content} tag.';
$lang['title_field_default_value'] = 'Default value for field';
$lang['title_clear_default'] = 'Clear default on click?';
$lang['title_clear_default_help'] = 'Check this to clear the default value when the user clicks this field. Since this uses a javascript string compare, it will fail if you put single quotes in your default text. Other un-javascript-friendly characters may also cause it to fail.';
$lang['title_remove_file_from_server'] = 'Delete uploaded file from server after processing (email dispositions)';
$lang['title_field_javascript'] = 'Javascript for field';
$lang['title_field_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;';
$lang['title_submit_javascript'] = 'Form Submission Javascript';
$lang['title_submit_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;.<br />This will probably not work well if you use the &quot;safety script&quot; option above.';
$lang['email_from_addr_help'] = 'Do not just pick a random address here -- many ISPs will<br />not deliver the mail if you are using a different domain name than your actual<br />host name (i.e., use something like name@%s)';
$lang['title_switch_advanced'] = 'Tarvitsetko lis&auml;&auml; kentt&auml;tyyppej&auml;?';
$lang['title_switch_basic'] = 'Too many confusing field types? ';
$lang['title_switch_advanced_link'] = 'Vaihda edistyneeseen tilan';
$lang['title_switch_basic_link'] = 'Vaihda perustilaan';
$lang['title_file_root'] = 'Directory to save file in';
$lang['title_file_root_help'] = 'This needs to be a directory that your web server has permissions to write in.<br />Chmod it 777 if you have problems/doubts.<br />Also, check to see that you do not have PHP directory restrictions.';
$lang['error_cataloger_module_not_available'] = '<strong>Cataloger module does not seem to be installed/active.</strong>';
$lang['warning'] = 'WARNING!';
$lang['default_template'] = 'Oletuspohja';
$lang['table_left_template'] = 'Table Template, Titles on left';
$lang['table_top_template'] = 'Table Template, Title on top';
$lang['form_template_name'] = 'Template from %s';
$lang['template_are_you_sure'] = 'Are you sure you want to overwrite your template with the selected template? (Even if you say OK, you will still need to save the change)';
$lang['title_bad_function'] = 'Error when computing &quot;%s&quot;.';
$lang['no_referrer_info'] = 'No HTTP_REFERER info available (probably due to use of User Email Validation)';
$lang['validation_param_error'] = 'Validation Parameter Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_response_error'] = 'Validation Repsonse Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_no_field_error'] = 'Validation Repsonse Error. No email validation field in this form!';
$lang['upgrade03to04'] = 'Form Template was updated automatically as part of the version 0.3 to version 0.4 upgrade. You may need to make some fixes. If you&#039;re using the default form, simply replace this template with &quot;default&quot; using the pulldown above.';
$lang['admindesc'] = 'Add, edit and manage interactive Forms';
$lang['operators_help'] = 'If you use String evaluation, the only operation available is concatenation (+), while if you use Number evaluation you have basic, very simple math (, +, -, *, /, ).';
$lang['date_january'] = 'Tammikuu';
$lang['date_february'] = 'Helmikuu';
$lang['date_march'] = 'Maaliskuu';
$lang['date_april'] = 'Huhtikuu';
$lang['date_may'] = 'Toukokuu';
$lang['date_june'] = 'Kes&auml;kuu';
$lang['date_july'] = 'Hein&auml;kuu';
$lang['date_august'] = 'Elokuu';
$lang['date_september'] = 'Syyskuu';
$lang['date_october'] = 'Lokakuu';
$lang['date_november'] = 'Marraskuu';
$lang['date_december'] = 'Joulukuu';
$lang['submission_error'] = 'Lomakkeen l&auml;hetyksess&auml; tapahtui virhe.';
$lang['submit_error'] = 'FormBuilder submit error: %s';
$lang['uploads_error'] = 'Error committing file to the uploads module: %s';
$lang['nouploads_error'] = 'Could not find the uploads module';
$lang['upload_attach_error'] = 'Upload/Attachment error on file %s (tmp_name: %s, of type %s)';
$lang['submission_error_file_lock'] = 'Error. Unable to obtain lock for file.';
$lang['unchecked_by_default'] = 'Default: unchecked';
$lang['checked_by_default'] = 'Default: checked';
$lang['email_default_template'] = 'FormBuilder Submission';
$lang['email_template_not_set'] = '<br/>Email Template not yet set!';
$lang['missing_cms_mailer'] = 'FormBuilder: Cannot find required module CMSMailer!';
$lang['user_approved_submission'] = 'User approved submission %s from %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Event triggered when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Event triggered if there is an error when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Event triggered when a FormBuilder form is displayed';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Event triggered when a FormBuilder form is submitted.</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>value_<name></em> - Supply a default value to a field with the specified name.</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Event triggered if there is an error when a FormBuilder form is submitted</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>error</em> - A list of all known errors (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Event triggered when a FormBuilder form is displayed</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
</ul> ';
$lang['formbuilder_params_response_id'] = 'Response ID. Used by FormBrowser';
$lang['formbuilder_params_passed_from_tag'] = 'Default field values; see module help';
$lang['formbuilder_params_field_id'] = 'Field ID for internal operations';
$lang['formbuilder_params_form_name'] = 'Form Name';
$lang['formbuilder_params_form_id'] = 'Form ID for internal operations';
$lang['formbuilder_params_general'] = 'General parameters for internal operations';
$lang['template_variable_help'] = '<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>
';
$lang['post_install'] = '<p>Make sure to set the &quot;Modify Forms&quot; permissions
on users who will be administering feedback forms. Also, if you&#039;ll be emailing form
results, be sure to update the Configuration appropriately.</p>
<p>Please be aware that a feedback form should not be active (e.g., usable by the public) while
you are still editing the form. You should create the form, and place the tag into an active
content page only when you have finished editing. Otherwise, erroneous results could be returned.</p>
<p>Additionally, this version does not support parallel editing of forms. Please take care that
only one admin is editing a given form at a given time.</p>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create feedback forms (in fact, it&#039;s a replacement of the original Feedback Form module), with the added power of database storage. With its companion module Form Browser, you can use it to create simple database applications.</p>
<p>The forms created using the Form Builder may be inserted
into templates and/or content pages. Forms may contain many kinds of inputs, and may have
validation applied to these inputs. The results of these forms may be handled in a variety of ways.</p>

<h3>How Do I Use it?</h3>
<P>Install it, and poke around the menus. Play with it. Try creating forms, and adding them to your content.
If you get stuck, chat with me on the #cms IRC channel, post to the forum, send me email, or, if you&#039;re
really desperate, read the rest of this page.</P>

<h3>How Do I Create a Form</h3>
<p>In the CMS Admin Menu, you should get a new menu item called FormBuilder. Click on this. On the page
that gets shown, there are options (at the bottom of the list of Forms) to Add a New Form or Modify
Configuration.</p>

<h3>Adding a Form to a Page</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module=&#039;FormBuilder&#039; form=&#039;sample_form&#039;}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page&#039;s content if you use a WYSIWYG editor such as TinyMCE, FCKEdit, or HTMLArea. These editors may stealthily
change the quote marks (&quot;) into HTML entities (&amp;quot;), and the forms will not show up. Try using
single quotes (&#039;) or editing the HTML directly.</p>

<h3>Working with Forms</h3>
<p>By clicking on a Form&#039;s name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you&#039;ll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing.</p>
<p>Below this, if you have it enabled, is the &quot;fast field adder&quot; pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Form Submission</h4>
<p>When the form is submitted, you can either redirect the user to another page of your site, or you can present the user some message (which can contain any of the user&#039;s form entries, or just static text). In this tab, you select which of these approaches you wish to use, and, if you chose redirection, it allows you to pick the page to redirect users to after a successful form submission.</p>
<p>Also on this page, you can specify the labels of various submission buttons (&quot;Previous&quot;, &quot;next&quot;, &quot;submit&quot;). You can also opt to have some Javascript added to the last page of a form that will prevent multiple submissions (useful on slow servers).</p>
<h4>Form Display Options</h4>
<p>This tab allows for other form customizations, like the symbol to show for required fields.</p>
<h4>Captcha Settings</h4>
<p>If you have installed the Captcha module, this tab lets you configure the Captcha settings for your form.</p>
<h4>Form Template</h4>
<p>This is where you do your customization work of your form&#039;s Smarty Template. See the section called Form Template Variables below.</p>
<p>The form should default to a Custom template that documents the Smarty tags available to you.</p>
<p>Unless you&#039;re a Smarty expert, you probably don&#039;t want to mess around with this. If you are a Smarty expert, this is where you can unleash your magic.</p>
<h4>Submission Template</h4>
<p>If, in the Form Submission tab, you selected &#039;Display &quot;Submission Template&quot;, this is where you can create that template. There is a display of which smarty variables are available to you, and a button to generate a sample template.</p>
<p>If you&#039;re a Smarty expert, you can do all manner of creative and powerful things here. If you&#039;re not a Smarty expert, you might just want to use the default.
</p>

<h3>Adding Fields to your Form</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it&#039;s submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it&#039;s safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked &quot;Required&quot;, which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to &quot;view source&quot; on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It&#039;s really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It&#039;s really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
<li>Time Picker. This is a set of pulldowns allowing the user to select a time (using 12 or 24 hour clock).</li>
<li>File Upload. This is a file upload field.</li>
<li>Link (User Entered). This creates a double input field for getting a link URL and link title.</li>
<li>Text Field (Multiple). This field creates one or more text inputs with add and delete buttons, effectively giving the end user a way of creating variable-length lists.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the &quot;From&quot; field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the &quot;From&quot; field.</li>
<li>Email Subject Field. This allows users to provide a subject for their email. The email generated when the form gets handled will use this in the &quot;Subject&quot; field. This may cause trouble with certain dispositions that want to control the Email Subject, so use it with caution.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Fieldset Start. Combined with Fieldset End, this allows you to group various fields within your form. Use this to start a given grouping.</li>
<li>-Fieldset End. Combined with Fieldset Start, this allows you to group various fields within your form. Use this to end a given grouping.</li>
<li>-Hidden Field. This allows you to embed a hidden field in your form.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you&#039;re not using a Custom Template to render your form.</li>
<li>-Static Link. This allows you to put a link to a given page into your form. Optionally, you can have it autopopulate with the page where the form is embedded (useful if you\&#039;re sending results via email).</li>
<li>-Computed Field. This allows you to embed a computed field in your form. It is not visible to the user until after the form is submitted. It allows you to do simple arithmetic or string concatenation.</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<ul><li>*Call a User Defined Tag With the Form Results. This submits all the form results to the User-Defined Tag you specify. The UDT can handle the results however it wants.</li>
<li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these &quot;Director&quot; pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email to User-Supplied Address. This puts an input field in the form for the user to populate with an email address. The form results get sent to that address. Beware of Spam abuse! Active the primitive anti-spam features in the FormBuilder configuration screen.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Redirect to Page Based on Pulldown. This allows you to redirect the form to a different site page depending on its value. If you have multiple dispositions, make sure this is used last.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered &quot;approved,&quot; and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the &quot;output&quot; directory under the
module&#039;s installation directory, assuming the web server has permission to write there.</li>
<li>*Save Results to File Based on Pulldown. Like the Flat File disposition, except the value of a pull-down determines which file results get written to.</li>
<li>*Save Results to File(s) Based on Multiple Selections. Like the Flat File disposition, except the value(s) of checkboxes  determines which file(s) results get written to.</li>
</ul></li></li></ul>


<h3>Passing Default Values to Forms</h3>
<p>Calguy added a nice feature, which is that you can pass default field values to your form via the module tag. This allows you to have
the same form in multiple places, but with different default values. It may not work for more exotic field types, but for fields that have
a single value, you can specify like:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_<i>FIELDNAME</i>=&#039;default_value&#039;}</p>
<p>This will set the field with <i>FIELDNAME</i> to &#039;default_value&#039;.</p>
<p>This can be problematic, as sometimes field names are unweildy or contain characters that don&#039;t work well with Smarty. So there is an
alternative like this:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_fld<i>NUMBER</i>=&#039;default_value&#039;}</p>
<p>That uses field <i>NUMBER</i>, where <i>NUMBER</i> is the internal FormBuilder field id. You might wonder how you know what that id is. Simply go into the FormBuilder configuration tab,
and check &quot;Show Field IDs&quot;</p>

<h3>Email and Flat File Templates</h3>
<p>Many disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it&#039;s own best guess, which may or may not work out to your liking. You can always click on the &quot;Create Sample Template&quot; and then customize the results.</p>
<p>To the right, you&#039;ll find a legend which lists all of the variables that are available to you to use in your template. As of version 0.3, variables have two names, one based on the field name, the other based on the field ID. If you use field names that have characters outside of the ASCII 32-126 range, it will be safer to use the ID-based variables.</p>
<p><strong>Note that once you&#039;ve changed a template, it will no longer automatically add new fields.</strong> For this reason, it&#039;s usually best to create your templates as the last step of creating your form.</p>
<p>As of version 0.2.4, you can opt to send any of these emails as HTML email. There should be a checkbox at the top of the template page for this. There is also a &quot;Create Sample HTML Template&quot; button over in the legend area. For HTML email, the email body will also provide the default text-only values.</p>

<h3>Configuration</h3>
<p>There are some global configuration options for FormBuilder:</p>
<ul>
<li>Enable fast field add pulldown. This enables the pulldown on the Form Edit page which saves a step in the creation of new fields.</li>
<li>Hide Errors. This is set by default. Unchecking it will cause more detailed errors to be displayed if there are problems when you submit your form.</li>
<li>Require Field Names. Typically, you will want form fields to be named so you can tell which is which. However, in some cases, you might want to have nameless fields. Uncheck this if you want to allow nameless fields.</li>
<li>Unique Field Names. Typically, you will want form fields to have unique names so you can tell which is which. Uncheck this if you want to allow fields to share names.</li>
<li>Use relaxed email validation. This uses a less restrictive regular expression for validating email; e.g., x@y will be allowed, where typically x@y.tld is required.</li>
<li>Show Form Builder Version. Displays the version of FormBuilder you&#039;re using in a comment when the form is generated. Typically only useful when debugging.</li>
<li>Enable primitive anti-spam features. When turned on, this allows any given IP address to only generate 10 emails per hour.</li>
<li>Show Field IDs. When turned on, FormBuilder will display field ids when adding or editing a form.</li>
</ul>
<h3>Styling and CSS</h3>
<p>Paul Noone graciously provides us all with a pretty good standard CSS that you can use for forms:</p>
<pre>
	/* Sample FormBuilder CSS base */
	form {margin-top:0}
	form, td, th, li { font-size: 100%}
	form div {margin-bottom:0}
	fieldset div {
		margin-bottom:0.5em;
		margin-left:1em;
	}
	fieldset div div {
		margin-top:0.5em;
		margin-left:1em
	}
	fieldset {
		margin-bottom:1em;
		border:1px solid #F60;
		padding:0.5em
	}
	fieldset label {
		width:auto;
	}
	legend {
		color:#FFF;
		background:#F60;
		font-style:italic;
		font-size:1.2em;
		margin-bottom:0.5em;
		padding:0.2em;
		width:auto;
		border:1px solid #CCC
	}
	textarea {
		margin: 0.5em 0;
		width:98%;
		height: 6em
	}

	/* Apply this class to text/select input fields with shorter labels
		to help alignment */
	.short-label label {float:left; width:10em}
	.short-label fieldset div input,
	.short-label fieldset div select {width:16em}

	/* Pretty up your Captcha image output */
	.captcha {
		margin:0.5em 0;
		width:200px;
		text-align:center
	}
	.captcha img {border:1px solid #F60; margin-bottom:0.5em}
	.captcha input {width:196px; margin-top:0.5em}

	/* Just a bit more room for the Submit button */
	.submit {margin-top:0.5em}
</pre>

<h3>Form Template Variables</h3>

<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>


<h3>Known Issues</h3>
<ul>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder cannot yet be inlined. That should be a simple upgrade down the line.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn&#039;t matter since the user side is pretty simple.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you&#039;re running CMS 1.1 or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you&#039;re missing fields in an email that gets generated, check the disposition field&#039;s template, and make sure you&#039;re specifying the missing fields. Seems obvious, but it&#039;s an easy mistake to make.</li>
<li>Uncheck the &quot;Hide Errors&quot; checkbox in the global options, and see what message gets displayed when you submit your form.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is no longer a particularly early version, but it is probably still buggy. While I&#039;ve done all I can
to make sure no egregious bugs have crept in, I have to admit that during early testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor&#039;s nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>.</li>
<li>Additional discussion of this module may also be found in the <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2007, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '<ul>
<li>Version 0.4.4. 26 Sept 07. Bugfixes for radio button groups, fix for validation of DispositionDeliverToEmailAddressField.</li>
<li>Version 0.4.3. 18 Sept 07. Bugfixes for pulldowns using numbers, option to inline form, fixes for table-layouts provided by Ap Muthu, fix for requirability of Dispositions.</li>
<li>Version 0.4.2. 14 Sept 07. Bugfixes for XML export, RadioButton Group submission, and HTML labels.</li>
<li>Version 0.4.1. Bugfixes for File Disposition Types.</li>
<li>Version 0.4
	<ul>
		<li>Upped minimum CMS version to 1.1</li>
		<li>Numerous Bug fixes; too many to enumerate here</li>
		<li>Massive rejiggering of code to work with CMS MS 1.1 parameter sanitizing regime</li>
		<li>Added field types: &quot;TextField (Multiple)&quot; and &quot;Computed Field&quot;</li>
		<li>Added dispositions: &quot;Save Results to File Based on Pulldown&quot; and &quot;Save Results to File(s) Based on Multiple Selections&quot;(Calguy)</li>
		<li>Added neat-o AJAX-y template-copying for Form Templates, gave versions of old table-based templates to soothe the raging masses.</li>
		<li>Added ability to pass default values to form elements from module tag using value_FIELDNAME=&quot;value&quot; syntax (Calguy)</li>
		<li>Added option to display field ids in admin (Calguy)</li>
	</ul>
</li>
<li>Version 0.3
   <ul>
      <li>Added Captcha module support.</li>
      <li>Reworked labeling of form elements to be XHTML compliant</li>
      <li>Added Paul Noone&#039;s new, improved contact form templates</li>
      <li>Implementation of Email Subject Field</li>
      <li>Added admin-specifiable values to hidden field type, which may contain parsable smarty tags</li>
      <li>Text Area Field now allows specification of rows and cols in the admin, instead of CSS</li>
      <li>Added Drag&#039;n&#039;Drop reordering of form fields.</li>
      <li>Added non-blank field name and unique field name global configuration options and validation</li>
      <li>Implemented templated display of form results upon submission in addition to page redirecting</li>
      <li></li>
   </ul>
</li>
<li>Version 0.2.4 - 09 May 2007
   <p>Big release:<ul>
   <li>Added &quot;Email Form to User-Supplied Address&quot; disposition.</li>
   <li>Added &quot;TimePicker&quot; field type. Split &quot;Link&quot; field into a &quot;User-supplied Link&quot; field and a &quot;Static Link&quot; field.</li>
   <li>Added HTML email option and auto-templates for all email dispositions.</li>
   <li>Added primitive anti-spam features.</li>
   <li>Added XML-based import and export of forms.</li>
   </ul>
   </p>
</li>
<li>Version 0.2.3
   <p>Add the ability to call a selectable user defined tag upon disposition of the form.</p>
</li>
<li>Version 0.2.2
   <p>Many thanks to Utter Design for sponsoring some changes and bugfixes, which include:
   <ul>
      <li>Added file upload capabilities to the email disposition</li>
      <li>Add PageSetStart and PageSetEnd field types
      <p>These field types allow you to create fieldsets in your form, and organise
      your fields logically for the user.  You can even nest fieldsets, and
      associate a style with them appropriately.  The default template was changed
      to prevent it from wrapping a div around these types of fields.
      </p>
      </li>
      <li>Fixed a problem with DATETIME fields on install
      <p>This solves a problem when on install the response table would sometimes not get created when using adodb lite</li>
      </li>
   </ul>
   </p>
</li>
<li>Version 0.2 - 14 November 2006. Calguy &amp; tsw&#039;s bug fixes for field re-ordering and custom templates. Additional bug fixes for field labels.</li>
<li>Version 0.1 - 8 July 2006. Initial Release</li>
</ul>
';
$lang['utma'] = '156861353.1524739552.1203768231.1216716414.1216719561.21';
$lang['utmz'] = '156861353.1204486725.2.2.utmccn=(organic)|utmcsr=google|utmctr=cmsmadesimple wiki language|utmcmd=organic';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/fr_FR.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Form Builder';
$lang['field_type_'] = 'Type de champ non renseign&eacute;';
$lang['field_type_CatalogerItemsField'] = 'S&eacute;lectionner un (ou plisieurs) items de Cataloger';
$lang['field_type_FieldsetEnd'] = '-Fin de champ renseign&eacute;';
$lang['field_type_FieldsetStart'] = '-D&eacute;but de champ renseign&eacute;';
$lang['field_type_TextField'] = 'Ligne de texte simple';
$lang['field_type_TextFieldExpandable'] = 'Lignes de texte multiples';
$lang['field_type_TextAreaField'] = 'Zone de texte';
$lang['field_type_CheckboxField'] = 'Boite &agrave; cocher';
$lang['field_type_CheckboxGroupField'] = 'Groupe de boite &agrave; cocher';
$lang['field_type_PulldownField'] = 'Menu d&eacute;roulant';
$lang['field_type_MultiselectField'] = 'S&eacute;lection multiple';
$lang['field_type_StatePickerField'] = 'S&eacute;lectionner un &eacute;tat des USA';
$lang['field_type_ProvincePickerField'] = 'S&eacute;lectionner une Province du Canada';
$lang['field_type_CountryPickerField'] = 'S&eacute;lectionner un pays';
$lang['field_type_DatePickerField'] = 'S&eacute;lectionner une date';
$lang['field_type_TimePickerField'] = 'S&eacute;lectionner une heure';
$lang['field_type_RadioGroupField'] = 'Groupe de bouton Radio';
$lang['field_type_DispositionDirector'] = '*Adresser par mail les r&eacute;sultats apr&egrave;s choix par menu d&eacute;roulant';
$lang['field_type_DispositionFileDirector'] = '*Sauvegarder les r&eacute;sultats vers un fichier apr&egrave;s choix par menu d&eacute;roulant';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Sauvegarder en fichier(s) les r&eacute;sultats des s&eacute;lections multiples';
$lang['field_type_DispositionPageRedirector'] = '*Rediriger vers la page &agrave; partir d&#039;un menu d&eacute;roulant';
$lang['field_type_DispositionEmail'] = '*Envoyer par mail les r&eacute;sultats aux adresses fournies';
$lang['field_type_DispositionEmailConfirmation'] = '*Validation via adresse mail';
$lang['field_type_DispositionFile'] = '*&Eacute;crire les r&eacute;sultats dans un fichier';
$lang['field_type_DispositionDatabase'] = '*Stocker les r&eacute;sultats dans la base de donn&eacute;es';
$lang['field_type_DispositionFormBrowser'] = '*Stocker les r&eacute;sultats pour le module FormBrowser v.3';
$lang['field_type_DispositionUserTag'] = '*Appeler un tag utilisateur avec le formulaire r&eacute;sultats';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Envoyer par mail aux utilisateurs ayant fourni une adresse';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Mail vers l&#039;adminstrateur du CMS';
$lang['field_type_PageBreakField'] = '-Saut de page';
$lang['field_type_FileUploadField'] = 'Fichier &agrave; Envoyer';
$lang['field_type_FromEmailAddressField'] = 'Champ du mail &quot;From Adresse&quot;';
$lang['field_type_FromEmailAddressAgainField'] = 'Champ du mail &quot;From Adresse&quot; &agrave; nouveau';
$lang['field_type_FromEmailNameField'] = 'Champ du mail &quot;From Nom&quot;';
$lang['field_type_FromEmailSubjectField'] = 'Champ du mail &quot;Sujet&quot;';
$lang['field_type_StaticTextField'] = '-Texte statique';
$lang['field_type_SystemLinkField'] = '-Lien statique';
$lang['field_type_LinkField'] = 'Lien (utilisateur connu)';
$lang['field_type_HiddenField'] = '-Champ cach&eacute;';
$lang['field_type_ComputedField'] = '-Champ calcul&eacute;';
$lang['field_type_UniqueIntegerField'] = '-Entier unique (S&eacute;rie)';
$lang['validation_none'] = 'Sans Validation';
$lang['validation_numeric'] = 'Num&eacute;rique';
$lang['validation_integer'] = 'Entier';
$lang['validation_email_address'] = 'Adresse mail';
$lang['validation_usphone'] = 'Num&eacute;ro de t&eacute;l&eacute;phone (US)';
$lang['validation_must_check'] = 'Doit &ecirc;tre v&eacute;rifi&eacute;';
$lang['validation_regex_match'] = 'Valider l&#039;expression reguli&egrave;re';
$lang['validation_regex_nomatch'] = 'Ne pas valider l&#039;expression reguli&egrave;re';
$lang['required_field_missing'] = 'Un champ obligatoire n&#039;a pas &eacute;t&eacute; rempli';
$lang['please_enter_a_value'] = 'Veuillez entrer une valeur pour &quot;%s&quot;';
$lang['please_enter_a_number'] = 'Veuillez entrer un nombre pour &quot;%s&quot;';
$lang['please_enter_valid'] = 'Veuillez entrer une valeur correcte pour &quot;%s&quot;';
$lang['please_enter_an_integer'] = 'Veuillez entrer une valeur enti&egrave;re pour &quot;%s&quot;';
$lang['please_enter_an_email'] = 'Veuillez entrer une adresse mail valide pour &quot;%s&quot;';
$lang['email_address_does_not_match'] = 'Adresse mail ne correspond pas &agrave; la valeur de &quot;% s&quot;';
$lang['please_enter_a_phone'] = 'Veuillez entrer un num&eacute;ro de t&eacute;l&eacute;phone valide pour &quot;%s&quot;';
$lang['not_valid_email'] = '&quot;%s&quot; ne semble pas &ecirc;tre une adresse mail valide !';
$lang['please_enter_no_longer'] = 'Veuillez entrer une valeur ayant moins de %s caract&egrave;res';
$lang['title_list_delimiter'] = 'Caract&egrave;res utilis&eacute;s comme &quot;s&eacute;parateur&quot; dans les formulaires re&ccedil;us contenant plus d&#039;une valeur&nbsp;';
$lang['you_need_permission'] = 'Il vous faut &quot;%s&quot; la permission d&#039;&eacute;x&eacute;cuter cette op&eacute;ration.';
$lang['lackpermission'] = 'D&eacute;sol&eacute; ! Vous n&#039;avez pas les droits suffisants pour acc&eacute;der &agrave; cette section.';
$lang['field_order_updated'] = 'Ordre des champs mis &agrave; jour.';
$lang['form_deleted'] = 'Formulaire supprim&eacute;.';
$lang['field_deleted'] = 'Champ supprim&eacute;.';
$lang['configuration_updated'] = 'Configuration mise &agrave; jour.';
$lang['you_must_check'] = 'V&eacute;rifiez &quot;%s&quot; pour pouvoir continuer.';
$lang['must_specify_one_destination'] = 'Vous devez pr&eacute;ciser au moins une adresse de destination !';
$lang['are_you_sure_delete_form'] = 'Voulez vous vraiment supprimer le formulaire %s ?';
$lang['are_you_sure_delete_field'] = 'Voulez vous vraiment supprimer le champ %s ?';
$lang['notice_select_type'] = 'Les options avanc&eacute;es ne seront disponibles que lorsque qu&#039;un type de champ aura &eacute;t&eacute; choisi.';
$lang['field_name_in_use'] = 'Il existe d&eacute;j&agrave; un champ &quot;%s&quot; utilis&eacute;. Utilisez des noms de champ uniques ou d&eacute;sactivez cette fonction dans la configuration de Form Builder.';
$lang['field_no_name'] = 'Tous les champs doivent &ecirc;tre nomm&eacute;s, sinon d&eacute;sactivez cette fonction dans la configuration de Form Builder.';
$lang['anonymous'] = 'Anonyme';
$lang['abbreviation_length'] = 'Longueur : %s';
$lang['boxes'] = '%s bo&icirc;tes';
$lang['options'] = '%s options';
$lang['text_length'] = '%s caract&egrave;res.';
$lang['order'] = 'Ordre';
$lang['unspecified'] = '[non specifie]';
$lang['added'] = 'ajout&eacute;';
$lang['updated'] = 'mis &agrave; jour';
$lang['sort_options'] = 'Trier les options &agrave; l&#039;ex&eacute;cution&nbsp;';
$lang['select_one'] = 'Selectionnez-en un';
$lang['select_type'] = 'S&eacute;lectionnez le type';
$lang['to'] = 'Pour';
$lang['yes'] = 'Oui';
$lang['no'] = 'Non';
$lang['recipients'] = 'destinataires';
$lang['file_count'] = '%s fichiers possibles';
$lang['destination_count'] = '%s destinations';
$lang['save'] = 'Sauvegarder';
$lang['add'] = 'Ajouter';
$lang['update'] = 'Mise &agrave; jour';
$lang['save_and_continue'] = 'Sauvegarder et continuer l&#039;&eacute;dition';
$lang['information'] = 'Information';
$lang['automatic'] = 'Automatique';
$lang['forms'] = 'Formulaires';
$lang['form'] = 'Formulaire %s';
$lang['configuration'] = 'Configuration';
$lang['field_requirement_updated'] = 'Champ requis mis &agrave; jour.';
$lang['maximum_size'] = 'Taille Maximum';
$lang['permitted_extensions'] = 'Extensions';
$lang['permitted_filetypes'] = 'Types de fichier autoris&eacute;s';
$lang['file_too_large'] = 'fichier envoy&eacute; trop lourd ! La taille maximum est de :&nbsp;';
$lang['illegal_file_type'] = 'Ce type de fichier n&#039;est pas accept&eacute;. V&eacute;rifier l&#039;extension de votre fichier.';
$lang['upload'] = 'Envoi';
$lang['form_imported'] = 'Formulaire Import&eacute;.';
$lang['form_import_failed'] = 'L&#039;importation du formulaire a &eacute;chou&eacute; ! Il y a un probl&egrave;me avec le format du fichier XML .';
$lang['rows'] = '%s lignes';
$lang['cols'] = '%s colonnes';
$lang['12_hour'] = 'Sur 12 Heures';
$lang['24_hour'] = 'Sur 24 Heures';
$lang['hour'] = 'Heure';
$lang['min'] = 'Minute';
$lang['merid'] = 'Meridien';
$lang['date_range'] = 'Ordre : %s - %s';
$lang['thanks'] = 'Merci ! Votre formulaire a &eacute;t&eacute; re&ccedil;u.';
$lang['edit'] = 'Editer';
$lang['delete'] = 'Supprimer';
$lang['day'] = 'Jour';
$lang['mon'] = 'Mois';
$lang['year'] = 'Ann&eacute;e';
$lang['none'] = '(Aucun)';
$lang['uninstalled'] = 'Module d&eacute;sinstall&eacute;.';
$lang['installed'] = 'Module version %s install&eacute;e.';
$lang['upgraded'] = 'Module mis &agrave; jour &agrave; la version %s.';
$lang['button_previous'] = 'Retour...';
$lang['button_submit'] = 'Envoyer';
$lang['button_continue'] = 'Suivant...';
$lang['value_checked'] = 'V&eacute;rifi&eacute;';
$lang['value_unchecked'] = 'Non v&eacute;rifi&eacute;';
$lang['tab_main'] = 'Principal';
$lang['tab_symbol'] = 'Param&egrave;tres d&#039;affichage du Formulaire';
$lang['tab_submit'] = 'Envoi du Formulaire';
$lang['tab_captcha'] = 'Options Captcha ';
$lang['tab_advanced'] = 'Options avanc&eacute;es';
$lang['tab_templatelayout'] = 'Gabarit du Formulaire';
$lang['tab_submissiontemplate'] = 'Gabarit de l&#039;envoi';
$lang['canuse_smarty'] = '<em>Les variables Smarty sont actives dans ce champ.</em>';
$lang['add_options'] = 'Ajouter plus d&#039;options';
$lang['delete_options'] = 'Supprimer les options s&eacute;lectionn&eacute;es';
$lang['add_checkboxes'] = 'Ajouter d&#039;autres bo&icirc;tes de v&eacute;rification';
$lang['delete_checkboxes'] = 'Supprimer les bo&icirc;tes de v&eacute;rification s&eacute;lectionn&eacute;es';
$lang['add_address'] = 'Ajouter d&#039;autres adresses mail';
$lang['delete_address'] = 'Supprimer les adresses mail s&eacute;lectionn&eacute;es';
$lang['add_destination'] = 'Ajouter d&#039;autres destinations';
$lang['delete_destination'] = 'Supprimer les destinations s&eacute;lectionn&eacute;es';
$lang['suspected_spam'] = 'Trop de mails sont g&eacute;n&eacute;r&eacute;es &agrave; partir de votre adresse IP ! Le syst&egrave;me anti-spam a &eacute;t&eacute; activ&eacute; et les administrateurs du site en ont &eacute;t&eacute; inform&eacute;s.';
$lang['suspected_spam_log'] = 'De possibles spams provenant de l&#039;IP %s ont &eacute;t&eacute; stopp&eacute;s.';
$lang['reorder'] = 'R&eacute;organiser les champs';
$lang['cancel'] = 'Annul&eacute;';
$lang['value_set'] = 'Valeur donn&eacute;e : %s';
$lang['help_cataloger_attribute_fields'] = 'Below is a list of the attributes available from the Cataloger module.<br/>You can optionally specify valid ranges, values, or numerous values to be used in filtering the list of items that is displayed to the user.<br/>
<br/>
<strong>Ranges:</strong><br/>
Ranges can be specified by signifying a minimum and maximum value using this syntax: &quot;range: minvalue to maxvalue&quot;<br/>
<br/>
<strong>Multiple Values:</strong><br/>
To specify multiple values for an attribute use the syntax &quot;multi: value1|value2|value3&quot;<br/>
<br/>
<strong>Values from hidden fields</strong><br/>
To specify a value from a hidden field use the syntax {$fld_id}<br/>
<br/>';
$lang['help_name_regex'] = 'Une expression reguli&egrave;re pour filtrer par nom les items de Cataloger';
$lang['help_field_height'] = 'La hauteur du champ multiple';
$lang['title_name_regex'] = 'Nom de l&#039;expression reguli&egrave;re pour Cataloger';
$lang['title_field_height'] = 'Hauteur du champ';
$lang['title_file_path'] = 'Dossier de destination pour les fichiers cr&eacute;es&nbsp;';
$lang['title_udt_name'] = 'Tag utilisateur&nbsp;';
$lang['title_uploads_destpage'] = 'Page de retour pour les liens d&#039;uploads (envois)';
$lang['title_uploadmodule_summary'] = 'Envoy&eacute; avec formbuilder';
$lang['title_uploads_category'] = 'Cat&eacute;gorie d&#039;Uploads (envois)';
$lang['title_sendto_uploads'] = 'Envoyer ce fichier au module d&#039;upload';
$lang['title_legend'] = 'L&eacute;gende&nbsp;';
$lang['title_maximum_length'] = 'Longueur maximum&nbsp;';
$lang['title_checkbox_label'] = 'Intitul&eacute; de la  boite&nbsp;';
$lang['title_radio_label'] = 'Intitul&eacute; du bouton radio';
$lang['title_checked_value'] = 'Valeur v&eacute;rifi&eacute;e&nbsp;';
$lang['title_unchecked_value'] = 'Valeur non-v&eacute;rifi&eacute;e&nbsp;';
$lang['title_checkbox_details'] = 'D&eacute;tails des groupes des boites de v&eacute;rifications&nbsp;';
$lang['title_delete'] = 'Supprimer ?';
$lang['title_select_one_message'] = 'Texte personnalisable &quot;s&eacute;lection&quot;&nbsp;';
$lang['title_selection_value'] = 'Valeur s&eacute;lectionn&eacute;e';
$lang['title_selection_displayname'] = 'Nom d&#039;affichage s&eacute;lectionn&eacute;&nbsp;';
$lang['title_selection_subject'] = 'Sujet s&eacute;lectionn&eacute;';
$lang['title_select_default_country'] = 'S&eacute;lection par d&eacute;faut&nbsp;';
$lang['title_select_default_state'] = 'S&eacute;lection par d&eacute;faut&nbsp;';
$lang['title_select_default_province'] = 'S&eacute;lection par d&eacute;faut&nbsp;';
$lang['title_option_name'] = 'Nom de l&#039;Option';
$lang['title_option_value'] = 'Valeur soumise';
$lang['title_pulldown_details'] = 'Options par menu d&eacute;roulant&nbsp;';
$lang['title_multiselect_details'] = 'Options de S&eacute;lection multiple&nbsp;';
$lang['title_destination_address'] = 'Adresse mail de destination&nbsp;';
$lang['title_destination_filename'] = 'Nom du fichier de destination&nbsp;';
$lang['title_email_from_name'] = '&quot;From  Nom&quot; pour le mail&nbsp;';
$lang['title_relaxed_email_regex'] = 'Validation adresse mail plus souple&nbsp;';
$lang['title_relaxed_regex_long'] = 'Autoriser les adresses mail sans extension (c.a.d : accepter &quot;nom@domaine&quot; &agrave; la place de &quot;nom@domaine.com&quot; requis par d&eacute;faut)';
$lang['title_email_from_address'] = '&quot;From Adresse&quot; pour Mail de l&#039;exp&eacute;diteur&nbsp;';
$lang['title_email_encoding'] = 'Encodage des caract&egrave;res du mail&nbsp;';
$lang['title_director_details'] = 'Menu d&eacute;roulant bas&eacute; sur les d&eacute;tails de l&#039;email&nbsp;';
$lang['title_file_name'] = 'Nom du fichier&nbsp;';
$lang['title_email_subject'] = 'Ligne du sujet  dans le mail&nbsp;';
$lang['title_form_name'] = 'Nom du Formulaire&nbsp;';
$lang['title_form_status'] = 'Status du Formulaire&nbsp;';
$lang['title_ready_for_deployment'] = 'Pr&ecirc;t &agrave; &ecirc;tre d&eacute;ploy&eacute;';
$lang['title_not_ready1'] = 'Pas pr&ecirc;t';
$lang['title_redirect_page'] = 'Page de redirection apr&egrave;s l&#039;envoi du formulaire&nbsp;';
$lang['title_not_ready2'] = 'Ajouter un champ au formulaire pour pouvoir modifier les contributions des utilisateurs.';
$lang['title_not_ready_link'] = 'Utiliser ce raccourci';
$lang['title_form_alias'] = 'Alias du Formulaire&nbsp;';
$lang['title_form_fields'] = 'Champs du Formulaire&nbsp;';
$lang['title_field_id'] = 'ID du champ&nbsp;';
$lang['title_show_fieldaliases'] = 'Montrer les champs Alias&nbsp;';
$lang['title_show_fieldaliases_long'] = 'Cocher cette case montrera les champs Alias lors de l&#039;&eacute;dition de ce formulaire';
$lang['title_field_name'] = 'Nom de champ&nbsp;';
$lang['title_field_alias'] = 'Alias du champ&nbsp;';
$lang['title_radiogroup_details'] = 'D&eacute;tails des groupes des boutons radio&nbsp;';
$lang['title_field_type'] = 'Type de champ&nbsp;';
$lang['title_not_ready3'] = 'pour cr&eacute;er un formulaire rapidement.';
$lang['title_add_new_form'] = 'Ajouter un nouveau formulaire';
$lang['title_show_version'] = 'Montrer la version de Form Builder ?&nbsp;';
$lang['title_show_version_long'] = 'Cela indiquera dans un commentaire la version install&eacute;e du module Form Builder. parfois utile pour debugger';
$lang['title_add_new_field'] = 'Ajouter un nouveau champ';
$lang['title_form_submit_button'] = 'Texte du bouton d&#039;envoi du formulaire&nbsp;';
$lang['title_submit_button_safety'] = 'Ajouter du Javascript au bouton d&#039;envoi final pour aider &agrave; la pr&eacute;vention des envois multiples (spam) ?';
$lang['title_submit_button_safety_help'] = 'Ajouter un script s&eacute;curis&eacute;&nbsp;';
$lang['title_form_next_button'] = 'Texte du bouton &quot;suivant&quot; du formulaire (utilis&eacute; pour les formulaires comprenant plusieurs pages)&nbsp;';
$lang['title_form_prev_button'] = 'Texte du bouton &quot;pr&eacute;c&eacute;dent&quot; du formulaire (utilis&eacute; pour les formulaires comprenant plusieurs pages)&nbsp;';
$lang['title_field_validation'] = 'Validation du champ&nbsp;';
$lang['title_field_to_validate'] = 'Champ &agrave; valider&nbsp;';
$lang['title_form_css_class'] = 'Classe CSS de ce Formulaire&nbsp;';
$lang['title_field_css_class'] = 'Classe CSS de ce champ&nbsp;';
$lang['title_form_required_symbol'] = 'Symbole indiquant un champ obligatoire&nbsp;';
$lang['title_field_required'] = 'Requis&nbsp;';
$lang['title_field_required_long'] = 'Ce champ exige une r&eacute;ponse obligatoire&nbsp;';
$lang['title_hide_label'] = 'Intutil&eacute; cach&eacute;&nbsp;';
$lang['title_hide_label_long'] = 'Masquer le nom de ce champ dans le formulaire';
$lang['title_text'] = 'Texte statique &agrave; afficher&nbsp;';
$lang['title_field_regex'] = 'Validation Regex&nbsp;';
$lang['title_lines_to_show'] = 'Nombre de lignes &agrave; afficher&nbsp;';
$lang['no_default'] = 'Pas de s&eacute;lection par d&eacute;faut&nbsp;';
$lang['redirect_after_approval'] = 'Page de redirection apr&egrave;s acceptation&nbsp;';
$lang['title_regex_help'] = 'Cette expression r&eacute;guli&egrave;re sera seulement utilis&eacute;e si &quot;type de validation&quot; est mis sur une option apparent&egrave;e regex. Inclus un style Perl regex complet, incluant les slashes de d&eacute;but et fin ainsi que les flags (exemple : &quot;/image\.(\d+)/i&quot;)';
$lang['title_field_required_abbrev'] = 'Actif';
$lang['title_hide_errors'] = 'Cacher les erreurs&nbsp;';
$lang['title_form_displaytype'] = 'Type d&#039;affichage du formulaire';
$lang['title_hide_errors_long'] = 'Cacher aux utilisateurs l&#039;affichage des messages d&#039;erreur ou de debugage.';
$lang['title_email_template'] = 'Gabarit du mail&nbsp;';
$lang['title_maximum_size'] = 'Taille Maximum pour l&#039;envoi de fichier (kilobytes)&nbsp;';
$lang['title_maximum_size_long'] = 'Cette limitation est prioritaire sur les limites php ou sur celles de la configuration du serveur web';
$lang['title_permitted_extensions'] = 'Extensions autoris&eacute;es&nbsp;';
$lang['title_permitted_extensions_long'] = 'Entrer une liste s&eacute;par&eacute;e par un caract&egrave;re autre que le point, (exemple : &quot;jpg, gif, jpeg&quot;). Les espaces seront ignor&eacute;s. Laisser vierge signifie &quot;aucune restriction&quot;';
$lang['title_show_limitations'] = 'Afficher les restrictions ?&nbsp;';
$lang['title_show_limitations_long'] = 'Afficher les restrictions de tailles et d&#039;extensions pour le champ d&#039;upload ?';
$lang['title_form_template'] = 'Gabarit &agrave; utiliser pour afficher le formulaire&nbsp;';
$lang['title_page_x_of_y'] = 'Page %s &agrave; %s';
$lang['title_no_advanced_options'] = 'Champ sans option avanc&eacute;e.';
$lang['title_form_unspecified'] = 'Texte renvoy&eacute; pour les valeurs de champ non sp&eacute;cifi&eacute;&nbsp;';
$lang['title_enable_fastadd_long'] = 'Autoriser l&#039;ajout rapide des champs de formulaire &agrave; l&#039;aide d&#039;un menu d&eacute;roulant ?';
$lang['title_enable_fastadd'] = 'Acc&egrave;s rapide au formulaire ?&nbsp;';
$lang['title_fastadd'] = 'Ajout rapide du champ';
$lang['title_enable_antispam_long'] = 'Cocher cette case limitera &agrave; 10 mails par heure la transmission des formulaires pour une m&ecirc;me adresse IP.';
$lang['title_enable_antispam'] = 'Opter pour des restrictions anti-spam ?&nbsp;';
$lang['title_show_fieldids'] = 'Montrer les ID des champs&nbsp;';
$lang['title_show_fieldids_long'] = 'Cocher cette case autorisera l&#039;affichage des ID des champs pendant l&#039;ajout ou l&#039;&eacute;dition du formulaire';
$lang['title_xml_to_upload'] = 'Importer un formulaire &agrave; partir d&#039;un fichier XML&nbsp;';
$lang['title_xml_upload_formname'] = 'Utiliser ce nom de formulaire&nbsp;';
$lang['title_import_legend'] = 'Importer un formulaire de format XML&nbsp;';
$lang['title_xml_upload_formalias'] = 'Utiliser cet alias&nbsp;';
$lang['title_html_email'] = 'G&eacute;n&eacute;rer un mail en HTML ?&nbsp;';
$lang['title_link_autopopulate'] = 'Remplir automatiquement ?&nbsp;';
$lang['title_link_autopopulate_help'] = 'Remplir automatiquement avec l&#039;URL de la page contant le formulaire ? (Ceci r&eacute;&eacute;crira le lien de la page ci-dessous)';
$lang['title_default_link'] = 'Lien URL par d&eacute;faut&nbsp;';
$lang['title_default_link_title'] = 'Texte par d&eacute;faut du lien&nbsp;';
$lang['title_link_to_sitepage'] = 'Lien pour la page du site&nbsp;';
$lang['title_captcha_not_installed'] = 'Vous pouvez utiliser<a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a> pour prot&eacute;ger l&#039;envoi de vos formulaires en installant le module Captcha. Pour plus d&#039;informations, <a href="http://dev.cmsmadesimple.org/projects/captcha/">suivez le projet du Captcha</a>.';
$lang['title_use_captcha'] = 'Utiliser Captcha pour prot&eacute;ger l&#039;envoi de vos formulaires ?&nbsp;';
$lang['title_use_captcha_help'] = 'V&eacute;rifier ici comment prot&eacute;ger vos formulaires avec <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a>.';
$lang['title_user_captcha'] = 'Veuillez confirmer que vous n&#039;&ecirc;tes pas automate en recopiant les caract&egrave;res presents sur l&#039;image.';
$lang['title_user_captcha_error'] = 'Echec de la v&eacute;rification Captcha&nbsp;';
$lang['wrong_captcha'] = 'Image et texte different !';
$lang['title_title_user_captcha'] = 'Texte d&#039;aide concernant Captcha&nbsp;';
$lang['title_dont_submit_unchecked'] = 'Ne pas envoyer les valeurs non-coch&eacute;es&amp;nbsp';
$lang['title_dont_submit_unchecked_help'] = 'V&eacute;rifier seulement si les cases coch&eacute;es retournent des valeurs.';
$lang['link_label'] = 'Label du lien&nbsp;';
$lang['link_destination'] = 'URL de destination du lien&nbsp;';
$lang['title_default_set'] = 'S&eacute;lectionn&eacute; par d&eacute;faut ?&nbsp;';
$lang['title_24_hour'] = 'Heures de 0 &agrave; 24 ? &nbsp;';
$lang['title_before_noon'] = 'AM avant midi';
$lang['title_after_noon'] = 'PM apr&egrave;s midi';
$lang['title_smarty_eval'] = 'Avec des tags Smarty dans les champs ?&nbsp;';
$lang['title_textarea_rows'] = 'Lignes (note : peut &ecirc;tre modifi&eacute; via CSS)&nbsp;';
$lang['title_textarea_cols'] = 'Colonnes (note : peut &ecirc;tre modifi&eacute; via CSS)&nbsp;';
$lang['title_form_main'] = 'Accueil - D&eacute;tails du Formulaire&nbsp;';
$lang['title_show_username'] = 'Affichage login utilisateur ?&nbsp;';
$lang['title_show_userfirstname'] = 'Affichage pr&eacute;nom utilisateur ?&nbsp;';
$lang['title_show_userlastname'] = 'Affichage nom utilisateur ?&nbsp;';
$lang['title_restrict_to_group'] = 'Liste des utilisateurs pour le groupe sp&eacute;cifi&eacute;&nbsp;';
$lang['restricted_to_group'] = 'Seulement pour le groupe %s&nbsp;';
$lang['title_show_to_user'] = 'Affichage utilisateur ?&nbsp;';
$lang['help_leaveempty'] = 'Ce champ peut &ecirc;tre laiss&eacute; vide&nbsp;';
$lang['help_variables_for_template'] = 'Variables pour gabarit';
$lang['help_variables_for_computation'] = 'Variables autoris&eacute;es';
$lang['help_php_variable_name'] = 'Variable PHP ';
$lang['help_submission_date'] = 'Date d&#039;envoi';
$lang['help_server_name'] = 'Votre serveur';
$lang['help_sub_source_ip'] = 'Adresse IP de la personne utilisant le formulaire';
$lang['help_sub_url'] = 'URL de la page contenant le formulaire';
$lang['help_fb_version'] = 'Version de FormBuilder';
$lang['help_tab'] = 'Tabulation';
$lang['help_other_fields'] = 'Les autres noms de champs peuvent &ecirc;tre utilis&eacute;s de fa&ccedil;on interchangeable (particuli&egrave;rement utile si Smarty bloqu&eacute; sur les caract&egrave;res ASCII en dehors de 32-126). <br />les autres champs seront disponibles si vous les ajouter au formulaire.';
$lang['help_array_fields'] = 'Yet another way of accessing field values is via $fieldname_obj, $alias_obj, or $fld_#_obj, where each field is an object containging:<br /><table>
<tr><td class=&quot;odd&quot;>name</td><td class=&quot;odd&quot;>Field Name</td></tr>
<tr><td>type</td><td>Field Type</td></tr>
<tr><td class=&quot;odd&quot;>id</td><td class=&quot;odd&quot;>Internal Field ID</td></tr>
<tr><td>value</td><td>Human-readable Value</td></tr>
<tr><td class=&quot;odd&quot;>valueArray</td><td class=&quot;odd&quot;>Array of field value(s)</td></tr></table><em>e.g.</em>, you could use &quot;{$fld_1_obj->name} = {$fld_1_obj->value}';
$lang['help_date_format'] = '&nbsp;Consulter le <a href="http://www.php.net/manual/fr/function.date.php" target="_blank">manuel PHP</a> pour vous aider.';
$lang['help_variable_name'] = 'Variable';
$lang['help_form_field'] = 'Champ repr&eacute;sent&eacute;&nbsp;';
$lang['link_back_to_form'] = '&laquo; Retour au Formulaire';
$lang['title_create_sample_template'] = 'Cr&eacute;er un mod&egrave;le de gabarit';
$lang['title_create_sample_html_template'] = 'Cr&eacute;er un mod&egrave;le de gabarit HTML';
$lang['title_create_sample_header_template'] = 'Cr&eacute;er un mod&egrave;le d&#039;ent&ecirc;te';
$lang['title_create_sample_header'] = 'Cr&eacute;er un mod&egrave;le d&#039;ent&ecirc;te';
$lang['help_tab_symbol'] = 'une tabulation';
$lang['title_file_template'] = 'Gabarit d&#039;une ligne pour les fichiers cr&eacute;es&nbsp;';
$lang['title_file_header'] = 'Gabarit du header (en-t&ecirc;te) des fichiers cr&eacute;es&nbsp;';
$lang['title_confirmation_url'] = 'URL &agrave; suivre pour confirmer le formulaire&nbsp;';
$lang['title_value'] = 'Valeur (regardez dans onglets &quot;Options avanc&eacute;e&quot; si vous utilisez des balises Smarty)&nbsp;';
$lang['title_date_format'] = 'Format de la  (<a href="http://www.php.net/manual/fr/function.date.php" target="_blank">date PHP standard </a>)&nbsp;';
$lang['title_use_wysiwyg'] = 'Utiliser un &eacute;diteur WYSIWYG pour la zone de texte (cot&eacute; admin seulement) ?&nbsp;';
$lang['title_submit_actions'] = 'Comportement lors de l&#039;envoi du Formulaire';
$lang['title_submit_labels'] = 'Labels des boutons de soumission';
$lang['title_sortable_field'] = 'Tri par champs #%s';
$lang['title_submit_help'] = 'Cette page vous permet de personnaliser le formulaire. Cela ne d&eacute;finit pas ce que le module Form Builder fait des donn&eacute;es r&eacute;colt&eacute;es. La destination des donn&eacute;es sera d&eacute;finie dans les champs &quot;Disposition&quot; (commnen&ccedil;ant par *.... ).';
$lang['title_start_year'] = 'Ann&eacute;e de d&eacute;but&nbsp;';
$lang['title_end_year'] = 'Ann&eacute;e de fin&nbsp;';
$lang['title_default_year'] = 'Ann&eacute;e par d&eacute;faut&nbsp;';
$lang['title_default_year_help'] = '&nbsp;(Mettez -1 pour l&#039;ann&eacute;e par d&eacute;fault pour signifier l&#039;ann&eacute;e courante)';
$lang['title_submit_action'] = 'Action apr&egrave;s l&#039;envoi du formulaire&nbsp;';
$lang['title_submit_response'] = 'R&eacute;ponse &agrave; afficher&nbsp;';
$lang['display_text'] = 'Afficher un r&eacute;sum&eacute; du formulaire envoy&eacute;&nbsp;';
$lang['redirect_to_page'] = 'Rediriger vers une page du site';
$lang['title_submit_response_help'] = 'Ce gabarit sert &agrave; l&#039;affichage pour l&#039;utilisateur apr&egrave;s l&#039;envoi du formulaire . Ce gabarit n&#039;a aucun effect ni sur les mails, ni sur d&#039;autres formulaires - Vous placerez ces gabarits (judicieusement) dans l&#039;onglet &quot;options avanc&eacute;es&quot;.';
$lang['title_destination_page'] = 'Page de destination&nbsp;';
$lang['title_require_fieldnames'] = 'Nommage des champs requis&nbsp;';
$lang['title_require_fieldnames_long'] = 'Les champs doivent obligatoirement avoir un nom ? (case coch&eacute;e = oui)&nbsp;';
$lang['title_unique_fieldnames'] = 'Champs &agrave; nom unique requis&nbsp;';
$lang['title_unique_fieldnames_long'] = 'Les champs doivent avoir des noms diff&eacute;rents (case coch&eacute;e = oui)&nbsp;';
$lang['title_reorder_form'] = 'R&eacute;organiser les champs';
$lang['title_load_template'] = 'Charger le gabarit &nbsp;';
$lang['title_add_button_text'] = 'Ajouter un bouton texte&nbsp;';
$lang['title_del_button_text'] = 'Supprimer un bouton texte&nbsp;';
$lang['title_string_or_number_eval'] = 'Interpr&eacute;ter les variables comme &eacute;tant des nombres ou des cha&icirc;nes de caract&egrave;res&nbsp;';
$lang['title_order'] = 'Ordre d&#039;interpr&eacute;tation&nbsp;';
$lang['title_order_help'] = 'Si plus d&#039;un champ de calcul existe, ils seront calcul&eacute; du plus petit au plus grand';
$lang['title_compute_value'] = 'Valeur de calcul&nbsp;';
$lang['title_string'] = 'Cha&icirc;nes de caract&egrave;res';
$lang['title_numeric'] = 'Numerique';
$lang['title_inline_form'] = 'Montrer le formulaire en ligne ?&nbsp;';
$lang['title_inline_form_help'] = 'Coch&eacute; signifie que le formulaire remplace le tag {cms_module}, Non-Coch&eacute; remplace le tag {content}.';
$lang['title_field_default_value'] = 'Valeur par d&eacute;faut pour le champ&nbsp;';
$lang['title_clear_default'] = 'Effacer la valeur par d&eacute;faut par un click ?';
$lang['title_clear_default_help'] = 'Verifier ceci pour effacer la valeur par d&eacute;faut quand l&#039;utiisateur cliquera ce champ. Puisque cela utilise la comparaison de cha&icirc;ne en javascript, un d&eacute;faut aura lieu si vous indiquer des simples quotes dans votre texte par d&eacute;faut. V&eacute;rifier les carract&egrave;res utiliser pour &eacute;viter les erreurs.';
$lang['title_remove_file_from_server'] = 'Supprimer les fichiers uploader depuis le serveur apr&eacute;s ex&eacute;cution (disposition email )&nbsp;';
$lang['title_field_javascript'] = 'Javascript pour le champ&nbsp;';
$lang['title_field_javascript_long'] = 'Mettre le code Javascript, inclu les &eacute;v&eacute;nements, ex : onclick=&quot;yourfn()&quot;';
$lang['title_submit_javascript'] = 'Formulaire de soumission Javascript&nbsp;';
$lang['title_submit_javascript_long'] = 'Mettre le code Javascript, inclu les &eacute;v&eacute;nements, ex : onclick=&quot;yourfn()&quot;.<br />This will probably not work well if you use the &quot;safety script&quot; option above.';
$lang['email_from_addr_help'] = 'Do not just pick a random address here -- many ISPs will<br />not deliver the mail if you are using a different domain name than your actual<br />host name (i.e., use something like name@%s)';
$lang['title_switch_advanced'] = 'Besoin de plus de types de champs ? ';
$lang['title_switch_basic'] = 'Trop de type de champs confus ? ';
$lang['title_switch_advanced_link'] = 'Passer en mode avanc&eacute;';
$lang['title_switch_basic_link'] = 'Passer en mode simple';
$lang['title_file_root'] = 'Dossier dans lequel le fichier sera sauver';
$lang['title_file_root_help'] = 'Ce doit &ecirc;tre un dossier de votre serveur Web avec des permissions d&#039;&eacute;criture<br />Chmod 777 il si vous avez des probl&egrave;mes ou doutes.<br />De plus, v&eacute;rifiez que vous n&#039;avez pas restrictions de r&eacute;pertoire PHP.';
$lang['title_newline_replacement'] = 'Nouvelle ligne/Retour &agrave; la ligne en remplacement de caract&egrave;res&nbsp;';
$lang['title_newline_replacement_help'] = 'Laisser en blanc la ligne pour permettre une Nouvelle ligne/Retour &agrave; la ligne';
$lang['error_cataloger_module_not_available'] = '<strong>Le module Cataloger ne semble pas &ecirc;tre install&eacute;/actif.</strong>';
$lang['warning'] = 'ATTENTION !';
$lang['default_template'] = 'Gabarit par d&eacute;faut';
$lang['table_left_template'] = 'Gabarit tableau, Titres &agrave; gauche';
$lang['table_top_template'] = 'Gabarit  tableau, Titres en haut';
$lang['form_template_name'] = 'Gabarit venant de %s';
$lang['template_are_you_sure'] = '&Ecirc;tes-vous s&ucirc;r de vouloir renommer votre gabarit avec le nouveau ? (Even if you say OK, you will still need to save the change)';
$lang['title_bad_function'] = 'Erreur de calcul &quot;%s&quot;.';
$lang['no_referrer_info'] = 'No HTTP_REFERER information non valable (probablement  du au syst&egrave;me de validation Email)';
$lang['validation_param_error'] = 'Erreur du param&egrave;tre de validation. V&eacute;rifier que vous avez recopier correctement l&#039;email !';
$lang['validation_response_error'] = 'Erreur de r&eacute;ponse de la validation. V&eacute;rifier que vous avez recopier correctement l&#039;email !';
$lang['validation_no_field_error'] = 'Erreur de r&eacute;ponse de la validation. Aucune validation de champ email dans ce formulaire !';
$lang['upgrade03to04'] = 'Form Template was updated automatically as part of the version 0.3 to version 0.4 upgrade. You may need to make some fixes. If you&#039;re using the default form, simply replace this template with &quot;default&quot; using the pulldown above.';
$lang['admindesc'] = 'Ajout, &eacute;dition et construction interactive des formulaires';
$lang['operators_help'] = 'Si vous utilisez une &eacute;valuation de cha&icirc;ne de caract&egrave;res, la seule op&eacute;ration possible est la concat&eacute;nation (+), alors que si vous utilisez une &eacute;valuation num&eacute;rique, vous avez les symboles de base (, +, -, *, /, ).';
$lang['date_january'] = 'Janvier';
$lang['date_february'] = 'F&eacute;vrier';
$lang['date_march'] = 'Mars';
$lang['date_april'] = 'Avril';
$lang['date_may'] = 'Mai';
$lang['date_june'] = 'Juin';
$lang['date_july'] = 'Juillet';
$lang['date_august'] = 'Ao&ucirc;t';
$lang['date_september'] = 'Septembre';
$lang['date_october'] = 'Octobre';
$lang['date_november'] = 'Novembre';
$lang['date_december'] = 'Decembre';
$lang['submission_error'] = 'D&eacute;sol&eacute; ! Une erreur a emp&eacute;ch&eacute; la transmission du formulaire.';
$lang['submit_error'] = 'Erreur FormBuilder : %s';
$lang['uploads_error'] = 'Erreur sur le fichier du module upload : %s';
$lang['nouploads_error'] = 'Module d&#039;upload introuvable';
$lang['upload_attach_error'] = 'Erreur sur le fichier Upload/Attachement  %s (tmp_name : %s, de type %s)';
$lang['submission_error_file_lock'] = 'Erreur. Impossible d&#039;obtenir le blocage du fichier.';
$lang['unchecked_by_default'] = 'Par d&eacute;faut : d&eacute;coch&eacute;';
$lang['checked_by_default'] = 'Par d&eacute;faut : coch&eacute;';
$lang['email_default_template'] = 'Soumission par FormBuilder';
$lang['email_template_not_set'] = '<br/>Gabarit du mail non encore fait !';
$lang['missing_cms_mailer'] = 'FormBuilder : impossible de trouver le module CMSMailer requis !';
$lang['user_approved_submission'] = 'Utilisateur aprouvant la soumission %s de %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Ev&eacute;nement d&eacute;clench&eacute; lorsque un formulaire FormBuilder est envoy&eacute;';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Ev&eacute;nement d&eacute;clench&eacute; s&#039;il y a une erreur lorsque un formulaire FormBuilder est envoy&eacute;';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Ev&eacute;nement d&eacute;clench&eacute; lorsque FormBuilder un formulaire est affich&eacute;';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Ev&eacute;nement d&eacute;clench&eacute; lorsqu&#039;un formulaire FormBuilder est envoy&eacute;.</p>
<h4>Param&egrave;tres</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>value_<name></em> - Supply a default value to a field with the specified name.</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Ev&eacute;nement d&eacute;clench&eacute; s&#039;il y a une erreur lorsqu&#039;un formulaire FormBuilder est envoy&eacute;</p>
<h4>Param&egrave;tres</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>error</em> - A list of all known errors (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Ev&eacute;nement d&eacute;clench&eacute; lorsqu&#039;un formulaire FormBuilder est affich&eacute;</p>
<h4>Param&egrave;tres</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
</ul> ';
$lang['formbuilder_params_response_id'] = 'ID. de la r&eacute;ponse utilis&eacute;e par le module FormBrowser';
$lang['formbuilder_params_passed_from_tag'] = 'Valeurs du champ par d&eacute;faut; voir le module d&#039;aide';
$lang['formbuilder_params_field_id'] = 'ID du champ pour les op&eacute;rations internes';
$lang['formbuilder_params_form_name'] = 'Nom du formulaire';
$lang['formbuilder_params_form_id'] = 'ID du formulaire pour les op&eacute;rations internes';
$lang['formbuilder_params_general'] = 'Param&egrave;tres g&eacute;n&eacute;raux pour les op&eacute;rations internes';
$lang['template_variable_help'] = '<h3>Variables du Gabarit de Formulaire</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Voici les diff&eacute;rentes valeurs applicables aux champs :</p>
<table>
<tr><th>Champ</th><th>Valeur</th></tr>
<tr><td>champ->display</td><td>1 pour afficher le champ, sinon 0</td></tr>
<tr><td>champ->required</td><td>1 si le champ est requis, sinon 0</td></tr>
<tr><td>champ->required_symbol</td><td>Le symbole signalant les champs obligatoires</td></tr>
<tr><td>champ->css_class</td><td>La classe CSS de ce champ</td></tr>
<tr><td>champ->valid</td><td>1 si le champ &eacute;t&eacute; valide, sinon 0</td></tr>
<tr><td>champ->error</td><td>Texte pour les probl&egrave;mes de validation, au cas o&ugrave; le champ ne serait pas valid&eacute;</td></tr>
<tr><td>champ->hide_name</td><td>1 si le nom du champs doit rester cach&eacute;, sinon 0</td></tr>
<tr><td>champ->has_label</td><td>1 si le type de champ a un label</td></tr>
<tr><td>champ->needs_div</td><td>1 si le champ doit &ecirc;tre int&eacute;gre dans un DIV (ou dans une ligne de tableau, si c&#039;est votre choix)</td></tr>
<tr><td>champ->name</td><td>Le nom du champ</td></tr>
<tr><td>champ->input</td><td>La valeur de contr&ocirc;le du champ (ex. : la valeur du champ)</td></tr>
<tr><td>champ->op</td><td>un bouton de controle associ&eacute; au champ si c&#039;est possible (ex. : le bouton supprimer pour un champ texte)</td></tr>
<tr><td>champ->input_id</td><td>l&#039; ID du champ (utile pour utiliser <label for=&quot;&quot;>)</td></tr>
<tr><td>champ->type</td><td>le yype de donn&eacute;es du champ</td></tr>
                                
<tr><td>champ->multiple_parts</td><td>1 si le champ->input est une collection de contr&ocirc;les</td></tr>
<tr><td>champ->label_parts</td><td>1 si la collection de contr&ocirc;les a des labels s&eacute;par&eacute;s pour chaque contr&ocirc;le</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Voici les variables smarty compl&eacute;mentaires que vous pouvez utiliser :</p>
<table>
<tr><th>Variable</th><th>Valeur</th></tr>
<tr><td>total_pages</td><td>nombre de pages pour un formulaire multi-pages</td></tr>
<tr><td>this_page</td><td>num&eacute;ro de la page courrante pour un formulaire multi-pages</td></tr>
<tr><td>title_page_x_of_y</td><td>affiche &quot;page x de y&quot; pour un formulaire multi-pages</td></tr>
<tr><td>css_class</td><td>La classe CSS pour le formulaire</td></tr>
<tr><td>form_name</td><td>Nom du formulaire</td></tr>
<tr><td>form_id</td><td>ID de la base de donn&eacute;es du formulaire</td></tr>
<tr><td>prev</td><td>Bouton &quot;Reculer&quot; pour un formulaire multiple</td></tr>
<tr><td>submit</td><td>Bouton &quot;Suivant&quot; or &quot;Envoyer&quot;  pour un formulaire multiple, adjuster automatiquement</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>
';
$lang['post_install'] = '<p>Make sure to set the &quot;Modify Forms&quot; permissions
on users who will be administering feedback forms. Also, if you&#039;ll be emailing form
results, be sure to update the Configuration appropriately.</p>
<p>Please be aware that a feedback form should not be active (e.g., usable by the public) while
you are still editing the form. You should create the form, and place the tag into an active
content page only when you have finished editing. Otherwise, erroneous results could be returned.</p>
<p>Additionally, this version does not support parallel editing of forms. Please take care that
only one admin is editing a given form at a given time.</p>';
$lang['help'] = '<h3>Que fait ce module ?</h3>
<p>The Form Builder Module allows you to create feedback forms (in fact, it&#039;s a replacement of the original Feedback Form module), with the added power of database storage. With its companion module Form Browser, you can use it to create simple database applications.</p>
<p>The forms created using the Form Builder may be inserted
into templates and/or content pages. Forms may contain many kinds of inputs, and may have
validation applied to these inputs. The results of these forms may be handled in a variety of ways.</p>

<h3>Comment l&#039;utiliser ?</h3>
<P>Install it, and poke around the menus. Play with it. Try creating forms, and adding them to your content.
If you get stuck, chat with me on the #cms IRC channel, post to the forum, send me email, or, if you&#039;re
really desperate, try reading the instructions on the rest of this page.</P>

<h3>Comment cr&eacute;er un formulaire ?</h3>
<p>In the CMS Admin Menu, you should get a new menu item called FormBuilder. Click on this. On the page
that gets shown, there are options (at the bottom of the list of Forms) to Add a New Form or Modify
Configuration.</p>

<h3>Ajouter un formulaire &agrave; une Page</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module=&#039;FormBuilder&#039; form=&#039;sample_form&#039;}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page&#039;s content if you use a WYSIWYG editor such as TinyMCE, FCKEdit, or HTMLArea. These editors may stealthily
change the quote marks (&quot;) into HTML entities (&amp;quot;), and the forms will not show up. Try using
single quotes (&#039;) or editing the HTML directly.</p>

<h3>Travailler avec les formulaires</h3>
<p>By clicking on a Form&#039;s name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you&#039;ll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing.</p>
<p>Below this, if you have it enabled, is the &quot;fast field adder&quot; pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Soumission des formulaires</h4>
<p>When the form is submitted, you can either redirect the user to another page of your site, or you can present the user some message (which can contain any of the user&#039;s form entries, or just static text). In this tab, you select which of these approaches you wish to use, and, if you chose redirection, it allows you to pick the page to redirect users to after a successful form submission.</p>
<p>Also on this page, you can specify the labels of various submission buttons (&quot;Previous&quot;, &quot;next&quot;, &quot;submit&quot;). You can also opt to have some Javascript added to the last page of a form that will prevent multiple submissions (useful on slow servers).</p>
<h4>Option d&#039;affichage du formulaire</h4>
<p>This tab allows for other form customizations, like the symbol to show for required fields.</p>
<h4>Captcha Settings</h4>
<p>If you have installed the Captcha module, this tab lets you configure the Captcha settings for your form.</p>
<h4>Gabarit de formulaire</h4>
<p>This is where you do your customization work of your form&#039;s Smarty Template. See the section called Form Template Variables below.</p>
<p>The form should default to a Custom template that documents the Smarty tags available to you.</p>
<p>Unless you&#039;re a Smarty expert, you probably don&#039;t want to mess around with this. If you are a Smarty expert, this is where you can unleash your magic.</p>
<h4>Soumission du gabarit</h4>
<p>If, in the Form Submission tab, you selected &#039;Display &quot;Submission Template&quot;, this is where you can create that template. There is a display of which smarty variables are available to you, and a button to generate a sample template.</p>
<p>If you&#039;re a Smarty expert, you can do all manner of creative and powerful things here. If you&#039;re not a Smarty expert, you might just want to use the default.
</p>

<h3>Ajouter des champs dans votre formulaire</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it&#039;s submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it&#039;s safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked &quot;Required&quot;, which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to &quot;view source&quot; on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It&#039;s really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It&#039;s really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Canadian Province. This is a pulldown listing the Canadian Provinces (Contributed by Noel McGran. Thanks!)</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
<li>Time Picker. This is a set of pulldowns allowing the user to select a time (using 12 or 24 hour clock).</li>
<li>File Upload. This is a file upload field.</li>
<li>Link (User Entered). This creates a double input field for getting a link URL and link title.</li>
<li>Text Field (Multiple). This field creates one or more text inputs with add and delete buttons, effectively giving the end user a way of creating variable-length lists.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the &quot;From&quot; field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the &quot;From&quot; field.</li>
<li>Email Subject Field. This allows users to provide a subject for their email. The email generated when the form gets handled will use this in the &quot;Subject&quot; field. This may cause trouble with certain dispositions that want to control the Email Subject, so use it with caution.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Fieldset Start. Combined with Fieldset End, this allows you to group various fields within your form. Use this to start a given grouping.</li>
<li>-Fieldset End. Combined with Fieldset Start, this allows you to group various fields within your form. Use this to end a given grouping.</li>
<li>-Hidden Field. This allows you to embed a hidden field in your form.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you&#039;re not using a Custom Template to render your form.</li>
<li>-Static Link. This allows you to put a link to a given page into your form. Optionally, you can have it autopopulate with the page where the form is embedded (useful if you&#039;re sending results via email).</li>
<li>-Computed Field. This allows you to embed a computed field in your form. It is not visible to the user until after the form is submitted. It allows you to do simple arithmetic or string concatenation.</li>
<li>-Unique Integer (Serial). This is an integer that increases every time someone hits your form. Your results may not be sequential, but they will increase monotonically.</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<ul><li>*Call a User Defined Tag With the Form Results. This submits all the form results to the User-Defined Tag you specify. The UDT can handle the results however it wants. Values are passed as $param[&#039;field_name&#039;].</li>
<li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these &quot;Director&quot; pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email to User-Supplied Address. This puts an input field in the form for the user to populate with an email address. The form results get sent to that address. Beware of Spam abuse! Active the primitive anti-spam features in the FormBuilder configuration screen.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Redirect to Page Based on Pulldown. This allows you to redirect the form to a different site page depending on its value. If you have multiple dispositions, make sure this is used last.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered &quot;approved,&quot; and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the &quot;output&quot; directory under the
module&#039;s installation directory, assuming the web server has permission to write there.</li>
<li>*Save Results to File Based on Pulldown. Like the Flat File disposition, except the value of a pull-down determines which file results get written to.</li>
<li>*Save Results to File(s) Based on Multiple Selections. Like the Flat File disposition, except the value(s) of checkboxes  determines which file(s) results get written to.</li>
<li>*Email to CMS Admin User. Provides a pull-down of CMS Admin users, and directs the results as an email to the selected admin.</li>
<li>*Store Results for FormBrowser Module v.3. Stores the form results in an XML structure as a single database record. This will become the interface to Form Browser in the next release.</li>

</ul></li></li></ul>


<h3>Passing Default Values to Forms</h3>
<p>Calguy added a nice feature, which is that you can pass default field values to your form via the module tag. This allows you to have
the same form in multiple places, but with different default values. It may not work for more exotic field types, but for fields that have
a single value, you can specify like:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_<i>FIELDNAME</i>=&#039;default_value&#039;}</p>
<p>This will set the field with <i>FIELDNAME</i> to &#039;default_value&#039;.</p>
<p>This can be problematic, as sometimes field names are unweildy or contain characters that don&#039;t work well with Smarty. So there is an
alternative like this:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_fld<i>NUMBER</i>=&#039;default_value&#039;}</p>
<p>That uses field <i>NUMBER</i>, where <i>NUMBER</i> is the internal FormBuilder field id. You might wonder how you know what that id is. Simply go into the FormBuilder configuration tab,
and check &quot;Show Field IDs&quot;</p>

<h3>Email and Flat File Templates</h3>
<p>Many disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it&#039;s own best guess, which may or may not work out to your liking. You can always click on the &quot;Create Sample Template&quot; and then customize the results.</p>
<p>To the right, you&#039;ll find a legend which lists all of the variables that are available to you to use in your template. As of version 0.3, variables have two names, one based on the field name, the other based on the field ID. If you use field names that have characters outside of the ASCII 32-126 range, it will be safer to use the ID-based variables.</p>
<p><strong>Note that once you&#039;ve changed a template, it will no longer automatically add new fields.</strong> For this reason, it&#039;s usually best to create your templates as the last step of creating your form.</p>
<p>As of version 0.2.4, you can opt to send any of these emails as HTML email. There should be a checkbox at the top of the template page for this. There is also a &quot;Create Sample HTML Template&quot; button over in the legend area. For HTML email, the email body will also provide the default text-only values.</p>

<h3>Configuration</h3>
<p>There are some global configuration options for FormBuilder:</p>
<ul>
<li>Enable fast field add pulldown. This enables the pulldown on the Form Edit page which saves a step in the creation of new fields.</li>
<li>Hide Errors. This is set by default. Unchecking it will cause more detailed errors to be displayed if there are problems when you submit your form.</li>
<li>Require Field Names. Typically, you will want form fields to be named so you can tell which is which. However, in some cases, you might want to have nameless fields. Uncheck this if you want to allow nameless fields.</li>
<li>Unique Field Names. Typically, you will want form fields to have unique names so you can tell which is which. Uncheck this if you want to allow fields to share names.</li>
<li>Use relaxed email validation. This uses a less restrictive regular expression for validating email; e.g., x@y will be allowed, where typically x@y.tld is required.</li>
<li>Show Form Builder Version. Displays the version of FormBuilder you&#039;re using in a comment when the form is generated. Typically only useful when debugging.</li>
<li>Enable primitive anti-spam features. When turned on, this allows any given IP address to only generate 10 emails per hour.</li>
<li>Show Field IDs. When turned on, FormBuilder will display field ids when adding or editing a form.</li>
</ul>
<h3>Styling and CSS</h3>
<p>Paul Noone graciously provides us all with a pretty good standard CSS that you can use for forms:</p>
<pre>
	/* Sample FormBuilder CSS base */
	form {margin-top:0}
	form, td, th, li { font-size: 100%}
	form div {margin-bottom:0}
	fieldset div {
		margin-bottom:0.5em;
		margin-left:1em;
	}
	fieldset div div {
		margin-top:0.5em;
		margin-left:1em
	}
	fieldset {
		margin-bottom:1em;
		border:1px solid #F60;
		padding:0.5em
	}
	fieldset label {
		width:auto;
	}
	legend {
		color:#FFF;
		background:#F60;
		font-style:italic;
		font-size:1.2em;
		margin-bottom:0.5em;
		padding:0.2em;
		width:auto;
		border:1px solid #CCC
	}
	textarea {
		margin: 0.5em 0;
		width:98%;
		height: 6em
	}

	/* Apply this class to text/select input fields with shorter labels
		to help alignment */
	.short-label label {float:left; width:10em}
	.short-label fieldset div input,
	.short-label fieldset div select {width:16em}

	/* Pretty up your Captcha image output */
	.captcha {
		margin:0.5em 0;
		width:200px;
		text-align:center
	}
	.captcha img {border:1px solid #F60; margin-bottom:0.5em}
	.captcha input {width:196px; margin-top:0.5em}

	/* Just a bit more room for the Submit button */
	.submit {margin-top:0.5em}
</pre>

<h3>Form Template Variables</h3>

<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>


<h3>Known Issues</h3>
<ul>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn&#039;t matter since the user side is pretty simple.</li>
<li>FileUpload Fields may not work correctly with multipage forms.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you&#039;re running CMS 1.1 or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you&#039;re missing fields in an email that gets generated, check the disposition field&#039;s template, and make sure you&#039;re specifying the missing fields. Seems obvious, but it&#039;s an easy mistake to make.</li>
<li>Uncheck the &quot;Hide Errors&quot; checkbox in the global options, and see what message gets displayed when you submit your form.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is no longer a particularly early version, but it is probably still buggy. While I&#039;ve done all I can
to make sure no egregious bugs have crept in, I have to admit that during early testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor&#039;s nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>.</li>
<li>Additional discussion of this module may also be found in the <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
</ul>
<p>Keep in mind that the author has put hundreds of hours into the development of this module. Please take the time to read the documentation before sending questions. Either that, or write your questions on financially negotiable instruments (i.e., cash).</p>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2008, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '<ul>
<li>Version 0.5.4. 29 Aug 08. Scrapping plans for 0.6. Bug fixes. Ted&#039;s new &quot;Email &quot;From Address&quot; Again Field&quot;. Added database indices.</li>
<li>Version 0.5.3. 26 May 08. Bugfixes to previous set of bugfixes. Now ready for major upgrades for 0.6.</li>
<li>Version 0.5.2. 25 May 08. Bugfixes. Release in preparation for substantial reworking for 0.6</li>
<li>Version 0.5.1. 30 April 08. Bugfixes, rewrote some of the File Upload code to prevent white screen of annoyance.</li>
<li>Version 0.5. 19 April 08. Bugfixes, support for FormBrowser fixes and features, disposition type for upcoming FormBrowser version.</li>
<li>Version 0.4.4. 26 Sept 07. Bugfixes for radio button groups, fix for validation of DispositionDeliverToEmailAddressField.</li>
<li>Version 0.4.3. 18 Sept 07. Bugfixes for pulldowns using numbers, option to inline form, fixes for table-layouts provided by Ap Muthu, fix for requirability of Dispositions.</li>
<li>Version 0.4.2. 14 Sept 07. Bugfixes for XML export, RadioButton Group submission, and HTML labels.</li>
<li>Version 0.4.1. Bugfixes for File Disposition Types.</li>
<li>Version 0.4
	<ul>
		<li>Upped minimum CMS version to 1.1</li>
		<li>Numerous Bug fixes; too many to enumerate here</li>
		<li>Massive rejiggering of code to work with CMS MS 1.1 parameter sanitizing regime</li>
		<li>Added field types: &quot;TextField (Multiple)&quot; and &quot;Computed Field&quot;</li>
		<li>Added dispositions: &quot;Save Results to File Based on Pulldown&quot; and &quot;Save Results to File(s) Based on Multiple Selections&quot;(Calguy)</li>
		<li>Added neat-o AJAX-y template-copying for Form Templates, gave versions of old table-based templates to soothe the raging masses.</li>
		<li>Added ability to pass default values to form elements from module tag using value_FIELDNAME=&quot;value&quot; syntax (Calguy)</li>
		<li>Added option to display field ids in admin (Calguy)</li>
	</ul>
</li>
<li>Version 0.3
   <ul>
      <li>Added Captcha module support.</li>
      <li>Reworked labeling of form elements to be XHTML compliant</li>
      <li>Added Paul Noone&#039;s new, improved contact form templates</li>
      <li>Implementation of Email Subject Field</li>
      <li>Added admin-specifiable values to hidden field type, which may contain parsable smarty tags</li>
      <li>Text Area Field now allows specification of rows and cols in the admin, instead of CSS</li>
      <li>Added Drag&#039;n&#039;Drop reordering of form fields.</li>
      <li>Added non-blank field name and unique field name global configuration options and validation</li>
      <li>Implemented templated display of form results upon submission in addition to page redirecting</li>
      <li></li>
   </ul>
</li>
<li>Version 0.2.4 - 09 May 2007
   <p>Big release:<ul>
   <li>Added &quot;Email Form to User-Supplied Address&quot; disposition.</li>
   <li>Added &quot;TimePicker&quot; field type. Split &quot;Link&quot; field into a &quot;User-supplied Link&quot; field and a &quot;Static Link&quot; field.</li>
   <li>Added HTML email option and auto-templates for all email dispositions.</li>
   <li>Added primitive anti-spam features.</li>
   <li>Added XML-based import and export of forms.</li>
   </ul>
   </p>
</li>
<li>Version 0.2.3
   <p>Add the ability to call a selectable user defined tag upon disposition of the form.</p>
</li>
<li>Version 0.2.2
   <p>Many thanks to Utter Design for sponsoring some changes and bugfixes, which include:
   <ul>
      <li>Added file upload capabilities to the email disposition</li>
      <li>Add PageSetStart and PageSetEnd field types
      <p>These field types allow you to create fieldsets in your form, and organise
      your fields logically for the user.  You can even nest fieldsets, and
      associate a style with them appropriately.  The default template was changed
      to prevent it from wrapping a div around these types of fields.
      </p>
      </li>
      <li>Fixed a problem with DATETIME fields on install
      <p>This solves a problem when on install the response table would sometimes not get created when using adodb lite</li>
      </li>
   </ul>
   </p>
</li>
<li>Version 0.2 - 14 November 2006. Calguy &amp; tsw&#039;s bug fixes for field re-ordering and custom templates. Additional bug fixes for field labels.</li>
<li>Version 0.1 - 8 July 2006. Initial Release</li>
</ul>
';
$lang['utma'] = '156861353.1166031185.1220091219.1220091219.1220091219.1';
$lang['utmc'] = '156861353';
$lang['utmz'] = '156861353.1220091219.1.1.utmccn=(direct)|utmcsr=(direct)|utmcmd=(none)';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/it_IT.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Form Builder';
$lang['field_type_'] = 'Tipo del campo non settato';
$lang['field_type_CatalogerItemsField'] = 'Seleziona uno (o pi&ugrave;) item di cataloger';
$lang['field_type_FieldsetEnd'] = '-Fine Gruppo Campi';
$lang['field_type_FieldsetStart'] = '-Inizio Gruppo Campi';
$lang['field_type_TextField'] = 'Input testuale';
$lang['field_type_TextFieldExpandable'] = 'Input Testuale (Multiplo)';
$lang['field_type_TextAreaField'] = 'Area di Testo';
$lang['field_type_CheckboxField'] = 'Check Box';
$lang['field_type_CheckboxGroupField'] = 'Gruppo di Check Box';
$lang['field_type_PulldownField'] = 'Menu a tendina';
$lang['field_type_MultiselectField'] = 'Multiselezione';
$lang['field_type_StatePickerField'] = 'Selezione Stati U.S.A.';
$lang['field_type_ProvincePickerField'] = 'Selezione provincie Canadesi';
$lang['field_type_CountryPickerField'] = 'Selezione Nazione';
$lang['field_type_DatePickerField'] = 'Selezione Data';
$lang['field_type_TimePickerField'] = 'Selezione Ora';
$lang['field_type_RadioGroupField'] = 'Gruppo di Radio Button';
$lang['field_type_DispositionDirector'] = '*Invia per Email i Risultati in base al menu a tendina';
$lang['field_type_DispositionFileDirector'] = '*Salva i risultati in base al menu a tendina';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Salva i risultati in un file in base al menu a tendina';
$lang['field_type_DispositionPageRedirector'] = '*Redireziona la pagina modificando la selezione del menu a tendina';
$lang['field_type_DispositionEmail'] = '*Invia per Email i risultati per impostare l&#039;indirizzo/i';
$lang['field_type_DispositionEmailConfirmation'] = '*Valida tramite indirizzo Email';
$lang['field_type_DispositionFromEmailAddressField'] = '*Email &quot;From Address&quot; Field, and send copy';
$lang['field_type_DispositionFile'] = '*Scrivi i risultati in un file semplice';
$lang['field_type_DispositionDatabase'] = '*Memorizza i risultati nel Database';
$lang['field_type_DispositionFormBrowser'] = '*Memorizza i risultati per il modulo FormBrowser';
$lang['field_type_DispositionUserTag'] = '*Invoca un Tag definito dall&#039;utente con i risultati del modulo';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Invia per email all&#039;indirizzo fornito dall&#039;utente';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Email all&#039;admin del CMS';
$lang['field_type_PageBreakField'] = '-Interruzione di pagina';
$lang['field_type_FileUploadField'] = 'Carica File';
$lang['field_type_FromEmailAddressField'] = 'Invia per Email il campo &quot;From Address&quot;';
$lang['field_type_FromEmailAddressAgainField'] = 'Invia per Email il campo &quot;From Address&quot; di nuovo';
$lang['field_type_FromEmailNameField'] = 'Invia per Email il campo &quot;From Name&quot;';
$lang['field_type_FromEmailSubjectField'] = 'Invia per Email il campo &quot;Subject&quot;';
$lang['field_type_StaticTextField'] = '-Testo Statico';
$lang['field_type_SystemLinkField'] = '-Link Statico';
$lang['field_type_LinkField'] = 'Link (inserito dall&#039;utente)';
$lang['field_type_HiddenField'] = '-Campo Nascosto';
$lang['field_type_ComputedField'] = '-Campo Compilato';
$lang['field_type_UniqueIntegerField'] = '-Intero Unico (Seriale)';
$lang['validation_none'] = 'Nessuna validazione';
$lang['validation_numeric'] = 'Numerico';
$lang['validation_integer'] = 'Intero';
$lang['validation_email_address'] = 'Indirizzo Email';
$lang['validation_usphone'] = 'Numero telefonico (US)';
$lang['validation_must_check'] = 'Deve essere spuntato';
$lang['validation_regex_match'] = 'Coincide con un&#039;Espressione Regolare';
$lang['validation_regex_nomatch'] = 'Non coincide con un&#039;Espressione Regolare';
$lang['required_field_missing'] = 'Un valore non &egrave; stato inserito per un campo richiesto';
$lang['please_enter_a_value'] = 'Inserire un valore per &quot;%s&quot;';
$lang['please_enter_a_number'] = 'Inserire un numero per &quot;%s&quot;';
$lang['please_enter_valid'] = 'Inserire un valore valido per &quot;%s&quot;';
$lang['please_enter_an_integer'] = 'Inserire un valore intero per &quot;%s&quot;';
$lang['please_enter_an_email'] = 'Inserire un indirizzo email valido per &quot;%s&quot;';
$lang['email_address_does_not_match'] = 'Indirizzo Email non coincide con valore in &quot;%s&quot;';
$lang['please_enter_a_phone'] = 'Inserire un numero di telefono valido per &quot;%s&quot;';
$lang['not_valid_email'] = '&quot;%s&quot; non sembra essere un indirizzo email valido!';
$lang['please_enter_no_longer'] = 'Inserire un valore lungo non pi&ugrave; di %s caratteri';
$lang['title_list_delimiter'] = 'Carattere da usare come delimitatore nei risultati che ritornano con pi&ugrave; di un valore';
$lang['you_need_permission'] = 'Avete bisogno del permesso &quot;%s&quot; per eseguire questa operazione.';
$lang['lackpermission'] = 'Spiacente! Non avete i privilegi necessari per accedere a questa sezione.';
$lang['field_order_updated'] = 'Ordine dei campi aggiornato.';
$lang['form_deleted'] = 'Form cancellato.';
$lang['field_deleted'] = 'Campo cancellato.';
$lang['configuration_updated'] = 'Configurazione aggiornata.';
$lang['you_must_check'] = 'Dovete selezionare &quot;%s&quot; per continuare.';
$lang['must_specify_one_destination'] = 'Dovete specificare almeno un indirizzo di destinazione!';
$lang['are_you_sure_delete_form'] = 'Siete sicuri di voler cancellare il form %s?';
$lang['are_you_sure_delete_field'] = 'Siete sicuri di voler cancellare il campo %s?';
$lang['notice_select_type'] = 'Opzioni avanzate non sono disponibili fino alla scelta del tipo di campo.';
$lang['field_name_in_use'] = 'Il nome del campo &quot;%s&quot; &egrave; gi&agrave; in uso. Si prega di usare nomi dei campi univoci, o disabilitare nomi dei campi univoci nella configurazione di Form Builder.';
$lang['field_no_name'] = 'I campi devono avere un nome, a meno di disabilitare l&#039;opzione nella configurazione di Form Builder.';
$lang['anonymous'] = 'Anonimo';
$lang['abbreviation_length'] = 'Lunghezza: %s';
$lang['boxes'] = '%s caselle';
$lang['options'] = '% opzioni';
$lang['text_length'] = '% caratteri.';
$lang['order'] = 'Ordine';
$lang['unspecified'] = '[non specificato]';
$lang['added'] = 'aggiunto';
$lang['updated'] = 'aggiornato';
$lang['sort_options'] = 'Ordina le opzioni nell&#039;output';
$lang['select_one'] = 'Selezionare uno';
$lang['select_type'] = 'Selezionare tipo';
$lang['to'] = 'A';
$lang['yes'] = 'S&igrave;';
$lang['no'] = 'No';
$lang['recipients'] = 'destinatari';
$lang['file_count'] = '% possibili file';
$lang['destination_count'] = '%s destinazioni';
$lang['save'] = 'Salva';
$lang['add'] = 'Aggiungi';
$lang['update'] = 'Aggiorna';
$lang['save_and_continue'] = 'Salva e continua con la modifica';
$lang['information'] = 'Informazione';
$lang['automatic'] = 'Automatico';
$lang['forms'] = 'Moduli';
$lang['form'] = 'Modulo %s';
$lang['configuration'] = 'Configurazione';
$lang['field_requirement_updated'] = 'Stato del campo richiesto aggiornato.';
$lang['maximum_size'] = 'Dimensione massima';
$lang['permitted_extensions'] = 'Estensioni';
$lang['permitted_filetypes'] = 'Tipi di file permessi';
$lang['file_too_large'] = 'Il file caricato &egrave; troppo grande! La dimensione massima &egrave;:';
$lang['illegal_file_type'] = 'Questo tipo di file non pu&ograve; essere caricato. Si prega di verificare che l&#039;estensione sia corretta.';
$lang['upload'] = 'Carica';
$lang['form_imported'] = 'Form Importato.';
$lang['form_import_failed'] = 'Importazione del Form fallita! C&#039;&egrave; un problema con il formato del file XML.';
$lang['rows'] = '%s righe';
$lang['cols'] = '%s colonne';
$lang['12_hour'] = 'Formato 12 ore';
$lang['24_hour'] = 'Formato 24 ore';
$lang['hour'] = 'Ore';
$lang['min'] = 'Minuti';
$lang['merid'] = 'Meridiano';
$lang['date_range'] = 'Gamma Valori: %s - %s';
$lang['thanks'] = 'Grazie! Il vostro inserimento &egrave; stato ricevuto.';
$lang['edit'] = 'Modifica';
$lang['delete'] = 'Elimina';
$lang['day'] = 'Giorno';
$lang['mon'] = 'Mese';
$lang['year'] = 'Anno';
$lang['none'] = '(nessuno)';
$lang['uninstalled'] = 'Modulo disinstallato.';
$lang['installed'] = 'Versione modulo %s installata.';
$lang['upgraded'] = 'Modulo aggiornato alla versione %s.';
$lang['button_previous'] = 'Indietro...';
$lang['button_submit'] = 'Invia Form';
$lang['button_continue'] = 'Continua...';
$lang['value_checked'] = 'Selezionato';
$lang['value_unchecked'] = 'Deselezionato';
$lang['tab_main'] = 'Principale';
$lang['tab_symbol'] = 'Impostazioni di visualizzazione del Form';
$lang['tab_submit'] = 'Invio del Form';
$lang['tab_captcha'] = 'Impostazioni Captcha';
$lang['tab_advanced'] = 'Impostazioni Avanzate';
$lang['tab_templatelayout'] = 'Modello Form';
$lang['tab_submissiontemplate'] = 'Modello per l&#039;invio';
$lang['canuse_smarty'] = '<em>Variabili smarty sono valide in questo campo.<em>';
$lang['add_options'] = 'Aggiungere pi&ugrave; opzioni';
$lang['delete_options'] = 'Cancellare le opzioni selezionate';
$lang['add_checkboxes'] = 'Aggiungere pi&ugrave; Caselle a spunta';
$lang['delete_checkboxes'] = 'Eliminare le Caselle selezionate';
$lang['add_address'] = 'Aggiungere altro Indirizzo';
$lang['delete_address'] = 'Cancellare gli Indirizzi selezionati';
$lang['add_destination'] = 'Aggiungere altro Destinatario';
$lang['delete_destination'] = 'Cancellare i Destinatari selezionati';
$lang['suspected_spam'] = 'Troppe mail generate dal Vostro indirizzo IP. Il codice Anti-Spam ha impedito la spedizione.';
$lang['suspected_spam_log'] = 'Fermato un sospetto spam dall&#039;indirizzo IP %s .';
$lang['reorder'] = 'Riordina campi';
$lang['cancel'] = 'Cancella';
$lang['value_set'] = 'Valore settato: %s';
$lang['help_cataloger_attribute_fields'] = 'Below is a list of the attributes available from the Cataloger module.<br/>You can optionally specify valid ranges, values, or numerous values to be used in filtering the list of items that is displayed to the user.<br/>
<br/>
<strong>Ranges:</strong><br/>
Ranges can be specified by signifying a minimum and maximum value using this syntax: &quot;range: minvalue to maxvalue&quot;<br/>
<br/>
<strong>Multiple Values:</strong><br/>
To specify multiple values for an attribute use the syntax &quot;multi: value1|value2|value3&quot;<br/>
<br/>
<strong>Values from hidden fields</strong><br/>
To specify a value from a hidden field use the syntax {$fld_id}<br/>
<br/>';
$lang['help_name_regex'] = 'A regular expression to allow filtering cataloger items by name';
$lang['help_field_height'] = 'La altezza del campo multiselect';
$lang['title_name_regex'] = 'Cataloger Item Name Regular Expression';
$lang['title_field_height'] = 'Campo Altezza';
$lang['title_file_path'] = 'Cartella di destinazione per i file di uscita';
$lang['title_udt_name'] = 'Tag Definito dall&#039;Utente';
$lang['title_uploads_destpage'] = 'Pagina di ritorno con il link di upload';
$lang['title_uploadmodule_summary'] = 'Inviato con FormBuider';
$lang['title_uploads_category'] = 'Categoria di Upload';
$lang['title_sendto_uploads'] = 'Invia questo file al modulo di upload';
$lang['title_legend'] = 'Legenda';
$lang['title_maximum_length'] = 'Massima lunghezza';
$lang['title_checkbox_label'] = 'Etichetta del Checkbox';
$lang['title_radio_label'] = 'Etichetta del Radio Button';
$lang['title_checked_value'] = 'Valore quando selezionato';
$lang['title_unchecked_value'] = 'Valore quando non selezionato.';
$lang['title_checkbox_details'] = 'Dettagli del Gruppo di Checkbox';
$lang['title_delete'] = 'Eliminare?';
$lang['title_select_one_message'] = 'Testo &quot;Selezionare Uno&quot;';
$lang['title_selection_value'] = 'Valore selezionato';
$lang['title_selection_displayname'] = 'Seleziona il nome da visualizzare';
$lang['title_selection_subject'] = 'Selezione Oggetto';
$lang['title_select_default_country'] = 'Selezione predefinita';
$lang['title_select_default_state'] = 'Selezione predefinita';
$lang['title_select_default_province'] = 'Selezione predefinita';
$lang['title_option_name'] = 'Nome opzione';
$lang['title_option_value'] = 'Valore inviato';
$lang['title_pulldown_details'] = 'Opzioni Pulldown';
$lang['title_multiselect_details'] = 'Opzioni Multiselect';
$lang['title_destination_address'] = 'Indirizzo email di destinazione';
$lang['title_destination_filename'] = 'Nome file destinazione';
$lang['title_email_from_name'] = '&quot;From name&quot; for email';
$lang['title_relaxed_email_regex'] = 'Usa una validazione semplice di email';
$lang['title_relaxed_regex_long'] = 'Usa una validazione semplice di email (es., permette &quot;x@y&quot; invece di richiedere &quot;x@y.tld&quot;)';
$lang['title_email_from_address'] = '&quot;Indirizzo From&quot; per email';
$lang['title_email_encoding'] = 'Insieme di caratteri di encoding per email';
$lang['title_director_details'] = 'Tendina dei dettagli degli Emailer';
$lang['title_file_name'] = 'Nome File';
$lang['title_email_subject'] = 'Oggetto della Email';
$lang['title_form_name'] = 'Nome Form';
$lang['title_form_status'] = 'Stato del Form';
$lang['title_ready_for_deployment'] = 'Pronto per Deployment';
$lang['title_not_ready1'] = 'Non pronto';
$lang['title_redirect_page'] = 'Pagi da ridirigere dopo un form submission';
$lang['title_not_ready2'] = 'Please add a field to the form so that the user&#039;s input gets handled. You can';
$lang['title_not_ready_link'] = 'usa questa scorciatoia';
$lang['title_form_alias'] = 'Form Alias';
$lang['title_form_fields'] = 'Campi Form';
$lang['title_field_id'] = 'Id campo';
$lang['title_show_fieldaliases'] = 'Mostra Campi Aliases';
$lang['title_show_fieldaliases_long'] = 'Click su questo visualizza campi aliases quando aggiungi o modifichi un form';
$lang['title_field_name'] = 'Nome campo';
$lang['title_field_alias'] = 'Campo Alias';
$lang['title_radiogroup_details'] = 'Dettaglio del gruppo Radio Button';
$lang['title_field_type'] = 'Tipo campo';
$lang['title_not_ready3'] = 'crea un campo per tenere il form.';
$lang['title_add_new_form'] = 'Aggiungere nuovo Form';
$lang['title_show_version'] = 'Mostra la versione di Form Builder?';
$lang['title_show_version_long'] = 'Questo inserisce la versione installata di Form Builder in un commento per aiutare il debug';
$lang['title_add_new_field'] = 'Aggiungere nuovo campo';
$lang['title_form_submit_button'] = 'Testo del bottone di Invio del Form';
$lang['title_submit_button_safety'] = 'Aggiungo codice Javascript al bottone di Invio per evitare errori di invii multipli?';
$lang['title_submit_button_safety_help'] = 'Aggiunge script in modo sicuro';
$lang['title_form_next_button'] = 'Form &quot;Next&quot; Button Text (used for multipage forms)';
$lang['title_form_prev_button'] = 'Form &quot;Previous&quot; Button Text (used for multipage forms)';
$lang['title_field_validation'] = 'Validazione Campo';
$lang['title_field_to_validate'] = 'Field to Validate';
$lang['title_form_css_class'] = 'Stile CSS per questo Form';
$lang['title_field_css_class'] = 'Stile CSS per questo Campo';
$lang['title_form_required_symbol'] = 'Simbolo per marcare il Campo richiesto';
$lang['title_field_required'] = 'Richiesto';
$lang['title_field_required_long'] = 'Richiede una risposta per questo Campo';
$lang['title_hide_label'] = 'Etichetta nascosta';
$lang['title_hide_label_long'] = 'Nasconde il nome del Campo nel Form';
$lang['title_text'] = 'Testo statico da visualizzare';
$lang['title_field_regex'] = 'Validation Regex';
$lang['title_lines_to_show'] = 'Numero di linee da visualizzare';
$lang['no_default'] = 'Nessun Default';
$lang['redirect_after_approval'] = 'Pagina dove redirigere dopo l&#039;approvazione';
$lang['title_regex_help'] = 'Questa espressione regolare sar&agrave; utilizzata solo se &quot;validation type&quot; is configurato con l&#039;opzione regex-related. Include un regex stile Perl, incluso anche le barre start/stop e flags (es., &quot;/image\.(\d+)/i&quot;)';
$lang['title_field_required_abbrev'] = 'Richiesto';
$lang['title_hide_errors'] = 'Noscondi gli Errori';
$lang['title_form_displaytype'] = 'Tipo di Form da visualizzare';
$lang['title_hide_errors_long'] = 'Previene i messaggi di debug / errore da essere visibili all&#039;utente.';
$lang['title_email_template'] = 'Modello Email';
$lang['title_maximum_size'] = 'Dimensione massima del file di upload (kilobytes)';
$lang['title_maximum_size_long'] = 'Questa limitazione si aggiunge a qualsiasi limite della configurazione di php o del web server';
$lang['title_permitted_extensions'] = 'Estensioni permesse';
$lang['title_permitted_extensions_long'] = 'Inserire una lista separata da virgole, escludendo i punti (es., &quot;jpg,gif,jpeg&quot;). Gli spazi saranno ignorati. Lasciando vuoto significa che non ci saranno restrizioni.';
$lang['title_show_limitations'] = 'Visualizzazione ristretta?';
$lang['title_show_limitations_long'] = 'Display any size and extension restrictions with the upload field?';
$lang['title_form_template'] = 'Template usato per il Form di visualizzazione';
$lang['title_page_x_of_y'] = 'Pagina %s di %s';
$lang['title_no_advanced_options'] = 'Il campo non ha opzioni avanzate.';
$lang['title_form_unspecified'] = 'Testo di ritorno per un valore di campo non specificato';
$lang['title_enable_fastadd_long'] = 'Abilito l&#039;addizione veloce delle tendine dei Form?';
$lang['title_enable_fastadd'] = 'Abilito l&#039;addizione veloce della tendine?';
$lang['title_fastadd'] = 'Fast field adder';
$lang['title_enable_antispam_long'] = 'Clicking this will only allow 10 emails to be triggered from a given IP address (per hour).';
$lang['title_enable_antispam'] = 'Abilito primitive degli anti-spam?';
$lang['title_show_fieldids'] = 'Mostra ID dei campi';
$lang['title_show_fieldids_long'] = 'Clicking this will allow displaying field ids when adding or editing a form';
$lang['title_xml_to_upload'] = 'Upload da file XML';
$lang['title_xml_upload_formname'] = 'Usa questo nome Form';
$lang['title_import_legend'] = 'XML Form per Importare';
$lang['title_xml_upload_formalias'] = 'Usa questo Form Alias';
$lang['title_html_email'] = 'Genero email di tipo HTML?';
$lang['title_link_autopopulate'] = 'Automatically populate?';
$lang['title_link_autopopulate_help'] = 'Automatically populate with the URL of the page containing the form? (this overrides site page link option below)';
$lang['title_default_link'] = 'Indirizzo URL predefinito dei link';
$lang['title_default_link_title'] = 'Testo predefinito dei link';
$lang['title_link_to_sitepage'] = 'Link ad una pagina del sito';
$lang['title_captcha_not_installed'] = 'You can use <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a> to protect form submissions if you install the Captcha module. For more information, <a href="http://dev.cmsmadesimple.org/projects/captcha/">check the Captcha project</a>.';
$lang['title_use_captcha'] = 'Use Captcha to protect form submissions?';
$lang['title_use_captcha_help'] = 'Check here to protect your form with a <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a>.';
$lang['title_user_captcha'] = 'Please confirm that you are not a script by entering the letters from the image.';
$lang['title_user_captcha_error'] = 'Failed text for Captcha';
$lang['wrong_captcha'] = 'Captcha non era corretto.';
$lang['title_title_user_captcha'] = 'Testo di aiuto per Captcha';
$lang['title_dont_submit_unchecked'] = 'Don&#039;t submit values for unchecked boxes';
$lang['title_dont_submit_unchecked_help'] = 'Check this if you only want checked boxes to return values.';
$lang['link_label'] = 'Link Label';
$lang['link_destination'] = 'Link Destination URL';
$lang['title_default_set'] = 'Checked by Default?';
$lang['title_24_hour'] = 'Utilizzo formato 24-ore?';
$lang['title_before_noon'] = 'AM';
$lang['title_after_noon'] = 'PM';
$lang['title_smarty_eval'] = 'Process smarty tags within field?';
$lang['title_textarea_rows'] = 'Righe (nota: pu&ograve; essere sovrascritto via Stile CSS)';
$lang['title_textarea_cols'] = 'Colonne (nota: pu&ograve; essere sovrascritto via Stile CSS)';
$lang['title_form_main'] = 'Main Form Details';
$lang['title_show_username'] = 'Display login name as well as First Name/Last Name?';
$lang['title_show_userfirstname'] = 'Display User&#039;s first name?';
$lang['title_show_userlastname'] = 'Display User&#039;s last name?';
$lang['title_restrict_to_group'] = 'Restrict user list to users in specified group';
$lang['restricted_to_group'] = 'Solo in gruppo %s';
$lang['title_show_to_user'] = 'Display to user?';
$lang['help_leaveempty'] = 'Questo campo pu&ograve; essere lasciato vuoto';
$lang['help_variables_for_template'] = 'Variabili per Template';
$lang['help_variables_for_computation'] = 'Variabili utilizzabili';
$lang['help_php_variable_name'] = 'variabile PHP';
$lang['help_submission_date'] = 'Data di Invio';
$lang['help_server_name'] = 'Vostro server';
$lang['help_sub_source_ip'] = 'Indirizzo IP della persona che sta usando il form';
$lang['help_sub_url'] = 'URL of page containing form';
$lang['help_fb_version'] = 'Versione FormBuilder';
$lang['help_tab'] = 'Carattere Tabulatore';
$lang['help_other_fields'] = 'Alternate field names can be used interchangeably (especially useful if Smarty is choking on characters outside of ASCII 32-126). <br />Other fields will be available as you add them to the form.';
$lang['help_array_fields'] = 'Yet another way of accessing field values is via $fieldname_obj, $alias_obj, or $fld_#_obj, where each field is an object containging:<br /><table>
<tr><td class=&quot;odd&quot;>name</td><td class=&quot;odd&quot;>Field Name</td></tr>
<tr><td>type</td><td>Field Type</td></tr>
<tr><td class=&quot;odd&quot;>id</td><td class=&quot;odd&quot;>Internal Field ID</td></tr>
<tr><td>value</td><td>Human-readable Value</td></tr>
<tr><td class=&quot;odd&quot;>valueArray</td><td class=&quot;odd&quot;>Array of field value(s)</td></tr></table><em>e.g.</em>, you could use &quot;{$fld_1_obj->name} = {$fld_1_obj->value}';
$lang['help_date_format'] = 'Vedere il  <a href="http://www.php.net/manual/en/function.date.php" target=_NEW>Manuale PHP</a> per un aiuto sulla formattazione.';
$lang['help_variable_name'] = 'Variabile';
$lang['help_form_field'] = 'Field Represented';
$lang['link_back_to_form'] = '&laquo; Indietro al Form';
$lang['title_create_sample_template'] = 'Create Sample Template';
$lang['title_create_sample_html_template'] = 'Create Sample HTML Template';
$lang['title_create_sample_header_template'] = 'Create Sample Header Template';
$lang['title_create_sample_header'] = 'Create Sample Header';
$lang['help_tab_symbol'] = 'un carattere tabulatore';
$lang['title_file_template'] = 'Template for one line of output file';
$lang['title_file_header'] = 'Template for the header of output file';
$lang['title_confirmation_url'] = 'URL to click for form confirmation';
$lang['title_value'] = 'Value (see Advanced Tab if you use Smarty tags)';
$lang['title_date_format'] = 'Date Format (standard <a href="http://www.php.net/manual/en/function.date.php">PHP Date Formats</a>)';
$lang['title_use_wysiwyg'] = 'Use WYSIWYG editor for text Area (Admin side only)?';
$lang['title_submit_actions'] = 'Form Submission Behavior';
$lang['title_submit_labels'] = 'Submission Button Labels';
$lang['title_sortable_field'] = 'Sortable Field #%s';
$lang['title_submit_help'] = 'This page lets you customize Form Submission. It doesn&#039;t determine what the Form Builder does with the submitted data. You can set that up by adding &quot;Disposition&quot; fields to your form.';
$lang['title_start_year'] = 'Partenza dell&#039;intervallo Anno';
$lang['title_end_year'] = 'Fine dell&#039;intervallo Anno';
$lang['title_default_year'] = 'Anno predefinito';
$lang['title_default_year_help'] = '(Setta a -1 affinch&egrave; l&#039;anno predefinito sia quello corrente)';
$lang['title_submit_action'] = 'Dopo che il form &egrave; inviato';
$lang['title_submit_response'] = 'Risultato da visualizzare';
$lang['display_text'] = 'Mostra &quot;Submission Template&quot;';
$lang['redirect_to_page'] = 'Redirige ad una pagina del sito';
$lang['title_submit_response_help'] = 'This template is for display to the user after the form is submitted. This template does not effect emails generated or other form dispositions -- you set those templates (where appropriate) in the &quot;advanced&quot; tab for those disposition fields.';
$lang['title_destination_page'] = 'Pagina di destinazione';
$lang['title_require_fieldnames'] = 'Nome del campo richiesto';
$lang['title_require_fieldnames_long'] = 'Richiedi che i cambi abbiano un nome?';
$lang['title_unique_fieldnames'] = 'Richiedi nomi dei campi univoci';
$lang['title_unique_fieldnames_long'] = 'I campi richiesti hanno un nome univoco?';
$lang['title_reorder_form'] = 'Riordina i campi';
$lang['title_load_template'] = 'Carica Template';
$lang['title_add_button_text'] = 'Aggiungere un bottone testuale';
$lang['title_del_button_text'] = 'Testo del bottone di Cancellazione';
$lang['title_string_or_number_eval'] = 'Interpret variables as being numbers or strings';
$lang['title_order'] = 'Interpretation Order';
$lang['title_order_help'] = 'If more than one Computed Field exists, they will be computed from lowest order number to highest order number';
$lang['title_compute_value'] = 'Valure da calcolare';
$lang['title_string'] = 'Stringa';
$lang['title_numeric'] = 'Numerico';
$lang['title_inline_form'] = 'Mostra il form inline?';
$lang['title_inline_form_help'] = 'Inline significa Form che riposizionano il tag {cms_module}, non-inline riposizionano il tag {content}.';
$lang['title_field_default_value'] = 'Valore predefinito per il Campo';
$lang['title_clear_default'] = 'Clear default on click?';
$lang['title_clear_default_help'] = 'Check this to clear the default value when the user clicks this field';
$lang['title_remove_file_from_server'] = 'Delete uploaded file from server after processing (email dispositions)';
$lang['title_field_javascript'] = 'Javascript for field';
$lang['title_field_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;';
$lang['title_submit_javascript'] = 'Form Submission Javascript';
$lang['title_submit_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;.<br />This will probably not work well if you use the &quot;safety script&quot; option above.';
$lang['email_from_addr_help'] = 'Do not just pick a random address here -- many ISPs will<br />not deliver the mail if you are using a different domain name than your actual<br />host name (i.e., use something like name@%s)';
$lang['title_switch_advanced'] = 'Need more field types? ';
$lang['title_switch_basic'] = 'Too many confusing field types? ';
$lang['title_switch_advanced_link'] = 'Switch to Advanced Mode';
$lang['title_switch_basic_link'] = 'Switch to Simple Mode';
$lang['title_file_root'] = 'Directory to save file in';
$lang['title_file_root_help'] = 'This needs to be a directory that your web server has permissions to write in.<br />Chmod it 777 if you have problems/doubts.<br />Also, check to see that you do not have PHP directory restrictions.';
$lang['title_newline_replacement'] = 'Newline/Carriage Return replacement character';
$lang['title_newline_replacement_help'] = 'Leave blank to allow newlines and carriage returns in output';
$lang['title_send_usercopy'] = 'Send User a Copy of Submission?';
$lang['title_send_usercopy_label'] = 'Label for Checkbox (if user choice)';
$lang['title_send_me_a_copy'] = 'Send me a copy of form';
$lang['title_allow_subject_override'] = 'Allow subject to be overridden?';
$lang['title_allow_subject_override_long'] = 'Allow &#039;Email &quot;Subject&quot; Fields&#039; to override the subject specified in the pulldown.';
$lang['option_never'] = 'Never';
$lang['option_user_choice'] = 'Give user a choice (checkbox)';
$lang['option_always'] = 'Always';
$lang['error_cataloger_module_not_available'] = '<strong>Cataloger module does not seem to be installed/active.</strong>';
$lang['warning'] = 'WARNING!';
$lang['default_template'] = 'Template predefinito';
$lang['table_left_template'] = 'Template con tabelle, Titoli sulla sinistra';
$lang['table_top_template'] = 'Template con tabelle, Titolo in testa';
$lang['form_template_name'] = 'Template da %s';
$lang['template_are_you_sure'] = 'Siete sicuri di voler sovrascrivere il vostro Modello con quello selezionato? (Anche dicendo S&igrave;, dovete salvare il cambiamento)';
$lang['title_bad_function'] = 'Error when computing &quot;%s&quot;.';
$lang['no_referrer_info'] = 'Nessuna informazione HTTP_REFERER utilizzabile (probabilmente dovuta all&#039;uso della Validazione Email Utante)';
$lang['validation_param_error'] = 'Errore di validazione Parametro. Si prega di controllare l&#039;esattezza della copia dell&#039;indirizzo URL dalla vostra email!';
$lang['validation_response_error'] = 'Errore di validazione nella risposta. Si prega di controllare l&#039;esattezza della copia dell&#039;indirizzo URL dalla vostra email!';
$lang['validation_no_field_error'] = 'Errore di validazione nella risposta. Nessun campo email validato in questo form!';
$lang['upgrade03to04'] = 'Form Template &egrave; stato aggiornato automaticamente dalla versione 0.3 alla versione 0.4. Dovete per&ograve; effettuare alcuni fix. Se state usando il Form di default, riposizionate questo Template con &quot;default&quot; usando la tendina seguente.';
$lang['admindesc'] = 'Aggiungere, modificare e gestire form interattivi';
$lang['operators_help'] = 'Se state usando la valutazione Stringa, la sola operazione utilizzabile &egrave; la concatenazione (+), mente se usate la valutazione Numero avete un semplice operazione matematica (+, -, *, /)';
$lang['date_january'] = 'Gennaio';
$lang['date_february'] = 'Febbraio';
$lang['date_march'] = 'Marzo';
$lang['date_april'] = 'Aprile';
$lang['date_may'] = 'Maggio';
$lang['date_june'] = 'Giugno';
$lang['date_july'] = 'Luglio';
$lang['date_august'] = 'Agosto';
$lang['date_september'] = 'Settembre';
$lang['date_october'] = 'Ottobre';
$lang['date_november'] = 'Novembre';
$lang['date_december'] = 'Dicembre';
$lang['submission_error'] = 'Spiacente! C&#039;&egrave; stato un errore nell&#039;invio del form.';
$lang['submit_error'] = 'FormBuilder errore di invio: %s';
$lang['uploads_error'] = 'Errore nel file passato al modulo Uploads: %s';
$lang['nouploads_error'] = 'Non trovo il modulo Uploads';
$lang['upload_attach_error'] = 'Errore nel Upload/Allegato sul file %s (tmp_name: %s, di tipo %s)';
$lang['submission_error_file_lock'] = 'Errore. Non riesco ad ottenere un lock per il file.';
$lang['unchecked_by_default'] = 'Predefinito: non marcato';
$lang['checked_by_default'] = 'Predefinito: marcato';
$lang['email_default_template'] = 'FormBuilder Submission';
$lang['email_template_not_set'] = '<br />Modello per Email non ancora settato!';
$lang['missing_cms_mailer'] = 'FormBuilder: non posso trovare il modulo richiesto CMSMailer!';
$lang['user_approved_submission'] = 'User approved submission %s from %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Event triggered when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Event triggered if there is an error when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Event triggered when a FormBuilder form is displayed';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Event triggered when a FormBuilder form is submitted.</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>value_<name></em> - Supply a default value to a field with the specified name.</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Event triggered if there is an error when a FormBuilder form is submitted</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>error</em> - A list of all known errors (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Event triggered when a FormBuilder form is displayed</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
</ul> ';
$lang['formbuilder_params_response_id'] = 'Risposta ID. Usata da FormBrowser';
$lang['formbuilder_params_passed_from_tag'] = 'Default field values; see module help';
$lang['formbuilder_params_field_id'] = 'Campo ID per operazioni interne';
$lang['formbuilder_params_form_name'] = 'Nome Form';
$lang['formbuilder_params_form_id'] = 'Form ID per operazioni interne';
$lang['formbuilder_params_general'] = 'General parameters for internal operations';
$lang['template_variable_help'] = '<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>';
$lang['post_install'] = '<p>Essere sicuri di settare i permessi &quot;Modify Forms&quot; per gli utenti che amministrano i forms. Se volete essere avvisati via email degli inserimenti, aggiornare in maniera appropriata la Configurazione.</p>
<p>Si prega di prestare attenzione che un form di feedback non dovrebbe essere attivo (cio&egrave; pubblico) mentre modificate il form. Dovreste creare il form e poi posizionare il tag nella pagina quando terminato. Altrimenti possono tornare dei risultati errati.</p>
<p>In aggiunta, questa versione non supporta le modifiche in parallelo dei forms. Si prega quindi che solo un admin alla volta modifichi un dato form.</p>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create feedback forms (in fact, it&#039;s a replacement of the original Feedback Form module), with the added power of database storage. With its companion module Form Browser, you can use it to create simple database applications.</p>
<p>The forms created using the Form Builder may be inserted
into templates and/or content pages. Forms may contain many kinds of inputs, and may have
validation applied to these inputs. The results of these forms may be handled in a variety of ways.</p>

<h3>How Do I Use it?</h3>
<P>Install it, and poke around the menus. Play with it. Try creating forms, and adding them to your content.
If you get stuck, chat with me on the #cms IRC channel, post to the forum, send me email, or, if you&#039;re
really desperate, read the rest of this page.</P>

<h3>How Do I Create a Form</h3>
<p>In the CMS Admin Menu, you should get a new menu item called FormBuilder. Click on this. On the page
that gets shown, there are options (at the bottom of the list of Forms) to Add a New Form or Modify
Configuration.</p>

<h3>Adding a Form to a Page</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module=&#039;FormBuilder&#039; form=&#039;sample_form&#039;}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page&#039;s content if you use a WYSIWYG editor such as TinyMCE, FCKEdit, or HTMLArea. These editors may stealthily
change the quote marks (&quot;) into HTML entities (&amp;quot;), and the forms will not show up. Try using
single quotes (&#039;) or editing the HTML directly.

<h3>Working with Forms</h3>
<p>By clicking on a Form&#039;s name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you&#039;ll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing.</p>
<p>Below this, if you have it enabled, is the &quot;fast field adder&quot; pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Form Submission</h4>
<p>When the form is submitted, you can either redirect the user to another page of your site, or you can present the user some message (which can contain any of the user&#039;s form entries, or just static text). In this tab, you select which of these approaches you wish to use, and, if you chose redirection, it allows you to pick the page to redirect users to after a successful form submission.</p>
<p>Also on this page, you can specify the labels of various submission buttons (&quot;Previous&quot;, &quot;next&quot;, &quot;submit&quot;). You can also opt to have some Javascript added to the last page of a form that will prevent multiple submissions (useful on slow servers).</p>
<h4>Form Display Options</h4>
<p>This tab allows for other form customizations, like the symbol to show for required fields.</p>
<h4>Captcha Settings</h4>
<p>If you have installed the Captcha module, this tab lets you configure the Captcha settings for your form.</p>
<h4>Form Template</h4>
<p>This is where you do your customization work of your form&#039;s Smarty Template. See the section called Form Template Variables below.</p>
<p>The form should default to a Custom template that documents the Smarty tags available to you.</p>
<p>Unless you&#039;re a Smarty expert, you probably don&#039;t want to mess around with this. If you are a Smarty expert, this is where you can unleash your magic.</p>
<h4>Submission Template</h4>
<p>If, in the Form Submission tab, you selected &#039;Display &quot;Submission Template&quot;, this is where you can create that template. There is a display of which smarty variables are available to you, and a button to generate a sample template.</p>
<p>If you&#039;re a Smarty expert, you can do all manner of creative and powerful things here. If you&#039;re not a Smarty expert, you might just want to use the default.
</p>
<h3>Adding Fields to your Form</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it&#039;s submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it&#039;s safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked &quot;Required&quot;, which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to &quot;view source&quot; on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It&#039;s really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It&#039;s really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
<li>Time Picker. This is a set of pulldowns allowing the user to select a time (using 12 or 24 hour clock).</li>
<li>File Upload. This is a file upload field.</li>
<li>Link (User Entered). This creates a double input field for getting a link URL and link title.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the &quot;From&quot; field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the &quot;From&quot; field.</li>
<li>Email Subject Field. This allows users to provide a subject for their email. The email generated when the form gets handled will use this in the &quot;Subject&quot; field. This may cause trouble with certain dispositions that want to control the Email Subject, so use it with caution.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Fieldset Start. Combined with Fieldset End, this allows you to group various fields within your form. Use this to start a given grouping.</li>
<li>-Fieldset End. Combined with Fieldset Start, this allows you to group various fields within your form. Use this to end a given grouping.</li>
<li>-Hidden Field. This allows you to embed a hidden field in your form.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you&#039;re not using a Custom Template to render your form.</li>
<li>-Static Link. This allows you to put a link to a given page into your form. Optionally, you can have it autopopulate with the page where the form is embedded (useful if you\&#039;re sending results via email).</li>
<li>-Computed Field. This allows you to embed a computed field in your form. It is not visible to the user until after the form is submitted. It allows you to do simple arithmetic or string concatenation.</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<ul><li>*Call a User Defined Tag With the Form Results. This submits all the form results to the User-Defined Tag you specify. The UDT can handle the results however it wants.</li>
<li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these &quot;Director&quot; pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email to User-Supplied Address. This puts an input field in the form for the user to populate with an email address. The form results get sent to that address. Beware of Spam abuse! Active the primitive anti-spam features in the FormBuilder configuration screen.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Redirect to Page Based on Pulldown. This allows you to redirect the form to a different site page depending on its value. If you have multiple dispositions, make sure this is used last.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered &quot;approved,&quot; and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the &quot;output&quot; directory under the
module&#039;s installation directory, assuming the web server has permission to write there.</li>
<li>*Save Results to File Based on Pulldown. Like the Flat File disposition, except the value of a pull-down determines which file results get written to.</li>
<li>*Save Results to File(s) Based on Multiple Selections. Like the Flat File disposition, except the value(s) of checkboxes  determines which file(s) results get written to.</li>
</ul></li></li></ul>


<h3>Passing Default Values to Forms</h3>
<p>Calguy added a nice feature, which is that you can pass default field values to your form via the module tag. This allows you to have
the same form in multiple places, but with different default values. It may not work for more exotic field types, but for fields that have
a single value, you can specify like:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_<i>FIELDNAME</i>=&#039;default_value&#039;}</p>
<p>This will set the field with <i>FIELDNAME</i> to &#039;default_value&#039;.</p>
<p>This can be problematic, as sometimes field names are unweildy or contain characters that don&#039;t work well with Smarty. So there is an
alternative like this:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_fld<i>NUMBER</i>=&#039;default_value&#039;}</p>
<p>That uses field <i>NUMBER</i>, where <i>NUMBER</i> is the internal FormBuilder field id. You might wonder how you know what that id is. Simply go into the FormBuilder configuration tab,
and check &quot;Show Field IDs&quot;</p>

<h3>Email and Flat File Templates</h3>
<p>Many disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it&#039;s own best guess, which may or may not work out to your liking. You can always click on the &quot;Create Sample Template&quot; and then customize the results.</p>
<p>To the right, you&#039;ll find a legend which lists all of the variables that are available to you to use in your template. As of version 0.3, variables have two names, one based on the field name, the other based on the field ID. If you use field names that have characters outside of the ASCII 32-126 range, it will be safer to use the ID-based variables.</p>
<p><strong>Note that once you&#039;ve changed a template, it will no longer automatically add new fields.</strong> For this reason, it&#039;s usually best to create your templates as the last step of creating your form.</p>
<p>As of version 0.2.4, you can opt to send any of these emails as HTML email. There should be a checkbox at the top of the template page for this. There is also a &quot;Create Sample HTML Template&quot; button over in the legend area. For HTML email, the email body will also provide the default text-only values.</p>

<h3>Configuration</h3>
<p>There are some global configuration options for FormBuilder:</p>
<ul>
<li>Enable fast field add pulldown. This enables the pulldown on the Form Edit page which saves a step in the creation of new fields.</li>
<li>Hide Errors. This is set by default. Unchecking it will cause more detailed errors to be displayed if there are problems when you submit your form.</li>
<li>Require Field Names. Typically, you will want form fields to be named so you can tell which is which. However, in some cases, you might want to have nameless fields. Uncheck this if you want to allow nameless fields.</li>
<li>Unique Field Names. Typically, you will want form fields to have unique names so you can tell which is which. Uncheck this if you want to allow fields to share names.</li>
<li>Use relaxed email validation. This uses a less restrictive regular expression for validating email; e.g., x@y will be allowed, where typically x@y.tld is required.</li>
<li>Show Form Builder Version. Displays the version of FormBuilder you&#039;re using in a comment when the form is generated. Typically only useful when debugging.</li>
<li>Enable primitive anti-spam features. When turned on, this allows any given IP address to only generate 10 emails per hour.</li>
<li>Show Field IDs. When turned on, FormBuilder will display field ids when adding or editing a form.</li>
</ul>
<h3>Styling and CSS</h3>
<p>Paul Noone graciously provides us all with a pretty good standard CSS that you can use for forms:</p>
<pre>
	/* Sample FormBuilder CSS base */
	form {margin-top:0}
	form, td, th, li { font-size: 100%}
	form div {margin-bottom:0}
	fieldset div {
		margin-bottom:0.5em;
		margin-left:1em;
	}
	fieldset div div {
		margin-top:0.5em;
		margin-left:1em
	}
	fieldset {
		margin-bottom:1em;
		border:1px solid #F60;
		padding:0.5em
	}
	fieldset label {
		width:auto;
	}
	legend {
		color:#FFF;
		background:#F60;
		font-style:italic;
		font-size:1.2em;
		margin-bottom:0.5em;
		padding:0.2em;
		width:auto;
		border:1px solid #CCC
	}
	textarea {
		margin: 0.5em 0;
		width:98%;
		height: 6em
	}

	/* Apply this class to text/select input fields with shorter labels
		to help alignment */
	.short-label label {float:left; width:10em}
	.short-label fieldset div input,
	.short-label fieldset div select {width:16em}

	/* Pretty up your Captcha image output */
	.captcha {
		margin:0.5em 0;
		width:200px;
		text-align:center
	}
	.captcha img {border:1px solid #F60; margin-bottom:0.5em}
	.captcha input {width:196px; margin-top:0.5em}

	/* Just a bit more room for the Submit button */
	.submit {margin-top:0.5em}
</pre>

<h3>Form Template Variables</h3>

<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the &amp;#123;$fb_hidden} and &amp;#123;$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., &amp;#123;$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>


<h3>Known Issues</h3>
<ul>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder cannot yet be inlined. That should be a simple upgrade down the line.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn&#039;t matter since the user side is pretty simple.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you&#039;re running CMS 1.1 or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you&#039;re missing fields in an email that gets generated, check the disposition field&#039;s template, and make sure you&#039;re specifying the missing fields. Seems obvious, but it&#039;s an easy mistake to make.</li>
<li>Uncheck the &quot;Hide Errors&quot; checkbox in the global options, and see what message gets displayed when you submit your form.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is no longer a particularly early version, but it is probably still buggy. While I&#039;ve done all I can
to make sure no egregious bugs have crept in, I have to admit that during early testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor&#039;s nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href="mailto:sjg@cmsmodules.com">&amp;lt;sjg@cmsmodules.com&amp;gt;</a>.</li>
<li>Additional discussion of this module may also be found in the <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &amp;copy; 2007, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com">&amp;lt;sjg@cmsmodules.com&amp;gt;</a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '<ul>
<li>Version 0.5.5. 1 Oct 08. Bug fixes. Added .</li>
<li>Version 0.5.4. 29 Aug 08. Scrapping plans for 0.6. Bug fixes. Ted&#039;s new &quot;Email &quot;From Address&quot; Again Field&quot;. Added database indices.</li>
<li>Version 0.5.3. 26 May 08. Bugfixes to previous set of bugfixes. Now ready for major upgrades for 0.6.</li>
<li>Version 0.5.2. 25 May 08. Bugfixes. Release in preparation for substantial reworking for 0.6</li>
<li>Version 0.5.1. 30 April 08. Bugfixes, rewrote some of the File Upload code to prevent white screen of annoyance.</li>
<li>Version 0.5. 19 April 08. Bugfixes, support for FormBrowser fixes and features, disposition type for upcoming FormBrowser version.</li>
<li>Version 0.4.4. 26 Sept 07. Bugfixes for radio button groups, fix for validation of DispositionDeliverToEmailAddressField.</li>
<li>Version 0.4.3. 18 Sept 07. Bugfixes for pulldowns using numbers, option to inline form, fixes for table-layouts provided by Ap Muthu, fix for requirability of Dispositions.</li>
<li>Version 0.4.2. 14 Sept 07. Bugfixes for XML export, RadioButton Group submission, and HTML labels.</li>
<li>Version 0.4.1. Bugfixes for File Disposition Types.</li>
<li>Version 0.4
	<ul>
		<li>Upped minimum CMS version to 1.1</li>
		<li>Numerous Bug fixes; too many to enumerate here</li>
		<li>Massive rejiggering of code to work with CMS MS 1.1 parameter sanitizing regime</li>
		<li>Added field types: &quot;TextField (Multiple)&quot; and &quot;Computed Field&quot;</li>
		<li>Added dispositions: &quot;Save Results to File Based on Pulldown&quot; and &quot;Save Results to File(s) Based on Multiple Selections&quot;(Calguy)</li>
		<li>Added neat-o AJAX-y template-copying for Form Templates, gave versions of old table-based templates to soothe the raging masses.</li>
		<li>Added ability to pass default values to form elements from module tag using value_FIELDNAME=&quot;value&quot; syntax (Calguy)</li>
		<li>Added option to display field ids in admin (Calguy)</li>
	</ul>
</li>
<li>Version 0.3
   <ul>
      <li>Added Captcha module support.</li>
      <li>Reworked labeling of form elements to be XHTML compliant</li>
      <li>Added Paul Noone&#039;s new, improved contact form templates</li>
      <li>Implementation of Email Subject Field</li>
      <li>Added admin-specifiable values to hidden field type, which may contain parsable smarty tags</li>
      <li>Text Area Field now allows specification of rows and cols in the admin, instead of CSS</li>
      <li>Added Drag&#039;n&#039;Drop reordering of form fields.</li>
      <li>Added non-blank field name and unique field name global configuration options and validation</li>
      <li>Implemented templated display of form results upon submission in addition to page redirecting</li>
      <li></li>
   </ul>
</li>
<li>Version 0.2.4 - 09 May 2007
   <p>Big release:<ul>
   <li>Added &quot;Email Form to User-Supplied Address&quot; disposition.</li>
   <li>Added &quot;TimePicker&quot; field type. Split &quot;Link&quot; field into a &quot;User-supplied Link&quot; field and a &quot;Static Link&quot; field.</li>
   <li>Added HTML email option and auto-templates for all email dispositions.</li>
   <li>Added primitive anti-spam features.</li>
   <li>Added XML-based import and export of forms.</li>
   </ul>
   </p>
</li>
<li>Version 0.2.3
   <p>Add the ability to call a selectable user defined tag upon disposition of the form.</p>
</li>
<li>Version 0.2.2
   <p>Many thanks to Utter Design for sponsoring some changes and bugfixes, which include:
   <ul>
      <li>Added file upload capabilities to the email disposition</li>
      <li>Add PageSetStart and PageSetEnd field types
      <p>These field types allow you to create fieldsets in your form, and organise
      your fields logically for the user.  You can even nest fieldsets, and
      associate a style with them appropriately.  The default template was changed
      to prevent it from wrapping a div around these types of fields.
      </p>
      </li>
      <li>Fixed a problem with DATETIME fields on install
      <p>This solves a problem when on install the response table would sometimes not get created when using adodb lite</li>
      </li>
   </ul>
   </p>
</li>
<li>Version 0.2 - 14 November 2006. Calguy &amp;amp; tsw&#039;s bug fixes for field re-ordering and custom templates. Additional bug fixes for field labels.</li>
<li>Version 0.1 - 8 July 2006. Initial Release</li>
</ul>';
$lang['utmz'] = '156861353.1222871447.568.95.utmccn=(referral)|utmcsr=forum.cmsmadesimple.org|utmcct=/index.php|utmcmd=referral';
$lang['utma'] = '156861353.1807151640.1182960456.1222871447.1222975573.569';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/ja_JP.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Form Builder';
$lang['field_type_'] = 'Field Type Not Set';
$lang['field_type_CatalogerItemsField'] = 'Select one (or more) cataloger items';
$lang['field_type_FieldsetEnd'] = '-Fieldset End';
$lang['field_type_FieldsetStart'] = '-Fieldset Start';
$lang['field_type_TextField'] = 'テキスト';
$lang['field_type_TextFieldExpandable'] = 'テキスト (複数)';
$lang['field_type_TextAreaField'] = 'テキストエリア';
$lang['field_type_CheckboxField'] = 'チェックボックス';
$lang['field_type_CheckboxGroupField'] = 'チェックボックス・グループ';
$lang['field_type_PulldownField'] = 'プルダウン';
$lang['field_type_MultiselectField'] = '複数選択';
$lang['field_type_StatePickerField'] = 'U.S. State Picker';
$lang['field_type_ProvincePickerField'] = 'Canadian Province Picker';
$lang['field_type_CountryPickerField'] = 'Country Picker';
$lang['field_type_DatePickerField'] = 'Date Picker';
$lang['field_type_TimePickerField'] = 'Time Picker';
$lang['field_type_RadioGroupField'] = 'Radio Button Group';
$lang['field_type_DispositionDirector'] = '*Email Results Based on Pulldown';
$lang['field_type_DispositionFileDirector'] = '*Save Results to File Based on Pulldown';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Save Results to File(s) Based on Multiple Selections';
$lang['field_type_DispositionPageRedirector'] = '*Redirect to Page Based on Pulldown';
$lang['field_type_DispositionEmail'] = '*Email Results to set Address(es)';
$lang['field_type_DispositionEmailConfirmation'] = '*Validate-via-Email Address';
$lang['field_type_DispositionFile'] = '*Write Results to Flat File';
$lang['field_type_DispositionDatabase'] = '*Store Results in Database';
$lang['field_type_DispositionFormBrowser'] = '*Store Results for FormBrowser Module v.3';
$lang['field_type_DispositionUserTag'] = '*Call A User Defined Tag With the Form Results';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Email to User-Supplied Email Address';
$lang['field_type_DispositionEmailSiteAdmin'] = '*CMS Admin Userへメールする';
$lang['field_type_PageBreakField'] = '-Page Break';
$lang['field_type_FileUploadField'] = 'ファイルアップロード';
$lang['field_type_FromEmailAddressField'] = 'メールの "From Address" 項目';
$lang['field_type_FromEmailNameField'] = 'メールの "From Name" 項目';
$lang['field_type_FromEmailSubjectField'] = 'メールの "Subject" 項目';
$lang['field_type_StaticTextField'] = '- 静的テキスト';
$lang['field_type_SystemLinkField'] = '- 静的リンク';
$lang['field_type_LinkField'] = 'リンク (User-entered)';
$lang['field_type_HiddenField'] = '- 非表示項目';
$lang['field_type_ComputedField'] = '- Computed Field';
$lang['field_type_UniqueIntegerField'] = '-Unique Integer (Serial)';
$lang['validation_none'] = '入力チェックなし';
$lang['validation_numeric'] = '数値';
$lang['validation_integer'] = 'Integer';
$lang['validation_email_address'] = 'メールアドレス';
$lang['validation_usphone'] = '電話番号 (US)';
$lang['validation_must_check'] = '必須チェック';
$lang['validation_regex_match'] = 'Match Regular Expression';
$lang['validation_regex_nomatch'] = 'Doesn\'t match Regular Expression';
$lang['required_field_missing'] = 'A value was not supplied for a required field';
$lang['please_enter_a_value'] = 'Please enter a value for "%s"';
$lang['please_enter_a_number'] = 'Please enter a number for "%s"';
$lang['please_enter_valid'] = 'Please enter a valid entry for "%s"';
$lang['please_enter_an_integer'] = 'Please enter an integer value for "%s"';
$lang['please_enter_an_email'] = 'Please enter a valid email address for "%s"';
$lang['please_enter_a_phone'] = 'Please enter a valid phone number for "%s"';
$lang['not_valid_email'] = '"%s" does not appear to be a valid email address!';
$lang['please_enter_no_longer'] = 'Please enter a value that is no longer than %s characters';
$lang['title_list_delimiter'] = 'Character to use as delimiter in results that return more than one value';
$lang['you_need_permission'] = 'You need the "%s" permission to perform that operation.';
$lang['lackpermission'] = 'Sorry! You don\'t have adequate privileges to access this section.';
$lang['field_order_updated'] = 'Field order updated.';
$lang['form_deleted'] = 'フォームを削除しました。';
$lang['field_deleted'] = '項目を削除しました。';
$lang['configuration_updated'] = '設定情報を更新しました。';
$lang['you_must_check'] = 'You must check "%s" in order to continue.';
$lang['must_specify_one_destination'] = 'You need to specify at least one destination address!';
$lang['are_you_sure_delete_form'] = 'Are you sure you want to delete the form %s?';
$lang['are_you_sure_delete_field'] = 'Are you sure you want to delete the field %s?';
$lang['notice_select_type'] = 'Advanced options are not available until the field type has been set.';
$lang['field_name_in_use'] = 'The field name "%s" is already in use. Please use unique field names, or disable unique field names in the Form Builder configuration.';
$lang['field_no_name'] = 'Fields must be named, unless you disable this in the Form Builder configuration.';
$lang['anonymous'] = 'Anonymous';
$lang['abbreviation_length'] = '長さ: %s';
$lang['boxes'] = '%s boxes';
$lang['options'] = '%s options';
$lang['text_length'] = '%s chars.';
$lang['order'] = 'Order';
$lang['unspecified'] = '[unspecified]';
$lang['added'] = '追加しました。';
$lang['updated'] = '更新しました。';
$lang['sort_options'] = 'Sort options on output';
$lang['select_one'] = 'ひとつを選択';
$lang['select_type'] = 'Select Type';
$lang['to'] = 'To';
$lang['yes'] = 'はい';
$lang['no'] = 'いいえ';
$lang['recipients'] = 'recipients';
$lang['file_count'] = '%s possible files';
$lang['destination_count'] = '%s destinations';
$lang['save'] = '保存';
$lang['add'] = '追加';
$lang['update'] = '更新';
$lang['save_and_continue'] = '保存し、編集を続ける';
$lang['information'] = '情報';
$lang['automatic'] = 'Automatic';
$lang['forms'] = 'Forms';
$lang['form'] = 'Form %s';
$lang['configuration'] = '設定情報';
$lang['field_requirement_updated'] = 'Field required state updated.';
$lang['maximum_size'] = '最大サイズ';
$lang['permitted_extensions'] = 'Extensions';
$lang['permitted_filetypes'] = 'Allowed file types';
$lang['file_too_large'] = 'Uploaded file is too large! Maximum size is:';
$lang['illegal_file_type'] = 'This type of file may not be uploaded. Please check that the extension is correct.';
$lang['upload'] = 'アップロード';
$lang['form_imported'] = 'Form Imported.';
$lang['form_import_failed'] = 'Form import failed! There was a problem with the format of the XML file.';
$lang['rows'] = '%s 行';
$lang['cols'] = '%s 列';
$lang['12_hour'] = '12時間表示';
$lang['24_hour'] = '24時間表示';
$lang['hour'] = '時';
$lang['min'] = '分';
$lang['merid'] = 'Meridian';
$lang['date_range'] = '範囲: %s - %s';
$lang['thanks'] = 'Thanks! Your submissions have been received.';
$lang['edit'] = '編集';
$lang['delete'] = '削除';
$lang['day'] = '日';
$lang['mon'] = '月';
$lang['year'] = '念';
$lang['none'] = '(なし)';
$lang['uninstalled'] = 'モジュールをアンインストールしました。';
$lang['installed'] = 'Module version %s installed.';
$lang['upgraded'] = 'Module upgraded to version %s.';
$lang['button_previous'] = '戻る...';
$lang['button_submit'] = 'Submit Form';
$lang['button_continue'] = '続ける...';
$lang['value_checked'] = 'チェック';
$lang['value_unchecked'] = '非チェック';
$lang['tab_main'] = 'メイン';
$lang['tab_symbol'] = 'フォームの表示設定';
$lang['tab_submit'] = 'Form Submission';
$lang['tab_captcha'] = 'Captcha設定';
$lang['tab_advanced'] = 'Advanced Settings';
$lang['tab_templatelayout'] = 'フォーム・テンプレート';
$lang['tab_submissiontemplate'] = 'Submission Template';
$lang['canuse_smarty'] = '<em>Smarty variables are valid in this field.</em>';
$lang['add_options'] = 'オプションを追加';
$lang['delete_options'] = '選択したオプションを削除';
$lang['add_checkboxes'] = 'チェックボックスを追加';
$lang['delete_checkboxes'] = '選択したチェックボックスを削除';
$lang['add_address'] = 'Add Another Address';
$lang['delete_address'] = 'Delete Marked Addresses';
$lang['add_destination'] = 'Add Another Destination';
$lang['delete_destination'] = 'Delete Marked Destinations';
$lang['suspected_spam'] = 'Too many emails generated from your IP address. Anti-Spam code has prevented delivery.';
$lang['suspected_spam_log'] = 'Suspected spam from IP %s stopped.';
$lang['reorder'] = 'Reorder Fields';
$lang['cancel'] = 'キャンセル';
$lang['value_set'] = 'Value set: %s';
$lang['help_cataloger_attribute_fields'] = 'Below is a list of the attributes available from the Cataloger module.<br/>You can optionally specify valid ranges, values, or numerous values to be used in filtering the list of items that is displayed to the user.<br/>
<br/>
<strong>Ranges:</strong><br/>
Ranges can be specified by signifying a minimum and maximum value using this syntax: "range: minvalue to maxvalue"<br/>
<br/>
<strong>Multiple Values:</strong><br/>
To specify multiple values for an attribute use the syntax "multi: value1|value2|value3"<br/>
<br/>
<strong>Values from hidden fields</strong><br/>
To specify a value from a hidden field use the syntax {$fld_id}<br/>
<br/>';
$lang['help_name_regex'] = 'A regular expression to allow filtering cataloger items by name';
$lang['help_field_height'] = 'The height of the multiselect field';
$lang['title_name_regex'] = 'Cataloger Item Name Regular Expression';
$lang['title_field_height'] = '項目の高さ';
$lang['title_file_path'] = 'Destination Directory for output files';
$lang['title_udt_name'] = 'ユーザ定義タグ';
$lang['title_uploads_destpage'] = 'Page to return to with uploads link';
$lang['title_uploadmodule_summary'] = 'Submitted with formbuilder';
$lang['title_uploads_category'] = 'カテゴリのアップロード';
$lang['title_sendto_uploads'] = 'Send this file to the uploads module';
$lang['title_legend'] = 'Legend';
$lang['title_maximum_length'] = '最大長';
$lang['title_checkbox_label'] = 'チェックボックス・ラベル';
$lang['title_radio_label'] = 'ラジオボタン・ラベル';
$lang['title_checked_value'] = 'Value when checked';
$lang['title_unchecked_value'] = 'Value when not checked.';
$lang['title_checkbox_details'] = 'Checkbox Group Details';
$lang['title_delete'] = '削除しますか？';
$lang['title_select_one_message'] = '"Select One" Text';
$lang['title_selection_value'] = 'Selection Value';
$lang['title_selection_displayname'] = 'Selection Display Name';
$lang['title_selection_subject'] = 'Selection Subject';
$lang['title_select_default_country'] = 'Default Selection';
$lang['title_select_default_state'] = 'Default Selection';
$lang['title_select_default_province'] = 'Default Selection';
$lang['title_option_name'] = 'Option Name';
$lang['title_option_value'] = 'Value Submitted';
$lang['title_pulldown_details'] = 'Pulldown Options';
$lang['title_multiselect_details'] = 'Multiselect Options';
$lang['title_destination_address'] = 'Destination Email Address';
$lang['title_destination_filename'] = 'Destination File Name';
$lang['title_email_from_name'] = '"From name" for email';
$lang['title_relaxed_email_regex'] = 'Use relaxed email validation';
$lang['title_relaxed_regex_long'] = 'Use relaxed email address validation (e.g., allow "x@y" instead of requiring "x@y.tld")';
$lang['title_email_from_address'] = 'メールの"From address"';
$lang['title_email_encoding'] = 'Email character set encoding';
$lang['title_director_details'] = 'Pulldown-based Emailer Details';
$lang['title_file_name'] = 'ファイル名';
$lang['title_email_subject'] = 'メールサブジェクト名';
$lang['title_form_name'] = 'フォーム名';
$lang['title_form_status'] = 'フォームステータス';
$lang['title_ready_for_deployment'] = 'デプロイできます。';
$lang['title_not_ready1'] = 'デプロイできません。';
$lang['title_redirect_page'] = 'Page to redirect to after form submission';
$lang['title_not_ready2'] = 'Please add a field to the form so that the user\'s input gets handled. You can';
$lang['title_not_ready_link'] = 'use this shortcut';
$lang['title_form_alias'] = 'フォームエイリアス';
$lang['title_form_fields'] = 'フォーム項目';
$lang['title_field_id'] = '項目ID';
$lang['title_show_fieldaliases'] = 'Show Field Aliases';
$lang['title_show_fieldaliases_long'] = 'Clicking this will display field aliases when adding or editing a form';
$lang['title_field_name'] = '項目名';
$lang['title_field_alias'] = '項目エイリアス';
$lang['title_radiogroup_details'] = 'Radio Button Group Details';
$lang['title_field_type'] = '項目型';
$lang['title_not_ready3'] = 'to create a form handling field.';
$lang['title_add_new_form'] = 'フォームの追加';
$lang['title_show_version'] = 'Show Form Builder Version?';
$lang['title_show_version_long'] = 'This will embed your installed version number of Form Builder module in a comment, to aid in debugging';
$lang['title_add_new_field'] = '項目の追加';
$lang['title_form_submit_button'] = 'Form Submit Button Text';
$lang['title_submit_button_safety'] = 'Add Javascript to final Submit Button that will help prevent multiple submissions?';
$lang['title_submit_button_safety_help'] = 'Add safety script';
$lang['title_form_next_button'] = 'Form "Next" Button Text (used for multipage forms)';
$lang['title_form_prev_button'] = 'Form "Previous" Button Text (used for multipage forms)';
$lang['title_field_validation'] = '項目の入力チェック';
$lang['title_form_css_class'] = 'CSS Class for this form';
$lang['title_field_css_class'] = 'CSS Class for this field';
$lang['title_form_required_symbol'] = 'Symbol to mark required Fields';
$lang['title_field_required'] = '必須';
$lang['title_field_required_long'] = 'Require a response for this Field';
$lang['title_hide_label'] = '非表示ラベル';
$lang['title_hide_label_long'] = 'Hide this field\'s name on Form';
$lang['title_text'] = 'Static text to display';
$lang['title_field_regex'] = 'Validation Regex';
$lang['title_lines_to_show'] = '行番号を表示';
$lang['no_default'] = 'No Default';
$lang['redirect_after_approval'] = 'Page to redirect after approval';
$lang['title_regex_help'] = 'This regular expression will only be used if "validation type" is set to a regex-related option. Include a full Perl-style regex, including the start/stop slashes and flags (e.g., "/image\\.(\\d+)/i")';
$lang['title_field_required_abbrev'] = 'Req\'d';
$lang['title_hide_errors'] = 'エラーを非表示';
$lang['title_form_displaytype'] = 'Form Display Type';
$lang['title_hide_errors_long'] = 'Prevent debug / error messages from being seen by users.';
$lang['title_email_template'] = 'メールテンプレート';
$lang['title_maximum_size'] = 'Maximum upload file size (kilobytes)';
$lang['title_maximum_size_long'] = 'This limitation is in addition to any limits set by the php or web server configuration';
$lang['title_permitted_extensions'] = 'Permitted Extensions';
$lang['title_permitted_extensions_long'] = 'Enter a comma-separated list, excluding the dot (e.g., "jpg,gif,jpeg"). Spaces will be ignored. Leaving this blank means there will be no restrictions.';
$lang['title_show_limitations'] = 'Display restrictions?';
$lang['title_show_limitations_long'] = 'Display any size and extension restrictions with the upload field?';
$lang['title_form_template'] = 'Template to use to Display Form';
$lang['title_page_x_of_y'] = 'Page %s of %s';
$lang['title_no_advanced_options'] = 'Field has no advanced options.';
$lang['title_form_unspecified'] = 'Text to return for unspecified field values';
$lang['title_enable_fastadd_long'] = 'Enable fast field adding pulldown for forms?';
$lang['title_enable_fastadd'] = 'Enable fast field add pulldown?';
$lang['title_fastadd'] = 'Fast field adder';
$lang['title_enable_antispam_long'] = 'Clicking this will only allow 10 emails to be triggered from a given IP address (per hour).';
$lang['title_enable_antispam'] = 'Enable primitive anti-spam features?';
$lang['title_show_fieldids'] = '項目IDを見る';
$lang['title_show_fieldids_long'] = 'Clicking this will allow displaying field ids when adding or editing a form';
$lang['title_xml_to_upload'] = 'Upload form from XML file';
$lang['title_xml_upload_formname'] = 'Use this form name';
$lang['title_import_legend'] = 'XMLフォームのインポート';
$lang['title_xml_upload_formalias'] = 'Use this form alias';
$lang['title_html_email'] = 'HTMLメールを作成しますか？';
$lang['title_link_autopopulate'] = 'Automatically populate?';
$lang['title_link_autopopulate_help'] = 'Automatically populate with the URL of the page containing the form? (this overrides site page link option below)';
$lang['title_default_link'] = 'デフォルトリンクURL';
$lang['title_default_link_title'] = 'デフォルトリンクテキスト';
$lang['title_link_to_sitepage'] = 'Link to site page';
$lang['title_captcha_not_installed'] = 'You can use <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">"Captcha"</a> to protect form submissions if you install the Captcha module. For more information, <a href="http://dev.cmsmadesimple.org/projects/captcha/">check the Captcha project</a>.';
$lang['title_use_captcha'] = 'Use Captcha to protect form submissions?';
$lang['title_use_captcha_help'] = 'Check here to protect your form with a <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">"Captcha"</a>.';
$lang['title_user_captcha'] = 'Please confirm that you are not a script by entering the letters from the image.';
$lang['title_user_captcha_error'] = 'Failed text for Captcha';
$lang['wrong_captcha'] = 'Captcha は利用できません。';
$lang['title_title_user_captcha'] = 'Help text for Captcha';
$lang['title_dont_submit_unchecked'] = 'Don\'t submit values for unchecked boxes';
$lang['title_dont_submit_unchecked_help'] = 'Check this if you only want checked boxes to return values.';
$lang['link_label'] = 'リンクラベル';
$lang['link_destination'] = 'Link Destination URL';
$lang['title_default_set'] = 'Checked by Default?';
$lang['title_24_hour'] = 'Use 24-hour clock?';
$lang['title_before_noon'] = '午前';
$lang['title_after_noon'] = '午後';
$lang['title_smarty_eval'] = 'Process smarty tags within field?';
$lang['title_textarea_rows'] = 'Rows (note: this may be overridden by CSS)';
$lang['title_textarea_cols'] = 'Columns (note: this may be overridden by CSS)';
$lang['title_form_main'] = 'Main Form Details';
$lang['title_show_username'] = 'Display User\'s login name?';
$lang['title_show_userfirstname'] = 'Display User\'s first name?';
$lang['title_show_userlastname'] = 'Display User\'s last name?';
$lang['title_restrict_to_group'] = 'Restrict user list to users in specified group';
$lang['restricted_to_group'] = 'Only in group %s';
$lang['title_show_to_user'] = 'Display to user?';
$lang['help_leaveempty'] = 'This field may be left empty';
$lang['help_variables_for_template'] = 'Variables For Template';
$lang['help_variables_for_computation'] = 'Variables Available';
$lang['help_php_variable_name'] = 'PHP variable';
$lang['help_submission_date'] = 'Date of Submission';
$lang['help_server_name'] = 'Your server';
$lang['help_sub_source_ip'] = 'IP address of person using form';
$lang['help_sub_url'] = 'URL of page containing form';
$lang['help_fb_version'] = 'FormBuilder version';
$lang['help_tab'] = 'Tab Character';
$lang['help_other_fields'] = 'Alternate field names can be used interchangeably (especially useful if Smarty is choking on characters outside of ASCII 32-126). <br />Other fields will be available as you add them to the form.';
$lang['help_array_fields'] = 'Yet another way of accessing field values is via $fieldname_obj, $alias_obj, or $fld_#_obj, where each field is an object containging:<br /><table>
<tr><td class="odd">name</td><td class="odd">Field Name</td></tr>
<tr><td>type</td><td>Field Type</td></tr>
<tr><td class="odd">id</td><td class="odd">Internal Field ID</td></tr>
<tr><td>value</td><td>Human-readable Value</td></tr>
<tr><td class="odd">valueArray</td><td class="odd">Array of field value(s)</td></tr></table><em>e.g.</em>, you could use "{$fld_1_obj->name} = {$fld_1_obj->value}';
$lang['help_date_format'] = 'See <a href="http://www.php.net/manual/en/function.date.php" target=_NEW>the PHP Manual</a> for formatting help.';
$lang['help_variable_name'] = 'Variable';
$lang['help_form_field'] = 'Field Represented';
$lang['link_back_to_form'] = '« フォームへ戻る';
$lang['title_create_sample_template'] = 'サンプルテンプレートの作成';
$lang['title_create_sample_html_template'] = 'サンプルHTMLテンプレートの作成';
$lang['title_create_sample_header'] = 'サンプルヘッダの作成';
$lang['help_tab_symbol'] = 'a tab character';
$lang['title_file_template'] = 'Template for one line of output file';
$lang['title_file_header'] = 'Template for the header of output file';
$lang['title_confirmation_url'] = 'URL to click for form confirmation';
$lang['title_value'] = 'Value (see Advanced Tab if you use Smarty tags)';
$lang['title_date_format'] = '日付型 (standard <a href="http://www.php.net/manual/en/function.date.php">PHP Date Formats</a>)';
$lang['title_use_wysiwyg'] = 'Use WYSIWYG editor for text Area (Admin side only)?';
$lang['title_submit_actions'] = 'Form Submission Behavior';
$lang['title_submit_labels'] = 'Submission Button Labels';
$lang['title_sortable_field'] = 'Sortable Field #%s';
$lang['title_submit_help'] = 'This page lets you customize Form Submission. It doesn\'t determine what the Form Builder does with the submitted data. You can set that up by adding "Disposition" fields to your form.';
$lang['title_start_year'] = '年の始まり';
$lang['title_end_year'] = '年の終わり';
$lang['title_default_year'] = 'デフォルト年';
$lang['title_default_year_help'] = '(Set to -1 for default year to be the current year)';
$lang['title_submit_action'] = 'After form is submitted';
$lang['title_submit_response'] = 'Response to display';
$lang['display_text'] = 'Display "Submission Template"';
$lang['redirect_to_page'] = 'サイトへリダイレクトする';
$lang['title_submit_response_help'] = 'This template is for display to the user after the form is submitted. This template does not effect emails generated or other form dispositions -- you set those templates (where appropriate) in the "advanced" tab for those disposition fields.';
$lang['title_destination_page'] = 'Destination Page';
$lang['title_require_fieldnames'] = '必須入力の項目名';
$lang['title_require_fieldnames_long'] = 'Require fields to have a name?';
$lang['title_unique_fieldnames'] = '必須入力、一意の項目名';
$lang['title_unique_fieldnames_long'] = 'Require fields to have unique names?';
$lang['title_reorder_form'] = 'Reorder Fields';
$lang['title_load_template'] = 'テンプレートの読み込み';
$lang['title_add_button_text'] = 'Add Button text';
$lang['title_del_button_text'] = 'Delete Button text';
$lang['title_string_or_number_eval'] = 'Interpret variables as being numbers or strings';
$lang['title_order'] = 'Interpretation Order';
$lang['title_order_help'] = 'If more than one Computed Field exists, they will be computed from lowest order number to highest order number';
$lang['title_compute_value'] = 'Value to compute';
$lang['title_string'] = '文字列';
$lang['title_numeric'] = '数値';
$lang['title_inline_form'] = 'Display form inline?';
$lang['title_inline_form_help'] = 'Inline means any form followup replaces the {cms_module} tag, non-inline replaces the {content} tag.';
$lang['title_field_default_value'] = 'Default value for field';
$lang['title_clear_default'] = 'Clear default on click?';
$lang['title_clear_default_help'] = 'Check this to clear the default value when the user clicks this field. Since this uses a javascript string compare, it will fail if you put single quotes in your default text. Other un-javascript-friendly characters may also cause it to fail.';
$lang['title_remove_file_from_server'] = 'Delete uploaded file from server after processing (email dispositions)';
$lang['title_field_javascript'] = 'Javascript for field';
$lang['title_field_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick="yourfn()"';
$lang['title_submit_javascript'] = 'Form Submission Javascript';
$lang['title_submit_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick="yourfn()".<br />This will probably not work well if you use the "safety script" option above.';
$lang['default_template'] = 'デフォルトテンプレート';
$lang['table_left_template'] = 'Table Template, Titles on left';
$lang['table_top_template'] = 'Table Template, Title on top';
$lang['form_template_name'] = 'テンプレートフォーム %s';
$lang['template_are_you_sure'] = 'Are you sure you want to overwrite your template with the selected template? (Even if you say OK, you will still need to save the change)';
$lang['title_bad_function'] = 'Error when computing "%s".';
$lang['no_referrer_info'] = 'No HTTP_REFERER info available (probably due to use of User Email Validation)';
$lang['validation_param_error'] = 'Validation Parameter Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_response_error'] = 'Validation Repsonse Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_no_field_error'] = 'Validation Repsonse Error. No email validation field in this form!';
$lang['upgrade03to04'] = 'Form Template was updated automatically as part of the version 0.3 to version 0.4 upgrade. You may need to make some fixes. If you\'re using the default form, simply replace this template with "default" using the pulldown above.';
$lang['admindesc'] = 'Add, edit and manage interactive Forms';
$lang['operators_help'] = 'If you use String evaluation, the only operation available is concatenation (+), while if you use Number evaluation you have basic, very simple math (, +, -, *, /, ).';
$lang['date_january'] = '1月';
$lang['date_february'] = '2月';
$lang['date_march'] = '3月';
$lang['date_april'] = '4月';
$lang['date_may'] = '5月';
$lang['date_june'] = '6月';
$lang['date_july'] = '7月';
$lang['date_august'] = '8月';
$lang['date_september'] = '9月';
$lang['date_october'] = '10月';
$lang['date_november'] = '11月';
$lang['date_december'] = '12月';
$lang['submission_error'] = 'Sorry! There was an error handling your form submission.';
$lang['submit_error'] = 'FormBuilder submit error: %s';
$lang['uploads_error'] = 'Error committing file to the uploads module: %s';
$lang['nouploads_error'] = 'Could not find the uploads module';
$lang['upload_attach_error'] = 'Upload/Attachment error on file %s (tmp_name: %s, of type %s)';
$lang['submission_error_file_lock'] = 'Error. Unable to obtain lock for file.';
$lang['unchecked_by_default'] = 'デフォルト: 非チェック';
$lang['checked_by_default'] = 'デフォルト: チェック';
$lang['email_default_template'] = 'FormBuilder Submission';
$lang['email_template_not_set'] = '<br/>Email Template not yet set!';
$lang['missing_cms_mailer'] = 'FormBuilder: Cannot find required module CMSMailer!';
$lang['user_approved_submission'] = 'User approved submission %s from %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Event triggered when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Event triggered if there is an error when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Event triggered when a FormBuilder form is displayed';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Event triggered when a FormBuilder form is submitted.</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>value_<name></em> - Supply a default value to a field with the specified name.</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Event triggered if there is an error when a FormBuilder form is submitted</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>error</em> - A list of all known errors (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Event triggered when a FormBuilder form is displayed</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
</ul> ';
$lang['formbuilder_params_response_id'] = 'Response ID. Used by FormBrowser';
$lang['formbuilder_params_passed_from_tag'] = 'Default field values; see module help';
$lang['formbuilder_params_field_id'] = 'Field ID for internal operations';
$lang['formbuilder_params_form_name'] = 'フォーム名';
$lang['formbuilder_params_form_id'] = 'Form ID for internal operations';
$lang['formbuilder_params_general'] = 'General parameters for internal operations';
$lang['template_variable_help'] = '<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you\'d like.
   To make the form work, you\'ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that\'s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field\'s name</td></tr>
<tr><td>field->input</td><td>the field\'s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field\'s input (useful for <label for="">)</td></tr>
<tr><td>field->type</td><td>the field\'s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays "page x of y" for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>"Back" button for multipart forms</td></tr>
<tr><td>submit</td><td>"Continue" or "Submit" button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you\'d want some of those, but there you go...</p>
';
$lang['post_install'] = '<p>Make sure to set the "Modify Forms" permissions
on users who will be administering feedback forms. Also, if you\'ll be emailing form
results, be sure to update the Configuration appropriately.</p>
<p>Please be aware that a feedback form should not be active (e.g., usable by the public) while
you are still editing the form. You should create the form, and place the tag into an active
content page only when you have finished editing. Otherwise, erroneous results could be returned.</p>
<p>Additionally, this version does not support parallel editing of forms. Please take care that
only one admin is editing a given form at a given time.</p>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create feedback forms (in fact, it\'s a replacement of the original Feedback Form module), with the added power of database storage. With its companion module Form Browser, you can use it to create simple database applications.</p>
<p>The forms created using the Form Builder may be inserted
into templates and/or content pages. Forms may contain many kinds of inputs, and may have
validation applied to these inputs. The results of these forms may be handled in a variety of ways.</p>

<h3>How Do I Use it?</h3>
<P>Install it, and poke around the menus. Play with it. Try creating forms, and adding them to your content.
If you get stuck, chat with me on the #cms IRC channel, post to the forum, send me email, or, if you\'re
really desperate, try reading the instructions on the rest of this page.</P>

<h3>How Do I Create a Form</h3>
<p>In the CMS Admin Menu, you should get a new menu item called FormBuilder. Click on this. On the page
that gets shown, there are options (at the bottom of the list of Forms) to Add a New Form or Modify
Configuration.</p>

<h3>Adding a Form to a Page</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module=\'FormBuilder\' form=\'sample_form\'}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page\'s content if you use a WYSIWYG editor such as TinyMCE, FCKEdit, or HTMLArea. These editors may stealthily
change the quote marks (") into HTML entities (&quot;), and the forms will not show up. Try using
single quotes (\') or editing the HTML directly.</p>

<h3>Working with Forms</h3>
<p>By clicking on a Form\'s name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you\'ll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing.</p>
<p>Below this, if you have it enabled, is the "fast field adder" pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Form Submission</h4>
<p>When the form is submitted, you can either redirect the user to another page of your site, or you can present the user some message (which can contain any of the user\'s form entries, or just static text). In this tab, you select which of these approaches you wish to use, and, if you chose redirection, it allows you to pick the page to redirect users to after a successful form submission.</p>
<p>Also on this page, you can specify the labels of various submission buttons ("Previous", "next", "submit"). You can also opt to have some Javascript added to the last page of a form that will prevent multiple submissions (useful on slow servers).</p>
<h4>Form Display Options</h4>
<p>This tab allows for other form customizations, like the symbol to show for required fields.</p>
<h4>Captcha Settings</h4>
<p>If you have installed the Captcha module, this tab lets you configure the Captcha settings for your form.</p>
<h4>Form Template</h4>
<p>This is where you do your customization work of your form\'s Smarty Template. See the section called Form Template Variables below.</p>
<p>The form should default to a Custom template that documents the Smarty tags available to you.</p>
<p>Unless you\'re a Smarty expert, you probably don\'t want to mess around with this. If you are a Smarty expert, this is where you can unleash your magic.</p>
<h4>Submission Template</h4>
<p>If, in the Form Submission tab, you selected \'Display "Submission Template", this is where you can create that template. There is a display of which smarty variables are available to you, and a button to generate a sample template.</p>
<p>If you\'re a Smarty expert, you can do all manner of creative and powerful things here. If you\'re not a Smarty expert, you might just want to use the default.
</p>

<h3>Adding Fields to your Form</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it\'s submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it\'s safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked "Required", which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to "view source" on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It\'s really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It\'s really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Canadian Province. This is a pulldown listing the Canadian Provinces (Contributed by Noel McGran. Thanks!)</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
<li>Time Picker. This is a set of pulldowns allowing the user to select a time (using 12 or 24 hour clock).</li>
<li>File Upload. This is a file upload field.</li>
<li>Link (User Entered). This creates a double input field for getting a link URL and link title.</li>
<li>Text Field (Multiple). This field creates one or more text inputs with add and delete buttons, effectively giving the end user a way of creating variable-length lists.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the "From" field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the "From" field.</li>
<li>Email Subject Field. This allows users to provide a subject for their email. The email generated when the form gets handled will use this in the "Subject" field. This may cause trouble with certain dispositions that want to control the Email Subject, so use it with caution.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Fieldset Start. Combined with Fieldset End, this allows you to group various fields within your form. Use this to start a given grouping.</li>
<li>-Fieldset End. Combined with Fieldset Start, this allows you to group various fields within your form. Use this to end a given grouping.</li>
<li>-Hidden Field. This allows you to embed a hidden field in your form.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you\'re not using a Custom Template to render your form.</li>
<li>-Static Link. This allows you to put a link to a given page into your form. Optionally, you can have it autopopulate with the page where the form is embedded (useful if you\'re sending results via email).</li>
<li>-Computed Field. This allows you to embed a computed field in your form. It is not visible to the user until after the form is submitted. It allows you to do simple arithmetic or string concatenation.</li>
<li>-Unique Integer (Serial). This is an integer that increases every time someone hits your form. Your results may not be sequential, but they will increase monotonically.</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<ul><li>*Call a User Defined Tag With the Form Results. This submits all the form results to the User-Defined Tag you specify. The UDT can handle the results however it wants. Values are passed as $param[\'field_name\'].</li>
<li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these "Director" pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email to User-Supplied Address. This puts an input field in the form for the user to populate with an email address. The form results get sent to that address. Beware of Spam abuse! Active the primitive anti-spam features in the FormBuilder configuration screen.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Redirect to Page Based on Pulldown. This allows you to redirect the form to a different site page depending on its value. If you have multiple dispositions, make sure this is used last.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered "approved," and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the "output" directory under the
module\'s installation directory, assuming the web server has permission to write there.</li>
<li>*Save Results to File Based on Pulldown. Like the Flat File disposition, except the value of a pull-down determines which file results get written to.</li>
<li>*Save Results to File(s) Based on Multiple Selections. Like the Flat File disposition, except the value(s) of checkboxes  determines which file(s) results get written to.</li>
<li>*Email to CMS Admin User. Provides a pull-down of CMS Admin users, and directs the results as an email to the selected admin.</li>
<li>*Store Results for FormBrowser Module v.3. Stores the form results in an XML structure as a single database record. This will become the interface to Form Browser in the next release.</li>

</ul></li></li></ul>


<h3>Passing Default Values to Forms</h3>
<p>Calguy added a nice feature, which is that you can pass default field values to your form via the module tag. This allows you to have
the same form in multiple places, but with different default values. It may not work for more exotic field types, but for fields that have
a single value, you can specify like:</p>
<p>{cms_module module=\'FormBuilder\' form=\'my_form\' value_<i>FIELDNAME</i>=\'default_value\'}</p>
<p>This will set the field with <i>FIELDNAME</i> to \'default_value\'.</p>
<p>This can be problematic, as sometimes field names are unweildy or contain characters that don\'t work well with Smarty. So there is an
alternative like this:</p>
<p>{cms_module module=\'FormBuilder\' form=\'my_form\' value_fld<i>NUMBER</i>=\'default_value\'}</p>
<p>That uses field <i>NUMBER</i>, where <i>NUMBER</i> is the internal FormBuilder field id. You might wonder how you know what that id is. Simply go into the FormBuilder configuration tab,
and check "Show Field IDs"</p>

<h3>Email and Flat File Templates</h3>
<p>Many disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it\'s own best guess, which may or may not work out to your liking. You can always click on the "Create Sample Template" and then customize the results.</p>
<p>To the right, you\'ll find a legend which lists all of the variables that are available to you to use in your template. As of version 0.3, variables have two names, one based on the field name, the other based on the field ID. If you use field names that have characters outside of the ASCII 32-126 range, it will be safer to use the ID-based variables.</p>
<p><strong>Note that once you\'ve changed a template, it will no longer automatically add new fields.</strong> For this reason, it\'s usually best to create your templates as the last step of creating your form.</p>
<p>As of version 0.2.4, you can opt to send any of these emails as HTML email. There should be a checkbox at the top of the template page for this. There is also a "Create Sample HTML Template" button over in the legend area. For HTML email, the email body will also provide the default text-only values.</p>

<h3>Configuration</h3>
<p>There are some global configuration options for FormBuilder:</p>
<ul>
<li>Enable fast field add pulldown. This enables the pulldown on the Form Edit page which saves a step in the creation of new fields.</li>
<li>Hide Errors. This is set by default. Unchecking it will cause more detailed errors to be displayed if there are problems when you submit your form.</li>
<li>Require Field Names. Typically, you will want form fields to be named so you can tell which is which. However, in some cases, you might want to have nameless fields. Uncheck this if you want to allow nameless fields.</li>
<li>Unique Field Names. Typically, you will want form fields to have unique names so you can tell which is which. Uncheck this if you want to allow fields to share names.</li>
<li>Use relaxed email validation. This uses a less restrictive regular expression for validating email; e.g., x@y will be allowed, where typically x@y.tld is required.</li>
<li>Show Form Builder Version. Displays the version of FormBuilder you\'re using in a comment when the form is generated. Typically only useful when debugging.</li>
<li>Enable primitive anti-spam features. When turned on, this allows any given IP address to only generate 10 emails per hour.</li>
<li>Show Field IDs. When turned on, FormBuilder will display field ids when adding or editing a form.</li>
</ul>
<h3>Styling and CSS</h3>
<p>Paul Noone graciously provides us all with a pretty good standard CSS that you can use for forms:</p>
<pre>
	/* Sample FormBuilder CSS base */
	form {margin-top:0}
	form, td, th, li { font-size: 100%}
	form div {margin-bottom:0}
	fieldset div {
		margin-bottom:0.5em;
		margin-left:1em;
	}
	fieldset div div {
		margin-top:0.5em;
		margin-left:1em
	}
	fieldset {
		margin-bottom:1em;
		border:1px solid #F60;
		padding:0.5em
	}
	fieldset label {
		width:auto;
	}
	legend {
		color:#FFF;
		background:#F60;
		font-style:italic;
		font-size:1.2em;
		margin-bottom:0.5em;
		padding:0.2em;
		width:auto;
		border:1px solid #CCC
	}
	textarea {
		margin: 0.5em 0;
		width:98%;
		height: 6em
	}

	/* Apply this class to text/select input fields with shorter labels
		to help alignment */
	.short-label label {float:left; width:10em}
	.short-label fieldset div input,
	.short-label fieldset div select {width:16em}

	/* Pretty up your Captcha image output */
	.captcha {
		margin:0.5em 0;
		width:200px;
		text-align:center
	}
	.captcha img {border:1px solid #F60; margin-bottom:0.5em}
	.captcha input {width:196px; margin-top:0.5em}

	/* Just a bit more room for the Submit button */
	.submit {margin-top:0.5em}
</pre>

<h3>Form Template Variables</h3>

<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you\'d like.
   To make the form work, you\'ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that\'s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field\'s name</td></tr>
<tr><td>field->input</td><td>the field\'s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field\'s input (useful for <label for="">)</td></tr>
<tr><td>field->type</td><td>the field\'s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays "page x of y" for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>"Back" button for multipart forms</td></tr>
<tr><td>submit</td><td>"Continue" or "Submit" button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you\'d want some of those, but there you go...</p>


<h3>Known Issues</h3>
<ul>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn\'t matter since the user side is pretty simple.</li>
<li>FileUpload Fields may not work correctly with multipage forms.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you\'re running CMS 1.1 or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you\'re missing fields in an email that gets generated, check the disposition field\'s template, and make sure you\'re specifying the missing fields. Seems obvious, but it\'s an easy mistake to make.</li>
<li>Uncheck the "Hide Errors" checkbox in the global options, and see what message gets displayed when you submit your form.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is no longer a particularly early version, but it is probably still buggy. While I\'ve done all I can
to make sure no egregious bugs have crept in, I have to admit that during early testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor\'s nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>.</li>
<li>Additional discussion of this module may also be found in the <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
</ul>
<p>Keep in mind that the author has put hundreds of hours into the development of this module. Please take the time to read the documentation before sending questions. Either that, or write your questions on financially negotiable instruments (i.e., cash).</p>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright © 2008, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '<ul>
<li>Version 0.5.3. 26 May 08. Bugfixes to previous set of bugfixes. Now ready for major upgrades for 0.6.</li>
<li>Version 0.5.2. 25 May 08. Bugfixes. Release in preparation for substantial reworking for 0.6</li>
<li>Version 0.5.1. 30 April 08. Bugfixes, rewrote some of the File Upload code to prevent white screen of annoyance.</li>
<li>Version 0.5. 19 April 08. Bugfixes, support for FormBrowser fixes and features, disposition type for upcoming FormBrowser version.</li>
<li>Version 0.4.4. 26 Sept 07. Bugfixes for radio button groups, fix for validation of DispositionDeliverToEmailAddressField.</li>
<li>Version 0.4.3. 18 Sept 07. Bugfixes for pulldowns using numbers, option to inline form, fixes for table-layouts provided by Ap Muthu, fix for requirability of Dispositions.</li>
<li>Version 0.4.2. 14 Sept 07. Bugfixes for XML export, RadioButton Group submission, and HTML labels.</li>
<li>Version 0.4.1. Bugfixes for File Disposition Types.</li>
<li>Version 0.4
	<ul>
		<li>Upped minimum CMS version to 1.1</li>
		<li>Numerous Bug fixes; too many to enumerate here</li>
		<li>Massive rejiggering of code to work with CMS MS 1.1 parameter sanitizing regime</li>
		<li>Added field types: "TextField (Multiple)" and "Computed Field"</li>
		<li>Added dispositions: "Save Results to File Based on Pulldown" and "Save Results to File(s) Based on Multiple Selections"(Calguy)</li>
		<li>Added neat-o AJAX-y template-copying for Form Templates, gave versions of old table-based templates to soothe the raging masses.</li>
		<li>Added ability to pass default values to form elements from module tag using value_FIELDNAME="value" syntax (Calguy)</li>
		<li>Added option to display field ids in admin (Calguy)</li>
	</ul>
</li>
<li>Version 0.3
   <ul>
      <li>Added Captcha module support.</li>
      <li>Reworked labeling of form elements to be XHTML compliant</li>
      <li>Added Paul Noone\'s new, improved contact form templates</li>
      <li>Implementation of Email Subject Field</li>
      <li>Added admin-specifiable values to hidden field type, which may contain parsable smarty tags</li>
      <li>Text Area Field now allows specification of rows and cols in the admin, instead of CSS</li>
      <li>Added Drag\'n\'Drop reordering of form fields.</li>
      <li>Added non-blank field name and unique field name global configuration options and validation</li>
      <li>Implemented templated display of form results upon submission in addition to page redirecting</li>
      <li></li>
   </ul>
</li>
<li>Version 0.2.4 - 09 May 2007
   <p>Big release:<ul>
   <li>Added "Email Form to User-Supplied Address" disposition.</li>
   <li>Added "TimePicker" field type. Split "Link" field into a "User-supplied Link" field and a "Static Link" field.</li>
   <li>Added HTML email option and auto-templates for all email dispositions.</li>
   <li>Added primitive anti-spam features.</li>
   <li>Added XML-based import and export of forms.</li>
   </ul>
   </p>
</li>
<li>Version 0.2.3
   <p>Add the ability to call a selectable user defined tag upon disposition of the form.</p>
</li>
<li>Version 0.2.2
   <p>Many thanks to Utter Design for sponsoring some changes and bugfixes, which include:
   <ul>
      <li>Added file upload capabilities to the email disposition</li>
      <li>Add PageSetStart and PageSetEnd field types
      <p>These field types allow you to create fieldsets in your form, and organise
      your fields logically for the user.  You can even nest fieldsets, and
      associate a style with them appropriately.  The default template was changed
      to prevent it from wrapping a div around these types of fields.
      </p>
      </li>
      <li>Fixed a problem with DATETIME fields on install
      <p>This solves a problem when on install the response table would sometimes not get created when using adodb lite</li>
      </li>
   </ul>
   </p>
</li>
<li>Version 0.2 - 14 November 2006. Calguy & tsw\'s bug fixes for field re-ordering and custom templates. Additional bug fixes for field labels.</li>
<li>Version 0.1 - 8 July 2006. Initial Release</li>
</ul>
';
$lang['utma'] = '156861353.1193756969.1199698276.1213318721.1213322938.6';
$lang['utmz'] = '156861353.1213322938.6.4.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/|utmcmd=referral';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/lt_LT.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Formų kūrimas';
$lang['field_type_'] = 'Laukelio tipas nenustatytas';
$lang['field_type_CatalogerItemsField'] = 'Select one (or more) cataloger items';
$lang['field_type_FieldsetEnd'] = '-Fieldset pabaiga';
$lang['field_type_FieldsetStart'] = '-Fieldset pradzia';
$lang['field_type_TextField'] = 'Text Input';
$lang['field_type_TextFieldExpandable'] = 'Text Input (Multiple)';
$lang['field_type_TextAreaField'] = 'Text Area';
$lang['field_type_CheckboxField'] = 'Check Box';
$lang['field_type_CheckboxGroupField'] = 'Check Box Group';
$lang['field_type_PulldownField'] = 'Pulldown';
$lang['field_type_MultiselectField'] = 'Multiselect';
$lang['field_type_StatePickerField'] = 'JAV valstijų pasirinkimas';
$lang['field_type_ProvincePickerField'] = 'Canadian Province Picker';
$lang['field_type_CountryPickerField'] = '&Scaron;alies pasirinkimas';
$lang['field_type_DatePickerField'] = 'Datos pasirinkimas';
$lang['field_type_TimePickerField'] = 'Laiko pasirinkimas';
$lang['field_type_RadioGroupField'] = 'Radio Button Group';
$lang['field_type_DispositionDirector'] = '*Email Results Based on Pulldown';
$lang['field_type_DispositionFileDirector'] = '*Save Results to File Based on Pulldown';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Save Results to File(s) Based on Multiple Selections';
$lang['field_type_DispositionPageRedirector'] = '*Redirect to Page Based on Pulldown';
$lang['field_type_DispositionEmail'] = '*Email Results to set Address(es)';
$lang['field_type_DispositionEmailConfirmation'] = '*Validate-via-Email Address';
$lang['field_type_DispositionFile'] = '*Write Results to Flat File';
$lang['field_type_DispositionDatabase'] = '*Store Results in Database';
$lang['field_type_DispositionFormBrowser'] = '*Store Results for FormBrowser Module v.3';
$lang['field_type_DispositionUserTag'] = '*Call A User Defined Tag With the Form Results';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Email to User-Supplied Email Address';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Email to CMS Admin User';
$lang['field_type_PageBreakField'] = '-Page Break';
$lang['field_type_FileUploadField'] = 'Bylos atsiuntimas';
$lang['field_type_FromEmailAddressField'] = 'El pa&scaron;to &quot;Nuo Adresas&quot; laukelis';
$lang['field_type_FromEmailNameField'] = 'El pa&scaron;to &quot;Nuo Vardas&quot; laukelis';
$lang['field_type_FromEmailSubjectField'] = 'El. pa&scaron;to &quot;Tema&quot; laukelis';
$lang['field_type_StaticTextField'] = '-Statinis tekstas';
$lang['field_type_SystemLinkField'] = '-Statinė nuoroda';
$lang['field_type_LinkField'] = 'Nuoroda (Įveda lankytojas)';
$lang['field_type_HiddenField'] = 'Hidden Field';
$lang['field_type_ComputedField'] = '-Computed Field';
$lang['field_type_UniqueIntegerField'] = '-Unique Integer (Serial)';
$lang['validation_none'] = 'No Validation';
$lang['validation_numeric'] = 'Numeric';
$lang['validation_integer'] = 'Integer';
$lang['validation_email_address'] = 'El pa&scaron;to adresas';
$lang['validation_usphone'] = 'Phone Number (US)';
$lang['validation_must_check'] = 'Turi būt pažymėtas';
$lang['validation_regex_match'] = 'Match Regular Expression';
$lang['validation_regex_nomatch'] = 'Doesn&#039;t match Regular Expression';
$lang['required_field_missing'] = 'A value was not supplied for a required field';
$lang['please_enter_a_value'] = 'Pra&scaron;ome įvesti  &quot;%s&quot;';
$lang['please_enter_a_number'] = 'Pra&scaron;ome įvesti skaičių &quot;%s&quot;';
$lang['please_enter_valid'] = 'Pra&scaron;ome įvesti galiojančią reik&scaron;mę &quot;%s&quot;';
$lang['please_enter_an_integer'] = 'Please enter an integer value for &quot;%s&quot;';
$lang['please_enter_an_email'] = 'Pra&scaron;ome įvesti galiojantį el pa&scaron;to adresą&quot;%s&quot;';
$lang['please_enter_a_phone'] = 'Pra&scaron;om, įveskite teisingą telefono numerį &quot;%s&quot;';
$lang['not_valid_email'] = '&quot;%s&quot; nepana&scaron;us į galiojantį el pa&scaron;to adresą!';
$lang['please_enter_no_longer'] = 'Pra&scaron;ome įvesti nedaugiau kaip  %s simbolių';
$lang['title_list_delimiter'] = 'Character to use as delimiter in results that return more than one value';
$lang['you_need_permission'] = 'You need the &quot;%s&quot; permission to perform that operation.';
$lang['lackpermission'] = 'Sorry! You don&#039;t have adequate privileges to access this section.';
$lang['field_order_updated'] = 'Laukelių tvarka atnaujinta.';
$lang['form_deleted'] = 'Forma pa&scaron;alinta.';
$lang['field_deleted'] = 'Laukelis pa&scaron;alintas.';
$lang['configuration_updated'] = 'Nustatymai atnaujinti.';
$lang['you_must_check'] = 'Turite pažymėti &quot;%s&quot; jei norite tęsti';
$lang['must_specify_one_destination'] = 'You need to specify at least one destination address!';
$lang['are_you_sure_delete_form'] = 'Ar jūs įsitikinęs, kad norite i&scaron;trinti formą %s?';
$lang['are_you_sure_delete_field'] = 'Ar jūs įsitikinęs, kad norite i&scaron;trinti laikelį %s?';
$lang['notice_select_type'] = 'Advanced options are not available until the field type has been set.';
$lang['field_name_in_use'] = 'The field name &quot;%s&quot; is already in use. Please use unique field names.';
$lang['field_no_name'] = 'Fields must be named, unless you disable this in the Form Builder configuration.';
$lang['anonymous'] = 'Anonimas';
$lang['abbreviation_length'] = 'Len: %s';
$lang['boxes'] = '%s boxes';
$lang['options'] = '%s options';
$lang['text_length'] = '%s chars.';
$lang['order'] = 'Order';
$lang['unspecified'] = '[nenurodyta]';
$lang['added'] = 'pridėta';
$lang['updated'] = 'atnaujinta';
$lang['sort_options'] = 'Sort options on output';
$lang['select_one'] = 'Pasirinkite vieną';
$lang['select_type'] = 'Pasirinkite tipą';
$lang['to'] = 'To';
$lang['yes'] = 'Taip';
$lang['no'] = 'Ne';
$lang['recipients'] = 'recipients';
$lang['file_count'] = '%s possible files';
$lang['destination_count'] = '%s destinations';
$lang['save'] = 'Saugoti';
$lang['add'] = 'Pridėti';
$lang['update'] = 'Atnaujinti';
$lang['save_and_continue'] = 'Saugoti ir tęsti redagavimą';
$lang['information'] = 'Informacija';
$lang['automatic'] = 'Automatic';
$lang['forms'] = 'Formos';
$lang['form'] = '%s forma';
$lang['configuration'] = 'Konfigūracija';
$lang['field_requirement_updated'] = 'Field required state updated.';
$lang['maximum_size'] = 'Max. dydis';
$lang['permitted_extensions'] = 'Plėtiniai';
$lang['permitted_filetypes'] = 'leidžiami bylų tipai';
$lang['file_too_large'] = 'Įkelta byla yra per didelė. Maksimalus dydis yra:';
$lang['illegal_file_type'] = 'This type of file may not be uploaded. Please check that the extension is correct.';
$lang['upload'] = 'Įkelti';
$lang['form_imported'] = 'Forma importuota';
$lang['form_import_failed'] = 'Form import failed! There was a problem with the format of the XML file.';
$lang['rows'] = '%s eilučių';
$lang['cols'] = '%s stulpelių';
$lang['12_hour'] = '12-os valandų laikrodis';
$lang['24_hour'] = '24-ių valandų laikrodis';
$lang['hour'] = 'Hour';
$lang['min'] = 'Minute';
$lang['merid'] = 'Meridian';
$lang['date_range'] = 'Range: %s - %s';
$lang['thanks'] = 'Ačiū! Jūsų pateikimas buvo gautas.';
$lang['edit'] = 'Redaguoti';
$lang['delete'] = 'Trinti';
$lang['day'] = 'Day';
$lang['mon'] = 'Month';
$lang['year'] = 'Year';
$lang['none'] = '(none)';
$lang['uninstalled'] = 'Modulis instaliuotas';
$lang['installed'] = 'Modulio %s versija instaliuota.';
$lang['upgraded'] = 'Modulis atnaujintas iki %s versijos.';
$lang['button_previous'] = 'Atgal...';
$lang['button_submit'] = 'Pateikti formą';
$lang['button_continue'] = 'Tęsti...';
$lang['value_checked'] = 'Pažymėta';
$lang['value_unchecked'] = 'Nepažymėta';
$lang['tab_main'] = 'Main';
$lang['tab_symbol'] = 'Form Display Settings';
$lang['tab_submit'] = 'Formos pateikimas';
$lang['tab_captcha'] = 'Captcha Settings';
$lang['tab_advanced'] = 'Advanced Settings';
$lang['tab_templatelayout'] = 'Template Layout Options';
$lang['tab_submissiontemplate'] = 'Submission Template';
$lang['canuse_smarty'] = '<em>Smarty variables are valid in this field.</em>';
$lang['add_options'] = 'Pridėti daugiau pasirinkimų';
$lang['delete_options'] = 'Trinti pažymėtus pasirinkimus';
$lang['add_checkboxes'] = 'Add More Checkboxes';
$lang['delete_checkboxes'] = 'Delete Marked Checkboxes';
$lang['add_address'] = 'Pridėti kitą adresą';
$lang['delete_address'] = 'I&scaron;trinti pažymėtus adresus';
$lang['add_destination'] = 'Add Another Destination';
$lang['delete_destination'] = 'Delete Marked Destinations';
$lang['suspected_spam'] = 'Too many emails generated from your IP address. Anti-Spam code has prevented delivery.';
$lang['suspected_spam_log'] = 'Suspected spam from IP %s stopped.';
$lang['reorder'] = 'Reorder Fields';
$lang['cancel'] = 'At&scaron;aukti';
$lang['value_set'] = 'Value set: %s';
$lang['help_cataloger_attribute_fields'] = 'Below is a list of the attributes available from the Cataloger module.<br/>You can optionally specify valid ranges, values, or numerous values to be used in filtering the list of items that is displayed to the user.<br/>
<br/>
<strong>Ranges:</strong><br/>
Ranges can be specified by signifying a minimum and maximum value using this syntax: &quot;range: minvalue to maxvalue&quot;<br/>
<br/>
<strong>Multiple Values:</strong><br/>
To specify multiple values for an attribute use the syntax &quot;multi: value1|value2|value3&quot;<br/>
<br/>
<strong>Values from hidden fields</strong><br/>
To specify a value from a hidden field use the syntax {$fld_id}<br/>
<br/>';
$lang['help_name_regex'] = 'A regular expression to allow filtering cataloger items by name';
$lang['help_field_height'] = 'The height of the multiselect field';
$lang['title_name_regex'] = 'Cataloger Item Name Regular Expression';
$lang['title_field_height'] = 'Field Height';
$lang['title_file_path'] = 'Destination Directory for output files';
$lang['title_udt_name'] = 'User Defined Tag';
$lang['title_uploads_destpage'] = 'Page to return to with uploads link';
$lang['title_uploadmodule_summary'] = 'Submitted with formbuilder';
$lang['title_uploads_category'] = 'Uploads category';
$lang['title_sendto_uploads'] = 'Send this file to the uploads module';
$lang['title_legend'] = 'Legenda';
$lang['title_maximum_length'] = 'Maximum Length';
$lang['title_checkbox_label'] = 'Checkbox label';
$lang['title_radio_label'] = 'Radio Button label';
$lang['title_checked_value'] = 'Value when checked';
$lang['title_unchecked_value'] = 'Value when not checked.';
$lang['title_checkbox_details'] = 'Checkbox Group Details';
$lang['title_delete'] = 'Delete?';
$lang['title_select_one_message'] = '&quot;Pasirinkti vieną&quot; tekstas';
$lang['title_selection_value'] = 'Selection Value';
$lang['title_selection_displayname'] = 'Selection Display Name';
$lang['title_selection_subject'] = 'Selection Subject';
$lang['title_select_default_country'] = 'Default Selection';
$lang['title_select_default_state'] = 'Default Selection';
$lang['title_select_default_province'] = 'Default Selection';
$lang['title_option_name'] = 'Option Name';
$lang['title_option_value'] = 'Value Submitted';
$lang['title_pulldown_details'] = 'Pulldown Options';
$lang['title_multiselect_details'] = 'Multiselect Options';
$lang['title_destination_address'] = 'Destination Email Address';
$lang['title_destination_filename'] = 'Destination File Name';
$lang['title_email_from_name'] = '&quot;From name&quot; for email';
$lang['title_relaxed_email_regex'] = 'Use relaxed email validation';
$lang['title_relaxed_regex_long'] = 'Use relaxed email address validation (e.g., allow &quot;x@y&quot; instead of requiring &quot;x@y.tld&quot;)';
$lang['title_email_from_address'] = '&quot;From address&quot; for email';
$lang['title_email_encoding'] = 'Email character set encoding';
$lang['title_director_details'] = 'Pulldown-based Emailer Details';
$lang['title_file_name'] = 'File Name';
$lang['title_email_subject'] = 'Email Subject Line';
$lang['title_form_name'] = 'Form Name';
$lang['title_form_status'] = 'Form Status';
$lang['title_ready_for_deployment'] = 'Ready for Deployment';
$lang['title_not_ready1'] = 'Not Ready';
$lang['title_redirect_page'] = 'Page to redirect to after form submission';
$lang['title_not_ready2'] = 'Please add a field to the form so that the user&#039;s input gets handled. You can';
$lang['title_not_ready_link'] = 'use this shortcut';
$lang['title_form_alias'] = 'Form Alias';
$lang['title_form_fields'] = 'Form Fields';
$lang['title_field_id'] = 'Field Id';
$lang['title_show_fieldaliases'] = 'Show Field Aliases';
$lang['title_show_fieldaliases_long'] = 'Clicking this will display field aliases when adding or editing a form';
$lang['title_field_name'] = 'Field Name';
$lang['title_field_alias'] = 'Field Alias';
$lang['title_radiogroup_details'] = 'Radio Button Group Details';
$lang['title_field_type'] = 'Field Type';
$lang['title_not_ready3'] = 'to create a form handling field.';
$lang['title_add_new_form'] = 'Pridėti naują formą';
$lang['title_show_version'] = 'Rodyti &quot;Formų kūrimo&quot; versiją ?';
$lang['title_show_version_long'] = 'This will embed your installed version number of Form Builder module in a comment, to aid in debugging';
$lang['title_add_new_field'] = 'Pridėti nają laukelį';
$lang['title_form_submit_button'] = 'Form Submit Button Text';
$lang['title_submit_button_safety'] = 'Add Javascript to Submit Button to prevent multiple submissions?';
$lang['title_submit_button_safety_help'] = 'Add safety script';
$lang['title_form_next_button'] = 'Form &quot;Next&quot; Button Text (used for multipage forms)';
$lang['title_form_prev_button'] = 'Form &quot;Previous&quot; Button Text (used for multipage forms)';
$lang['title_field_validation'] = 'Field Validation';
$lang['title_form_css_class'] = 'CSS Class for this form';
$lang['title_field_css_class'] = 'CSS Class for this field';
$lang['title_form_required_symbol'] = 'Symbol to mark required Fields';
$lang['title_field_required'] = 'Required';
$lang['title_field_required_long'] = 'Require a response for this Field';
$lang['title_hide_label'] = 'Hide Label';
$lang['title_hide_label_long'] = 'Hide this field&#039;s name on Form';
$lang['title_text'] = 'Static text to display';
$lang['title_field_regex'] = 'Validation Regex';
$lang['title_lines_to_show'] = 'Number of Lines to display';
$lang['no_default'] = 'No Default';
$lang['redirect_after_approval'] = 'Page to redirect after approval';
$lang['title_regex_help'] = 'This regular expression will only be used if &quot;validation type&quot; is set to a regex-related option. Include a full Perl-style regex, including the start/stop slashes and flags (e.g., &quot;/image\.(\d+)/i&quot;)';
$lang['title_field_required_abbrev'] = 'Req&#039;d';
$lang['title_hide_errors'] = 'Slėpti klaidas';
$lang['title_form_displaytype'] = 'Form Display Type';
$lang['title_hide_errors_long'] = 'Prevent debug / error messages from being seen by users.';
$lang['title_email_template'] = 'Email Template';
$lang['title_maximum_size'] = 'Maximum upload file size (kilobytes)';
$lang['title_maximum_size_long'] = 'This limitation is in addition to any limits set by the php or web server configuration';
$lang['title_permitted_extensions'] = 'Permitted Extensions';
$lang['title_permitted_extensions_long'] = 'Enter a comma-separated list, excluding the dot (e.g., &quot;jpg,gif,jpeg&quot;). Spaces will be ignored. Leaving this blank means there will be no restrictions.';
$lang['title_show_limitations'] = 'Display restrictions?';
$lang['title_show_limitations_long'] = 'Display any size and extension restrictions with the upload field?';
$lang['title_form_template'] = 'Template to use to Display Form';
$lang['title_page_x_of_y'] = 'Puslapis %s i&scaron; %s';
$lang['title_no_advanced_options'] = 'Field has no advanced options.';
$lang['title_form_unspecified'] = 'Text to return for unspecified field values';
$lang['title_enable_fastadd_long'] = 'Enable fast field adding pulldown for forms?';
$lang['title_enable_fastadd'] = 'Enable fast field add pulldown?';
$lang['title_fastadd'] = 'Fast field adder';
$lang['title_enable_antispam_long'] = 'Clicking this will only allow 10 emails to be triggered from a given IP address (per hour).';
$lang['title_enable_antispam'] = 'Enable primitive anti-spam features?';
$lang['title_show_fieldids'] = 'Show Field IDs';
$lang['title_show_fieldids_long'] = 'Clicking this will allow displaying field ids when adding or editing a form';
$lang['title_xml_to_upload'] = 'Upload form from XML file';
$lang['title_xml_upload_formname'] = 'Use this form name';
$lang['title_import_legend'] = 'XML Form Import';
$lang['title_xml_upload_formalias'] = 'Use this form alias';
$lang['title_html_email'] = 'Generate HTML email?';
$lang['title_link_autopopulate'] = 'Automatically populate?';
$lang['title_link_autopopulate_help'] = 'Automatically populate with the URL of the page containing the form? (this overrides site page link option below)';
$lang['title_default_link'] = 'Default link URL';
$lang['title_default_link_title'] = 'Default link text';
$lang['title_link_to_sitepage'] = 'Link to site page';
$lang['title_captcha_not_installed'] = 'You can use <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a> to protect form submissions if you install the Captcha module. For more information, <a href="http://dev.cmsmadesimple.org/projects/captcha/">check the Captcha project</a>.';
$lang['title_use_captcha'] = 'Use Captcha to protect form submissions?';
$lang['title_use_captcha_help'] = 'Check here to protect your form with a <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a>.';
$lang['title_user_captcha'] = 'Įveskite raidės i&scaron; paveiksliuko.';
$lang['title_user_captcha_error'] = 'Failed text for Captcha';
$lang['wrong_captcha'] = 'Captcha was not correct.';
$lang['title_title_user_captcha'] = 'Help text for Captcha';
$lang['title_dont_submit_unchecked'] = 'Don&#039;t submit values for unchecked boxes';
$lang['title_dont_submit_unchecked_help'] = 'Check this if you only want checked boxes to return values.';
$lang['link_label'] = 'Link Label';
$lang['link_destination'] = 'Link Destination URL';
$lang['title_default_set'] = 'Checked by Default?';
$lang['title_24_hour'] = 'Use 24-hour clock?';
$lang['title_before_noon'] = 'AM';
$lang['title_after_noon'] = 'PM';
$lang['title_smarty_eval'] = 'Process smarty tags within field?';
$lang['title_textarea_rows'] = 'Rows (note: this may be overridden by CSS)';
$lang['title_textarea_cols'] = 'Columns (note: this may be overridden by CSS)';
$lang['title_form_main'] = 'Main Form Details';
$lang['title_show_username'] = 'Display User&#039;s login name?';
$lang['title_show_userfirstname'] = 'Display User&#039;s first name?';
$lang['title_show_userlastname'] = 'Display User&#039;s last name?';
$lang['title_restrict_to_group'] = 'Restrict user list to users in specified group';
$lang['restricted_to_group'] = 'Only in group %s';
$lang['title_show_to_user'] = 'Rodyti naudotoją?';
$lang['help_leaveempty'] = 'This field may be left empty';
$lang['help_variables_for_template'] = 'Variables For Template';
$lang['help_variables_for_computation'] = 'Variables Available';
$lang['help_php_variable_name'] = 'PHP variable';
$lang['help_submission_date'] = 'Date of Submission';
$lang['help_server_name'] = 'Your server';
$lang['help_sub_source_ip'] = 'IP address of person using form';
$lang['help_sub_url'] = 'URL of page containing form';
$lang['help_fb_version'] = 'FormBuilder version';
$lang['help_tab'] = 'Tab Character';
$lang['help_other_fields'] = 'Other fields will be available as you add them to the form.';
$lang['help_array_fields'] = 'Yet another way of accessing field values is via $fieldname_obj, $alias_obj, or $fld_#_obj, where each field is an object containging:<br /><table>
<tr><td class=&quot;odd&quot;>name</td><td class=&quot;odd&quot;>Field Name</td></tr>
<tr><td>type</td><td>Field Type</td></tr>
<tr><td class=&quot;odd&quot;>id</td><td class=&quot;odd&quot;>Internal Field ID</td></tr>
<tr><td>value</td><td>Human-readable Value</td></tr>
<tr><td class=&quot;odd&quot;>valueArray</td><td class=&quot;odd&quot;>Array of field value(s)</td></tr></table><em>e.g.</em>, you could use &quot;{$fld_1_obj->name} = {$fld_1_obj->value}';
$lang['help_date_format'] = 'See <a href="http://www.php.net/manual/en/function.date.php" target=_NEW>the PHP Manual</a> for formatting help.';
$lang['help_variable_name'] = 'Variable';
$lang['help_form_field'] = 'Field Represented';
$lang['link_back_to_form'] = '&laquo; Back to Form';
$lang['title_create_sample_template'] = 'Create Sample Template';
$lang['title_create_sample_html_template'] = 'Create Sample HTML-Email Template';
$lang['title_create_sample_header_template'] = 'Create Sample Header Template';
$lang['title_create_sample_header'] = 'Create Sample Header';
$lang['help_tab_symbol'] = 'a tab character';
$lang['title_file_template'] = 'Template for one line of output file';
$lang['title_file_header'] = 'Template for the header of output file';
$lang['title_confirmation_url'] = 'URL to click for form confirmation';
$lang['title_value'] = 'Value (see Advanced Tab if you use Smarty tags)';
$lang['title_date_format'] = 'Date Format (standard <a href="http://www.php.net/manual/en/function.date.php">PHP Date Formats</a>)';
$lang['title_use_wysiwyg'] = 'Use WYSIWYG editor for text Area?';
$lang['title_submit_actions'] = 'Form Submission Behavior';
$lang['title_submit_labels'] = 'Submission Button Labels';
$lang['title_sortable_field'] = 'Sortable Field #%s';
$lang['title_submit_help'] = 'This page lets you customize Form Submission. It doesn&#039;t determine what the Form Builder does with the submitted data. You can set that up by adding &quot;Disposition&quot; fields to your form.';
$lang['title_start_year'] = 'Year range start';
$lang['title_end_year'] = 'Year range end';
$lang['title_default_year'] = 'Default Year';
$lang['title_default_year_help'] = '(Set to -1 for default year to be the current year)';
$lang['title_submit_action'] = 'After form is submitted';
$lang['title_submit_response'] = 'Response to display';
$lang['display_text'] = 'Display &quot;Submission Template&quot;';
$lang['redirect_to_page'] = 'Redirect to site page';
$lang['title_submit_response_help'] = 'This template is for display to the user after the form is submitted. This template does not effect emails generated or other form dispositions -- you set those templates (where appropriate) in the &quot;advanced&quot; tab for those disposition fields.';
$lang['title_destination_page'] = 'Destination Page';
$lang['title_require_fieldnames'] = 'Require Fieldnames';
$lang['title_require_fieldnames_long'] = 'Require fields to have a name?';
$lang['title_unique_fieldnames'] = 'Require Unique Fieldnames';
$lang['title_unique_fieldnames_long'] = 'Require fields to have unique names?';
$lang['title_reorder_form'] = 'Reorder Fields';
$lang['title_load_template'] = 'Load template';
$lang['title_add_button_text'] = 'Add Button text';
$lang['title_del_button_text'] = 'Delete Button text';
$lang['title_string_or_number_eval'] = 'Interpret variables as being numbers or strings';
$lang['title_order'] = 'Interpretation Order';
$lang['title_order_help'] = 'If more than one Computed Field exists, they will be computed from lowest order number to highest order number';
$lang['title_compute_value'] = 'Value to compute';
$lang['title_string'] = 'String';
$lang['title_numeric'] = 'Numeric';
$lang['title_inline_form'] = 'Display form inline?';
$lang['title_inline_form_help'] = 'Inline means any form followup replaces the {cms_module} tag, non-inline replaces the {content} tag.';
$lang['title_field_default_value'] = 'Default value for field';
$lang['title_clear_default'] = 'Clear default on click?';
$lang['title_clear_default_help'] = 'Check this to clear the default value when the user clicks this field. Since this uses a javascript string compare, it will fail if you put single quotes in your default text. Other un-javascript-friendly characters may also cause it to fail.';
$lang['title_remove_file_from_server'] = 'Delete uploaded file from server after processing (email dispositions)';
$lang['title_field_javascript'] = 'Javascript for field';
$lang['title_field_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;';
$lang['title_submit_javascript'] = 'Form Submission Javascript';
$lang['title_submit_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;.<br />This will probably not work well if you use the &quot;safety script&quot; option above.';
$lang['email_from_addr_help'] = 'Do not just pick a random address here -- many ISPs will<br />not deliver the mail if you are using a different domain name than your actual<br />host name (i.e., use something like name@%s)';
$lang['title_switch_advanced'] = 'Need more field types? ';
$lang['title_switch_basic'] = 'Too many confusing field types? ';
$lang['title_switch_advanced_link'] = 'Switch to Advanced Mode';
$lang['title_switch_basic_link'] = 'Switch to Simple Mode';
$lang['title_file_root'] = 'Directory to save file in';
$lang['title_file_root_help'] = 'This needs to be a directory that your web server has permissions to write in.<br />Chmod it 777 if you have problems/doubts.<br />Also, check to see that you do not have PHP directory restrictions.';
$lang['error_cataloger_module_not_available'] = '<strong>Cataloger module does not seem to be installed/active.</strong>';
$lang['warning'] = 'WARNING!';
$lang['default_template'] = 'Default Template';
$lang['table_left_template'] = 'Table Template, Titles on left';
$lang['table_top_template'] = 'Table Template, Title on top';
$lang['form_template_name'] = 'Template from %s';
$lang['template_are_you_sure'] = 'Are you sure you want to overwrite your template with the selected template? (Even if you say OK, you will still need to save the change)';
$lang['title_bad_function'] = 'Error when computing &quot;%s&quot;.';
$lang['no_referrer_info'] = 'No HTTP_REFERER info available (probably due to use of User Email Validation)';
$lang['validation_param_error'] = 'Validation Parameter Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_response_error'] = 'Validation Repsonse Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_no_field_error'] = 'Validation Repsonse Error. No email validation field in this form!';
$lang['upgrade03to04'] = 'Form Template was updated automatically as part of the version 0.3 to version 0.4 upgrade. You may need to make some fixes. If you&#039;re using the default form, simply replace this template with &quot;default&quot; using the pulldown above.';
$lang['admindesc'] = 'Add, edit and manage interactive Forms';
$lang['operators_help'] = 'If you use String evaluation, the only operation available is concatenation (+), while if you use Number evaluation you have basic, very simple math (, +, -, *, /, ).';
$lang['date_january'] = 'Sausis';
$lang['date_february'] = 'Vasaris';
$lang['date_march'] = 'Kovas';
$lang['date_april'] = 'Balandis';
$lang['date_may'] = 'Gegužė';
$lang['date_june'] = 'Birželis';
$lang['date_july'] = 'Liepa';
$lang['date_august'] = 'Rugpjūtis';
$lang['date_september'] = 'Rugsėjis';
$lang['date_october'] = 'Spalis';
$lang['date_november'] = 'Lapkritis';
$lang['date_december'] = 'Gruodis';
$lang['submission_error'] = 'Sorry! There was an error handling your form submission.';
$lang['submit_error'] = 'FormBuilder submit error: %s';
$lang['uploads_error'] = 'Error committing file to the uploads module: %s';
$lang['nouploads_error'] = 'Could not find the uploads module';
$lang['upload_attach_error'] = 'Upload/Attachment error on file %s (tmp_name: %s, of type %s)';
$lang['submission_error_file_lock'] = 'Error. Unable to obtain lock for file.';
$lang['unchecked_by_default'] = 'Default: unchecked';
$lang['checked_by_default'] = 'Default: checked';
$lang['email_default_template'] = 'FormBuilder Submission';
$lang['email_template_not_set'] = '<br/>Email Template not yet set!';
$lang['missing_cms_mailer'] = 'FormBuilder: Cannot find required module CMSMailer!';
$lang['user_approved_submission'] = 'User approved submission %s from %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Event triggered when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Event triggered if there is an error when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Event triggered when a FormBuilder form is displayed';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Event triggered when a FormBuilder form is submitted.</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>value_<name></em> - Supply a default value to a field with the specified name.</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Event triggered if there is an error when a FormBuilder form is submitted</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>error</em> - A list of all known errors (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Event triggered when a FormBuilder form is displayed</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
</ul> ';
$lang['formbuilder_params_response_id'] = 'Response ID. Used by FormBrowser';
$lang['formbuilder_params_passed_from_tag'] = 'Default field values; see module help';
$lang['formbuilder_params_field_id'] = 'Field ID for internal operations';
$lang['formbuilder_params_form_name'] = 'Formos pavadinimas';
$lang['formbuilder_params_form_id'] = 'Form ID for internal operations';
$lang['formbuilder_params_general'] = 'General parameters for internal operations';
$lang['template_variable_help'] = '<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>
';
$lang['post_install'] = '<p>Make sure to set the &quot;Modify Forms&quot; permissions
on users who will be administering feedback forms. Also, if you&#039;ll be emailing form
results, be sure to update the Configuration appropriately.</p>
<p>Please be aware that a feedback form should not be active (e.g., usable by the public) while
you are still editing the form. You should create the form, and place the tag into an active
content page only when you have finished editing. Otherwise, erroneous results could be returned.</p>
<p>Additionally, this version does not support parallel editing of forms. Please take care that
only one admin is editing a given form at a given time.</p>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create feedback forms (in fact, it&#039;s a replacement of the original Feedback Form module), with the added power of database storage. With its companion module Form Browser, you can use it to create simple database applications.</p>
<p>The forms created using the Form Builder may be inserted
into templates and/or content pages. Forms may contain many kinds of inputs, and may have
validation applied to these inputs. The results of these forms may be handled in a variety of ways.</p>

<h3>How Do I Use it?</h3>
<P>Install it, and poke around the menus. Play with it. Try creating forms, and adding them to your content.
If you get stuck, chat with me on the #cms IRC channel, post to the forum, send me email, or, if you&#039;re
really desperate, read the rest of this page.</P>

<h3>How Do I Create a Form</h3>
<p>In the CMS Admin Menu, you should get a new menu item called FormBuilder. Click on this. On the page
that gets shown, there are options (at the bottom of the list of Forms) to Add a New Form or Modify
Configuration.</p>

<h3>Adding a Form to a Page</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module=&#039;FormBuilder&#039; form=&#039;sample_form&#039;}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page&#039;s content if you use a WYSIWYG editor such as TinyMCE or HTMLArea. These editors may stealthily
change the quote marks (&quot;) into HTML entities (&amp;quot;), and the forms will not show up. Try using
single quotes (&#039;) or editing the HTML directly.

<h3>Working with Forms</h3>
<p>By clicking on a Form&#039;s name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you&#039;ll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing. You also select the display type. Your choices are:</p>
<ul>
<li>Table/CSS. The form is created using HTML tables. If you don&#039;t know what to choose, this is the easiest option, and will probably do most of what you want. You can still use CSS to style the form if you want.</li>
<li>Pure CSS. The form is created, with all the fields wrapped in <div> tags. You can then style the form as you see fit.</li>
<li>Custom Template. Basically, you get a smarty template, a bunch of variables, and you&#039;re on your own. You have the power to create whatever you want.</li>
</ul>
<p>Below this, if you have it enabled, is the &quot;fast field adder&quot; pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Form Settings</h4>
<p>Form Settings allows you to customize a lot of the messages and text in the controls for your form. It also allows you to pick a page to redirect users to after a successful form submission.</p>
<h4>Table-based Layout Options</h4>
<p>Table-layouts have gotten simpler, so your only option here is the position of the field names relative to the inputs. If you&#039;re using a Table/CSS layout, you can use this tab to select the field name positions.</p>
<h4>Template Layout Options</h4>
<p>This is where you do your customization work if your form uses a Custom Template.</p>
<p>The form should default to a a Custom template that documents the smarty tags available to you. Unless you&#039;re a smarty expert, you probably don&#039;t want to mess around with this. If you are a smarty expert, this is where you can unleash your magic.</p>
<h3>Adding Fields to your Form</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it&#039;s submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it&#039;s safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked &quot;Required&quot;, which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to &quot;view source&quot; on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It&#039;s really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It&#039;s really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
<li>Time Picker. This is a set of pulldowns allowing the user to select a time (using 12 or 24 hour clock).</li>
<li>Hidden Field. This allows you to embed a hidden field in your form.</li>
<li>File Upload. This is a file upload field.</li>
<li>Link (User Entered). This creates a double input field for getting a link URL and link title.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the &quot;From&quot; field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the &quot;From&quot; field.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Fieldset Start. Combined with Fieldset End, this allows you to group various fields within your form. Use this to start a given grouping.</li>
<li>-Fieldset End. Combined with Fieldset Start, this allows you to group various fields within your form. Use this to end a given grouping.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you&#039;re not using a Custom Template to render your form.</li>
<li>-Static Link. This allows you to put a link to a given page into your form. Optionally, you can have it autopopulate with the page where the form is embedded (useful if you\&#039;re sending results via email).</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<li>*Call a User Defined Tag With the Form Results. This submits all the form results to the User-Defined Tag you specify. The UDT can handle the results however it wants.</li>
<ul><li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these &quot;Director&quot; pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email to User-Supplied Address. This puts an input field in the form for the user to populate with an email address. The form results get sent to that address. Beware of Spam abuse! Active the primitive anti-spam features in the FormBuilder configuration screen.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered &quot;approved,&quot; and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the &quot;output&quot; directory under the
module&#039;s installation directory, assuming the web server has permission to write there.</li>
</ul></li></li></ul>

<h3>Email and Flat File Templates</h3>
<p>Many disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it&#039;s own best guess, which may or may not work out to your liking. You can always click on the &quot;Create Sample Template&quot; and then customize the results.</p>
<p>Note that once you&#039;ve changed a template, it will no longer automatically add new fields. For this reason, it&#039;s usually best to create your templates as the last step of creating your form.</p>

<h3>Known Issues</h3>
<ul>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder cannot yet be inlined. That should be a simple upgrade down the line.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn&#039;t matter since the user side is pretty simple.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you&#039;re running CMS 1.0-svn or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you&#039;re missing fields in an email that gets generated, check the disposition field&#039;s template, and make sure you&#039;re specifying the missing fields. Seems obvious, but it&#039;s an easy mistake to make.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is a fairly early version, if not a rank beta release, and it is probably still buggy. While I&#039;ve done all I can
to make sure no egregious bugs have crept in, I have to admit that during testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor&#039;s nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>.</li>
<li>Additional discussion of this module may also be found in the <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2007, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '		    <ul>
		    			  <li>Version 0.2.4
								<p>Big release:
								Added &quot;Email Form to User-Supplied Address&quot; disposition.
								Added &quot;TimePicker&quot; field type. Split &quot;Link&quot; field into a &quot;User-supplied Link&quot; field and a &quot;Static Link&quot; field.
								Added HTML email option and auto-templates for all email dispositions.
								Added primitive anti-spam features.
								Added XML-based import and export of forms.
								</p>
						  </li>
                    <li>Version 0.2.3
                      <p>Add the ability to call a selectable user defined tag upon disposition of the form.</p>
                    </li>
                    <li>Version 0.2.2
                       <p>Many thanks to Utter Design for sponsoring some changes and bugfixes, which include:
                          <ul>
                            <li>Added file upload capabilities to the email disposition</li>
                            <li>Add PageSetStart and PageSetEnd field types
                                <p>These field types allow you to create fieldsets in your form, and organise
                                   your fields logically for the user.  You can even nest fieldsets, and
                                   associate a style with them appropriately.  The default template was changed
                                   to prevent it from wrapping a div around these types of fields.
                                </p>
                            </li>
                            <li>Fixed a problem with DATETIME fields on install
                                <p>This solves a problem when on install the response table would sometimes not get created when using adodb lite</li>
                            </li>
                          </ul>
                       </p>
		    <li>Version 0.2 - 14 November 2006. Calguy &amp; tsw&#039;s bug fixes for field re-ordering and custom templates. Additional bug fixes for field labels.</li>
		    <li>Version 0.1 - 8 July 2006. Initial Release</li>
                    </ul>
		';
$lang['utmz'] = '156861353.1217483792.13.12.utmccn=(referral)|utmcsr=forum.cmsmadesimple.org|utmcct=/index.php/topic,22566.0.html|utmcmd=referral';
$lang['utma'] = '156861353.3824783600689563600.1212128768.1213255610.1217483792.13';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/nb_NO.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Skjema Bygger';
$lang['field_type_'] = 'Felttype ikke satt';
$lang['field_type_CatalogerItemsField'] = 'Velg en (eller flere) cataloger artikler';
$lang['field_type_FieldsetEnd'] = 'Feltgruppe Slutt';
$lang['field_type_FieldsetStart'] = 'Feltgruppe Start';
$lang['field_type_TextField'] = 'Tekst innskriving';
$lang['field_type_TextFieldExpandable'] = 'Tekst innskriving (Flere)';
$lang['field_type_TextAreaField'] = 'Tekstomr&aring;de';
$lang['field_type_CheckboxField'] = 'Avkrysningsboks';
$lang['field_type_CheckboxGroupField'] = 'Avkrysningsboks gruppe';
$lang['field_type_PulldownField'] = 'Nedtrekk';
$lang['field_type_MultiselectField'] = 'Multivalg';
$lang['field_type_StatePickerField'] = 'Amerikansk stat velger';
$lang['field_type_ProvincePickerField'] = 'Kanadisk provins velger';
$lang['field_type_CountryPickerField'] = 'Land velger';
$lang['field_type_DatePickerField'] = 'Dato velger';
$lang['field_type_TimePickerField'] = 'Tids-velger';
$lang['field_type_RadioGroupField'] = 'Radioknapp gruppe';
$lang['field_type_DispositionDirector'] = '*Sende resultater via epost basert p&aring; Nedtrekk';
$lang['field_type_DispositionFileDirector'] = '*Lagre resultatet til fil Basert p&aring; nedtrekk';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Lagre resultatet til fil(er) BAsert p&aring; Flere Valg';
$lang['field_type_DispositionPageRedirector'] = '*Omdiriger til Side Basert p&aring; Nedtrekk';
$lang['field_type_DispositionEmail'] = '*Sende resultater via epost til bestemte adresser';
$lang['field_type_DispositionEmailConfirmation'] = '*Validering-med-epostadresse';
$lang['field_type_DispositionFromEmailAddressField'] = '*Epost fra adresse&quot; felt, og send kopi';
$lang['field_type_DispositionFile'] = '*Skriv resultater til flat fil';
$lang['field_type_DispositionDatabase'] = '*Lagre resultater i databasen';
$lang['field_type_DispositionFormBrowser'] = '*Lagre resultater for FormBrowser modulen';
$lang['field_type_DispositionUserTag'] = '*Kall opp en Brukerdefinert Tagg med skjema resultatene';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Epost til Bruker-Oppgitt Epostadresse';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Epost til CMS Admin bruker';
$lang['field_type_PageBreakField'] = '-Sideskift';
$lang['field_type_FileUploadField'] = 'Fil opplasting';
$lang['field_type_FromEmailAddressField'] = 'Epost &quot;Fra adresse&quot; felt';
$lang['field_type_FromEmailAddressAgainField'] = 'Epost &quot;Fra adresse&quot; Igjen Felt';
$lang['field_type_FromEmailNameField'] = 'Epost &quot;Fra navn&quot; felt';
$lang['field_type_FromEmailSubjectField'] = 'Epost &quot;Emne&quot; felt';
$lang['field_type_StaticTextField'] = '-Statisk tekst';
$lang['field_type_SystemLinkField'] = '-Statisk lenke';
$lang['field_type_LinkField'] = 'Lenke (Bruker-oppgitt)';
$lang['field_type_HiddenField'] = '-Skjult Felt';
$lang['field_type_ComputedField'] = '-Beregnet felt';
$lang['field_type_UniqueIntegerField'] = '-Unik Integer (Seriell)';
$lang['validation_none'] = 'Ingen validering';
$lang['validation_numeric'] = 'Numerisk';
$lang['validation_integer'] = 'Integer ';
$lang['validation_email_address'] = 'Epostadresse';
$lang['validation_usphone'] = 'Telefonnummer (US)';
$lang['validation_must_check'] = 'M&aring; avkrysses';
$lang['validation_regex_match'] = 'Samsvarer vanlig uttrykk';
$lang['validation_regex_nomatch'] = 'Samsvarer ikke med vanlig uttrykk';
$lang['required_field_missing'] = 'En verdi er ikke oppgitt for et &#039;n&oslash;dvendig&#039;-felt';
$lang['please_enter_a_value'] = 'Vennligst skriv inn en verdi for &quot;%s&quot;';
$lang['please_enter_a_number'] = 'Vennligst skriv inn et tall for &quot;%s&quot;';
$lang['please_enter_valid'] = 'Vennligst skriv inn en gyldig verdi for &quot;%s&quot;';
$lang['please_enter_an_integer'] = 'Vennlgist skriv inn en integer verdi for &quot;%s&quot;';
$lang['please_enter_an_email'] = 'Vennligst skriv inn en gyldig epostadresse for &quot;%s&quot;';
$lang['email_address_does_not_match'] = 'Epostadressen er ikke lik verdien satt i &quot;%s&quot;';
$lang['please_enter_a_phone'] = 'Vennligst oppgi et gyldig US telefonnummer for&quot;%s&quot;';
$lang['not_valid_email'] = '&quot;%s&quot; ser ikke ut til &aring; v&aelig;re en gyldig epostadresse!';
$lang['please_enter_no_longer'] = 'Vennligst oppgi en verdi som ikke er lengre enn %s bokstaver';
$lang['title_list_delimiter'] = 'Tegn &aring; bruke som avdeler i resultater som har flere verdier';
$lang['you_need_permission'] = 'Du trenger &quot;%s&quot; rettigheten for kunne utf&oslash;re den handlingen.';
$lang['lackpermission'] = 'Beklager! Du har ikke nok rettigheter for &aring; f&aring; adgang til den avdelingen.';
$lang['field_order_updated'] = 'Felt rekkef&oslash;lge oppdatert.';
$lang['form_deleted'] = 'Skjema slettet.';
$lang['field_deleted'] = 'Felt slettet';
$lang['configuration_updated'] = 'Konfigurasjon oppdatert.';
$lang['you_must_check'] = 'Du m&aring; krysse av &quot;%s&quot; for &aring; fortsette.';
$lang['must_specify_one_destination'] = 'Du m&aring; oppgi i det minste en m&aring;l-adresse!';
$lang['are_you_sure_delete_form'] = 'Er du sikker p&aring; du vil slette skjemaet %s?';
$lang['are_you_sure_delete_field'] = 'Er du sikker p&aring; du vil slette feltet %s?';
$lang['notice_select_type'] = 'Avanserte valg er ikke tilgjengelig f&oslash;r felt-type har blitt satt.';
$lang['field_name_in_use'] = 'Felt navnet &quot;%s&quot; er allerede i bruk. Vennligst bruk unike feltnavn, eller sl&aring; av kravet til unike feltnavn i Skjemabygger konfigurasjonen.';
$lang['field_no_name'] = 'Felter M&Aring; navnes, om du da ikke sl&aring;r av dette i Form Builder konfigurasjonen.';
$lang['anonymous'] = 'Anonym';
$lang['abbreviation_length'] = 'Lengde: %s';
$lang['boxes'] = '%s bokser';
$lang['options'] = '%s valg';
$lang['text_length'] = '%s bokstaver';
$lang['order'] = 'Rekkef&oslash;lge';
$lang['unspecified'] = '[uspesifisert]';
$lang['added'] = 'Lagt til';
$lang['updated'] = 'Oppdatert';
$lang['sort_options'] = 'Sorteringsmuligheter for utdata';
$lang['select_one'] = 'Velg en';
$lang['select_type'] = 'Velg type';
$lang['to'] = 'Til';
$lang['yes'] = 'Ja';
$lang['no'] = 'Nei';
$lang['recipients'] = 'mottakere';
$lang['file_count'] = '%s mulige filer';
$lang['destination_count'] = '%s m&aring;l';
$lang['save'] = 'Lagre';
$lang['add'] = 'Lagg til';
$lang['update'] = 'Oppdater';
$lang['save_and_continue'] = 'Lagre og fortsett redigering';
$lang['information'] = 'Informasjon';
$lang['automatic'] = 'Automatisk';
$lang['forms'] = 'Skjema';
$lang['form'] = 'Skjema %s';
$lang['configuration'] = 'Konfigurasjon';
$lang['field_requirement_updated'] = 'Felt n&oslash;dvendig-status oppdatert';
$lang['maximum_size'] = 'Maks. st&oslash;rrelse';
$lang['permitted_extensions'] = 'Filendelser';
$lang['permitted_filetypes'] = 'Lovlige filtyper';
$lang['file_too_large'] = 'Opplastet fil er for stor! Maksimum st&oslash;rrelse er:';
$lang['illegal_file_type'] = 'Denne type fil vil ikke bli lastet opp. Vennligst sjekk at filendelsen er korrekt.';
$lang['upload'] = 'Last opp';
$lang['form_imported'] = 'Skjema importert.';
$lang['form_import_failed'] = 'Skjema import feilet! Det oppstod et problem med formattet p&aring; XML filen.';
$lang['rows'] = '%s rader';
$lang['cols'] = '%s kolonner';
$lang['12_hour'] = '12 -timers klokke';
$lang['24_hour'] = '24-timers klokke';
$lang['hour'] = 'Time';
$lang['min'] = 'Minutt';
$lang['merid'] = 'Meridian(AM/PM)';
$lang['date_range'] = 'Intervall: %s - %s';
$lang['thanks'] = 'Takk! Din innsending har blitt mottatt.';
$lang['edit'] = 'Rediger';
$lang['delete'] = 'Slett';
$lang['day'] = 'Dag';
$lang['mon'] = 'M&aring;ned';
$lang['year'] = '&Aring;r';
$lang['none'] = '(ingen)';
$lang['uninstalled'] = 'Modul avinstallert.';
$lang['installed'] = 'Modul versjon %s installert.';
$lang['upgraded'] = 'Modul oppgradert til versjon %s.';
$lang['button_previous'] = 'Tilbake...';
$lang['button_submit'] = 'Send skjema';
$lang['button_continue'] = 'Fortsett...';
$lang['value_checked'] = 'Avkrysset';
$lang['value_unchecked'] = 'Ikke avkrysset';
$lang['tab_main'] = 'Hoved';
$lang['tab_symbol'] = 'Skjemavisnings innstillinger';
$lang['tab_submit'] = 'Skjema innsending';
$lang['tab_captcha'] = 'Captcha innstillinger';
$lang['tab_advanced'] = 'Avanserte innstillinger';
$lang['tab_templatelayout'] = 'Mal layout valg';
$lang['tab_submissiontemplate'] = 'Innsendings mal';
$lang['canuse_smarty'] = '<em>Smarty variabler er gyldige i dette feltet.<em>';
$lang['add_options'] = 'Legg til flere valg';
$lang['delete_options'] = 'Slett markerte valg';
$lang['add_checkboxes'] = 'Legg til flere avkrysningsbokser';
$lang['delete_checkboxes'] = 'Slett markerte avkrysningsbokser';
$lang['add_address'] = 'Legg til annen adresse';
$lang['delete_address'] = 'Slett markert adresse';
$lang['add_destination'] = 'Legg til annet m&aring;l';
$lang['delete_destination'] = 'Slett markerte m&aring;l';
$lang['suspected_spam'] = 'For mange eposter er blitt generert fra din IP-adresse. Anti-Spam kode har stoppet leveringen.';
$lang['suspected_spam_log'] = 'Mistenkelig spam fra IP %s ble stoppet.';
$lang['reorder'] = 'Omsorter felter';
$lang['cancel'] = 'Avbryt';
$lang['value_set'] = 'Verdi satt: %s';
$lang['help_cataloger_attribute_fields'] = 'Nedenfor er en liste med atributtene som er tilgjengelige fra Cataloger modulen.<br/>
Du kan valgfritt spesifisere gyldige utvalg, verdier eller flere verdier som skal benyttes for &aring; filtrere listen med enheter som vises til brukeren.<br/>
<br/>
<strong>Utvalg:</strong><br/>
Utvalg(Ranges) kan spesifiseres ved &aring; implisere en minimum og maksimum verdi ved &aring; benytte denne syntaksen: &quot;range: minvalue to maxvalue&quot;<br/>
<br/>
<strong>Flere verdier:</strong><br/>
For &aring; spesifisere flere verdier for en atributt benytter du syntaksen &quot;multi: value1|value2|value3&quot;<br/>
<br/>
<strong>Verdier fra skjulte felt</strong><br/>
For &aring; spesifisere en verdi fra et skjult felt benytter du syntaksen {$fld_id}<br/>
<br/>';
$lang['help_name_regex'] = 'En regular expression for &aring; tillate filtrering av cataloger artikler etter navn';
$lang['help_field_height'] = 'H&oslash;yde p&aring; flervalgs feltet';
$lang['title_name_regex'] = 'Cataloger Item Name vanlig uttrykk';
$lang['title_field_height'] = 'Felt h&oslash;yde';
$lang['title_file_path'] = 'M&aring;lkatalog for utsending av filer';
$lang['title_udt_name'] = 'Brukerdefinert Tagg';
$lang['title_uploads_destpage'] = 'Side &aring; returnere til med opplastings lenken';
$lang['title_uploadmodule_summary'] = 'Innsendt med SkjemaBygger';
$lang['title_uploads_category'] = 'Opplastings Kategori';
$lang['title_sendto_uploads'] = 'Send denne filen til opplastings modulen';
$lang['title_legend'] = 'Feltgruppetittel';
$lang['title_maximum_length'] = 'Maksimum lengde';
$lang['title_checkbox_label'] = 'Avkrysningsboks etikett';
$lang['title_radio_label'] = 'Radioknapp etikett';
$lang['title_checked_value'] = 'Verdi n&aring;r avkrysset';
$lang['title_unchecked_value'] = 'Verdi n&aring;r ikke avkrysset';
$lang['title_checkbox_details'] = 'Avkrysningsboks gruppe detaljer';
$lang['title_delete'] = 'Slett?';
$lang['title_select_one_message'] = '&quot;Velg &eacute;n&quot; Text';
$lang['title_selection_value'] = 'Utvalg verdi';
$lang['title_selection_displayname'] = 'Utvalg Visnings Navn';
$lang['title_selection_subject'] = 'Utvalg emne';
$lang['title_select_default_country'] = 'Standard utvalg';
$lang['title_select_default_state'] = 'Standard utvalg';
$lang['title_select_default_province'] = 'Standard utvalg';
$lang['title_option_name'] = 'Valg navn';
$lang['title_option_value'] = 'Verdi sendt';
$lang['title_pulldown_details'] = 'Nedtrekks valg';
$lang['title_multiselect_details'] = 'Flervalg valg';
$lang['title_destination_address'] = 'M&aring;l epostadresse';
$lang['title_destination_filename'] = 'M&aring;l Filnavn';
$lang['title_email_from_name'] = '&quot;Fra navn&quot; for epost';
$lang['title_relaxed_email_regex'] = 'Bruk enkel epost verifisering';
$lang['title_relaxed_regex_long'] = 'Bruk enkel epostadresse verifisering (f.eks. tillat &quot;x@y&quot; istedet for &aring; kreve &quot;x@y.tld&quot;)';
$lang['title_email_from_address'] = '&quot;Fra adresse&quot; for epost';
$lang['title_email_encoding'] = 'Epost tegnsett koding';
$lang['title_director_details'] = 'Nedtrekk-baserte epost detaljer';
$lang['title_file_name'] = 'Filnavn';
$lang['title_email_subject'] = 'Epost Emne linje';
$lang['title_form_name'] = 'Fra navn';
$lang['title_form_status'] = 'Skjema status';
$lang['title_ready_for_deployment'] = 'Ferdig for anvendelse';
$lang['title_not_ready1'] = 'Ikke ferdig';
$lang['title_redirect_page'] = 'Side &aring; videresende til etter skjema sendt';
$lang['title_not_ready2'] = 'Vennligst legg til et felt til skjemaet s&aring; brukerens innskriving blir behandlet. Du kan ';
$lang['title_not_ready_link'] = 'bruk denne snarveien';
$lang['title_form_alias'] = 'Skjema alias';
$lang['title_form_fields'] = 'Skjemafelter';
$lang['title_field_id'] = 'Fielt Id';
$lang['title_show_fieldaliases'] = 'Vis felt aliaser';
$lang['title_show_fieldaliases_long'] = '&Aring; velge dette vil vise felt aliaser n&aring;r en legger til eller redigerer et skjema';
$lang['title_field_name'] = 'Felt navn';
$lang['title_field_alias'] = 'Felt alias';
$lang['title_radiogroup_details'] = 'Radioknapp gruppe detaljer';
$lang['title_field_type'] = 'Felt type';
$lang['title_not_ready3'] = 'for &aring; lage et skjema behandling felt';
$lang['title_add_new_form'] = 'Legg til nytt skjema';
$lang['title_show_version'] = 'Vis Skjema Bygger versjon?';
$lang['title_show_version_long'] = 'Dette vil innkapsle ditt versjonsnummer for Skjema bygger modulen i en kommentar, for &aring; hjelpe i feils&oslash;king';
$lang['title_add_new_field'] = 'Legg til nytt felt';
$lang['title_form_submit_button'] = 'Skjema &quot;Send&quot; tekst for knapp';
$lang['title_submit_button_safety'] = 'Legg til ett Javascript til Utf&oslash;r knappen for &aring; unng&aring; gjentatte innsendinger?';
$lang['title_submit_button_safety_help'] = 'Legg til Sikkerhets script';
$lang['title_form_next_button'] = 'Skjema &quot;Neste&quot; tekst for knapp (brukt p&aring; flersiders skjemaer)';
$lang['title_form_prev_button'] = 'Skjema &quot;Forrige&quot; tekst for knapp (brukt p&aring; flersiders skjemaer)';
$lang['title_field_validation'] = 'Feltsjekk';
$lang['title_field_to_validate'] = 'Felt &aring; sjekke';
$lang['title_form_css_class'] = 'CSS klasse for dette skjema';
$lang['title_field_css_class'] = 'CSS klasse for dette felt';
$lang['title_form_required_symbol'] = 'Symbol for &aring; merke n&oslash;dvendige felt';
$lang['title_field_required'] = 'N&oslash;dvendig';
$lang['title_field_required_long'] = 'Krev en respons for dette felt';
$lang['title_hide_label'] = 'Skjul etikett';
$lang['title_hide_label_long'] = 'Skjul dette feltets navn p&aring; skjemaet';
$lang['title_text'] = 'Statisk tekst &aring; vise';
$lang['title_field_regex'] = '(Regex) sjekk';
$lang['title_lines_to_show'] = 'Antall linjer &aring; vise';
$lang['no_default'] = 'Ingen standard';
$lang['redirect_after_approval'] = 'Side &aring; videresende til etter godkjenning';
$lang['title_regex_help'] = 'Dette vanlige uttrykket vil bare bli brukt om &quot;validerings type&quot; er satt til regex-relatert valg. Inkluder full Perl-stil regex, inkludert start/stopp slasher og flagg (f.eks. &quot;/image\.(\d+)/i&quot;)';
$lang['title_field_required_abbrev'] = 'Oblig.';
$lang['title_hide_errors'] = 'Skjul feil';
$lang['title_form_displaytype'] = 'Skjema visnings type';
$lang['title_hide_errors_long'] = 'Hindre feils&oslash;king / feil-meldinger fra &aring; vises til brukeren.';
$lang['title_email_template'] = 'Epost mal';
$lang['title_maximum_size'] = 'Maksimum opplasting filst&oslash;rrelse (kilobytes)';
$lang['title_maximum_size_long'] = 'Denne begrensning er et tillegg til enhver grense satt av php eller webserver konfigurasjonen';
$lang['title_permitted_extensions'] = 'Godkjente filendelser';
$lang['title_permitted_extensions_long'] = 'Skriv en komma-separert liste, utelatt punktum (f.eks. &quot;jpg,gif,jpeg&quot;). Mellomrom vil bli ignorert. &Aring; la dette v&aelig;re tomt vil si ingen restriksjoner.';
$lang['title_show_limitations'] = 'Vis restriksjoner?';
$lang['title_show_limitations_long'] = 'Vis st&oslash;rrelse eller filendelse-restriksjoner p&aring; opplastingsfeltet?';
$lang['title_form_template'] = 'Mal &aring; bruke for &aring; vise skjema';
$lang['title_page_x_of_y'] = 'Side %s av %s';
$lang['title_no_advanced_options'] = 'Feltet har ingen avanserte valg.';
$lang['title_form_unspecified'] = 'Tekst &aring; vise for uspesifiserte felt verdier';
$lang['title_enable_fastadd_long'] = 'Muliggj&oslash;r rask felt-tillegging med nedtrekk for skjemaer?';
$lang['title_enable_fastadd'] = 'Muliggj&oslash;r nedtrekk for hurtig tillegging av felter?';
$lang['title_fastadd'] = 'Hurtig-tillegg av felter';
$lang['title_enable_antispam_long'] = '&Aring; hake av dette vil kun tillate 10 eposter &aring; blir generert fra en gitt IP adresse (pr time).';
$lang['title_enable_antispam'] = 'Sl&aring; p&aring; primitive antispam egenskaper?';
$lang['title_show_fieldids'] = 'Vis Felt IDer';
$lang['title_show_fieldids_long'] = '&Aring; hake av dette vil tillate visning av felt ider under opprettelse eller redigering av et skjema';
$lang['title_xml_to_upload'] = 'Last opp skjema som XML fil';
$lang['title_xml_upload_formname'] = 'Benytt dette skjemanavnet';
$lang['title_import_legend'] = 'XML Skjema import';
$lang['title_xml_upload_formalias'] = 'Benytt dette skjema aliaset';
$lang['title_html_email'] = 'Generer HTML epost?';
$lang['title_link_autopopulate'] = 'Fyll ut automatisk?';
$lang['title_link_autopopulate_help'] = 'Fyll ut automatisk med URL&#039;en til siden som inneholder skjemaet? (dette overstyrer Lenke til nettsted side valget nedenfor)';
$lang['title_default_link'] = 'Standard lenke URL';
$lang['title_default_link_title'] = 'Standard lenke tekst';
$lang['title_link_to_sitepage'] = 'Lenke til nettsted side';
$lang['title_captcha_not_installed'] = 'Du kan benytte <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a> for &aring; beskytte skjema innsendinger om du installerer Captcha modulen. For mere informasjon, <a href="http://dev.cmsmadesimple.org/projects/captcha/">check the Captcha project</a>.';
$lang['title_use_captcha'] = 'Bruke Captcha for &aring; beskytte skjema innsendinger?';
$lang['title_use_captcha_help'] = 'Hak av her for &aring; beskytte ditt skjema med en <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a>.';
$lang['title_user_captcha'] = 'Vennligst bekreft at du ikke er et skript ved &aring; skrive inn bokstavene fra bildet.';
$lang['title_user_captcha_error'] = 'Feil tekst for Captcha';
$lang['wrong_captcha'] = 'Captcha teksten ble ikke korrekt innskrevet.';
$lang['title_title_user_captcha'] = 'Hjelpetekst for Captcha';
$lang['title_dont_submit_unchecked'] = 'Ikke send verdier for ikke-avkryssede bokser';
$lang['title_dont_submit_unchecked_help'] = 'Hak av denne om du kun vil at avkryssede bokser skal gi verdier.';
$lang['link_label'] = 'Lenke etikett';
$lang['link_destination'] = 'Lenke m&aring;l URL';
$lang['title_default_set'] = 'Avkrysset som standard?';
$lang['title_24_hour'] = 'Benytt 24-timers klokke?';
$lang['title_before_noon'] = 'AM ';
$lang['title_after_noon'] = 'PM ';
$lang['title_smarty_eval'] = 'Prosesser smarty tagger inni felter?';
$lang['title_textarea_rows'] = 'Rader (merk: dette kan bli overstyrt av CSS)';
$lang['title_textarea_cols'] = 'Kolonner (merk: dette kan bli overstyrt av CSS)';
$lang['title_form_main'] = 'Hoved Skjema Detaljer';
$lang['title_show_username'] = 'Vis Innloggingsnavn(login name)?';
$lang['title_show_userfirstname'] = 'Vis brukerens fornavn?';
$lang['title_show_userlastname'] = 'Vis brukerens etternavn?';
$lang['title_restrict_to_group'] = 'Begrens brukerlisten til brukere i en spesifik gruppe';
$lang['restricted_to_group'] = 'Kun i gruppe %s';
$lang['title_show_to_user'] = 'Vis til bruker?';
$lang['help_leaveempty'] = 'Dette feltet kan du la v&aelig;re blankt';
$lang['help_variables_for_template'] = 'Variabler for mal';
$lang['help_variables_for_computation'] = 'Tilgjengelige variabler';
$lang['help_php_variable_name'] = 'PHP variabel';
$lang['help_submission_date'] = 'Dato for innlevering';
$lang['help_server_name'] = 'Din server';
$lang['help_sub_source_ip'] = 'IP adresse til personen som bruker skjemaet';
$lang['help_sub_url'] = 'Link til siden som inneholder skjemaet';
$lang['help_fb_version'] = 'FormBuilder versjon';
$lang['help_tab'] = 'Tabular tegn';
$lang['help_other_fields'] = 'Altenative feltnavn kan benyttes utbyttbart (spesielt nyttig om Smarty protesterer p&aring; bokstaver utenfor ASCII 32-126). <br />Andre felt vil bli tilgjengelige n&aring;r du legger dem til skjemaet.';
$lang['help_array_fields'] = 'Yet another way of accessing field values is via $fieldname_obj, $alias_obj, or $fld_#_obj, where each field is an object containging:<br /><table>
<tr><td class=&quot;odd&quot;>name</td><td class=&quot;odd&quot;>Field Name</td></tr>
<tr><td>type</td><td>Field Type</td></tr>
<tr><td class=&quot;odd&quot;>id</td><td class=&quot;odd&quot;>Internal Field ID</td></tr>
<tr><td>value</td><td>Human-readable Value</td></tr>
<tr><td class=&quot;odd&quot;>valueArray</td><td class=&quot;odd&quot;>Array of field value(s)</td></tr></table><em>e.g.</em>, you could use &quot;{$fld_1_obj->name} = {$fld_1_obj->value}';
$lang['help_date_format'] = 'Se <a href=&#039;http://www.php.net/manual/en/function.date.php&#039; target=_NEW>the PHP Manual</a> for formatterings hjelp.';
$lang['help_variable_name'] = 'Variabel';
$lang['help_form_field'] = 'Felt representert';
$lang['link_back_to_form'] = '&laquo; Tilbake til skjema';
$lang['title_create_sample_template'] = 'Lag eksempelmal';
$lang['title_create_sample_html_template'] = 'Opprett Eksempel HTML-epost mal';
$lang['title_create_sample_header_template'] = 'Opprett Eksempel Header mal';
$lang['title_create_sample_header'] = 'Lag eksempel overskrift';
$lang['help_tab_symbol'] = 'et tabulator tegn';
$lang['title_file_template'] = 'Mal for &eacute;n linje av utdata filen';
$lang['title_file_header'] = 'Mal for overskriften p&aring; utdata filen';
$lang['title_confirmation_url'] = 'Link &aring; klikke for skjema bekreftelse';
$lang['title_value'] = 'Verdi (se Avansert fliken om du benytter Smarty tagger)';
$lang['title_date_format'] = 'Dato format (standard <a href="http://www.php.net/manual/en/function.date.php">PHP Date Formats</a>)';
$lang['title_use_wysiwyg'] = 'Bruke WYSIWYG redigerer for tekst omr&aring;det?';
$lang['title_submit_actions'] = 'Oppf&oslash;rsel for Skjema Innsending';
$lang['title_submit_labels'] = 'Etikett for Innsendingsknappen';
$lang['title_sortable_field'] = 'Sorterbart felt #%s';
$lang['title_submit_help'] = 'Denne siden lar deg tilpasse Skjema Innsending. Det bestemmer ikke hva Skjema Bygger gj&oslash;r med de innsendte data. Dette kan du sette opp ved &aring; legge til &quot;Disposisjon&quot;(gemytt) felter til ditt skjema.';
$lang['title_start_year'] = '&Aring;rsintervall start';
$lang['title_end_year'] = '&Aring;rsintervall slutt';
$lang['title_default_year'] = 'Standard &aring;r';
$lang['title_default_year_help'] = '(Sett til -1 for at standard &aring;r skal bli n&aring;v&aelig;rende &aring;r)';
$lang['title_submit_action'] = 'Etter skjemaet er sendt';
$lang['title_submit_response'] = 'Respons som skal vises';
$lang['display_text'] = 'Vis &quot;Innsendings mal&quot;';
$lang['redirect_to_page'] = 'Omdiriger til nettside';
$lang['title_submit_response_help'] = 'Denne malen er for det som skal vises til brukeren etter et skjema er innsendt. Denne malen har ingen virkning p&aring; epost som genereres eller andre skjemagemytter  -- du setter de malene (hvor det er relevant) i &quot;avansert&quot; fliken p&aring; disse gemyttenes felter.';
$lang['title_destination_page'] = 'M&aring;l Side';
$lang['title_require_fieldnames'] = 'Krev Feltnavn';
$lang['title_require_fieldnames_long'] = 'Krev at felter skal ha ett navn?';
$lang['title_unique_fieldnames'] = 'Krev unike felnavn';
$lang['title_unique_fieldnames_long'] = 'Krev at felter skal ha unike feltnavn?';
$lang['title_reorder_form'] = 'Omsorter felter';
$lang['title_load_template'] = 'Last mal';
$lang['title_add_button_text'] = 'Legg til Knapp tekst';
$lang['title_del_button_text'] = 'Slett Knapp tekst';
$lang['title_string_or_number_eval'] = 'Fortolk variabler til &aring; v&aelig;re nummer eller strenger';
$lang['title_order'] = 'Tolkningsrekkerf&oslash;lge';
$lang['title_order_help'] = 'Om mer enn et Beregnet felt eksisterer, vil de bli beregnet fra det laveste rekkef&oslash;lgenummeret til det h&oslash;yeste rekkef&oslash;lgenummeret';
$lang['title_compute_value'] = 'Verdi &aring; beregne';
$lang['title_string'] = 'Streng';
$lang['title_numeric'] = 'Nummerisk';
$lang['title_inline_form'] = 'Vis skjema inline?';
$lang['title_inline_form_help'] = 'Med Inline menes at enhver videref&oslash;ring erstatter {cms_module} taggen, non-inline erstatter {content} taggen.';
$lang['title_field_default_value'] = 'Standard verdi for felt';
$lang['title_clear_default'] = 't&oslash;m standard ved klikk?';
$lang['title_clear_default_help'] = 'Hak av denne om du vil at standard verdi skal fjernes n&aring;r brukeren klikker i dette feltet. Siden dette benytter en javaskript string sammenligning vil dette feile om du setter enkle anf&oslash;rselstegn i din standardtekst. Andre ikke-javaskript egnede tegn kan ogs&aring; f&aring; dette til &aring; feile.';
$lang['title_remove_file_from_server'] = 'Slett opplastede filer fra serveren etter prosessering (epost disposisjoner)';
$lang['title_field_javascript'] = 'Javascript for felt';
$lang['title_field_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;';
$lang['title_submit_javascript'] = 'Skjemainnsendings javaskript';
$lang['title_submit_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;.<br />This will probably not work well if you use the &quot;safety script&quot; option above.';
$lang['email_from_addr_help'] = 'Ikke bare sett en tilfeldig adresse her -- mange ISPer vill<br />ikke levere eposten om du benytter et annet domenenavn enn ditt faktiske<br />vertsnavn (f.eks. benytt noe som name@%s)';
$lang['title_switch_advanced'] = 'Behov for flere telttyper? ';
$lang['title_switch_basic'] = 'For mange forvirrende felttyper? ';
$lang['title_switch_advanced_link'] = 'Bytt til avansert modus';
$lang['title_switch_basic_link'] = 'Bytt til enkel modus';
$lang['title_file_root'] = 'Katalog &aring; lagre filen i';
$lang['title_file_root_help'] = 'Dette m&aring; v&aelig;re en katalog som din webserver har rettighet til &aring; skrive i.<br />Chmod den til 777 om du har problemer/tviler.<br />Og, se etter at du ikke har PHP katalog restriksjoner.';
$lang['title_newline_replacement'] = 'Ny linje/Linjeskift(Newline/Carriage Return) erstatningstegn';
$lang['title_newline_replacement_help'] = 'La dette v&aelig;re blankt for &aring; tillate Ny linje/Linjeskift i resultatvisningen';
$lang['title_send_usercopy'] = 'Send brukieren en kopi av innsendingen?';
$lang['title_send_usercopy_label'] = 'Etikett for avkryssningsboks (om brukeren velger)';
$lang['title_send_me_a_copy'] = 'Send meg en kopi av skjemaet';
$lang['title_allow_subject_override'] = 'Tillat Emne(subject) &aring; bli overstyrt?';
$lang['title_allow_subject_override_long'] = 'Tillat &#039;Epost &quot;Subject&quot; felter&#039; &aring; overstyre Emne(subject) spesifisert i netrekksvalget.';
$lang['option_never'] = 'Aldri';
$lang['option_user_choice'] = 'Gi brukeren et valg (avkryssningsboks)';
$lang['option_always'] = 'Alltid';
$lang['error_cataloger_module_not_available'] = '<strong>Cataloger modulen ser ikke ut til &aring; v&aelig;re installert/aktiv.</strong>';
$lang['warning'] = 'ADVARSEL!';
$lang['default_template'] = 'Standard mal';
$lang['table_left_template'] = 'Tabell mal, Etikett til venstre';
$lang['table_top_template'] = 'Tabell mal, Etikett overfor';
$lang['form_template_name'] = 'Mal fra %s';
$lang['template_are_you_sure'] = 'Er du sikker p&aring; at du vil overskrive din mal med den valgte malen? (Selv om du svarer OK, vil du fortsatt m&aring;tte lagre endringen)';
$lang['title_bad_function'] = 'Feil under beregning &quot;%s&quot;.';
$lang['no_referrer_info'] = 'Ingen HTTP_REFERER informasjon tilgjengelig';
$lang['validation_param_error'] = 'Gyldighetssjekk Parameter feil. Vennligst sjekk at du kopierte linken fra din epost korrekt!';
$lang['validation_response_error'] = 'Gyldighetssjekk Respons feil. Vennligst sjekk at du kopierte linken fra din epost korrekt!';
$lang['validation_no_field_error'] = 'Gyldighetssjekk Respons feil. Ingen epost-sjekk felt i dette skjema';
$lang['upgrade03to04'] = 'Skjema malen ble oppdatert automagisk som del av oppgradering fra versjon 0.3 til versjon 0.4. Du trenger kanskje &aring; gj&oslash;re noen manuelle fikser. Om du benytter standardskjemaet, kan du enkelt bytte det med &quot;default&quot; ved &aring; benytte nedtrekkmenyen ovenfor.';
$lang['admindesc'] = 'Legg til, rediger og h&aring;ndter interaktive skjemaer';
$lang['operators_help'] = 'Om du benytter Streng)String) evaluering, den eneste operasjon tilgjengelig er kobling (+), men om du benytter Nummer(Number) evaluering s&aring; har du de helt enkle matematiske (,+, -, *, /,)';
$lang['date_january'] = 'Januar';
$lang['date_february'] = 'Februar';
$lang['date_march'] = 'Mars';
$lang['date_april'] = 'April ';
$lang['date_may'] = 'Mai';
$lang['date_june'] = 'Juni';
$lang['date_july'] = 'Juli';
$lang['date_august'] = 'August ';
$lang['date_september'] = 'September ';
$lang['date_october'] = 'Oktober';
$lang['date_november'] = 'November ';
$lang['date_december'] = 'Desember';
$lang['submission_error'] = 'Beklager! Det skjedde en feil under behandling av din skjema innsending.';
$lang['submit_error'] = 'SkjemaBygger Sendefeil: %s';
$lang['uploads_error'] = 'Feil ved overf&oslash;ring av fila til opplastingsmodulen: %s';
$lang['nouploads_error'] = 'Kunne ikke finne Opplastingsmodulen';
$lang['upload_attach_error'] = 'Opplasting/Vedlegg feil p&aring; fil %s (temp_navn: %s, av type %s)';
$lang['submission_error_file_lock'] = 'Feil. Umulig &aring; erverve l&aring;s for filen.';
$lang['unchecked_by_default'] = 'Standard: ikke avhaket';
$lang['checked_by_default'] = 'Standard: avhaket';
$lang['email_default_template'] = 'SkjemaBygger innsending';
$lang['email_template_not_set'] = '<br/>Epost mal enn&aring; &aring;ikke angitt!';
$lang['missing_cms_mailer'] = 'SkjemaBygger: Kan ikke finne n&oslash;dvendig modul CMSMailer!';
$lang['user_approved_submission'] = 'Bruker godkjent sending %s fra %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Hendelse satt i gang n&aring;r et SkjemaBygger skjema blir innlevert';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Hendelse satt i gang om det skjer en feil n&aring;r et SkjemaBygger skjema blir innlevert';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Hendelse satt i gang n&aring;r et SkjemaBygger skjema blri vist';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Hendelse satt i gang n&aring;r et Skjema_Bygger skjema blir sendt.</p>
<h4>Parametere</h4>
<ul>
<li><em>form_name</em> - Skjema navnet (string)</li>
<li><em>form_id</em> - Den interne Skjema id (int)</li>
<li><em>value_&amp;lt;name&amp;gt;</em> - Tilf&oslash;r en standard verdi til et felt med det opgitte navnet.</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Hendelse satt i gang om det skjer en feil n&aring;r et SkjemaBygger skjema blir sendt</p>
<h4>Parametere</h4>
<ul>
<li><em>form_name</em> - Skjema navnet (string)</li>
<li><em>form_id</em> - Den interne skjema id (int)</li>
<li><em>error</em> - En liste med alle kjente feil (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Hendelse satt i gang n&aring;r et SkjemaBygger skjema blri vist</p>
<h4>Parametere</h4>
<ul>
<li><em>form_name</em> - Skjema navnet (string)</li>
<li><em>form_id</em> - Den interne skjema id (int)</li>
</ul> ';
$lang['formbuilder_params_response_id'] = 'Response ID. Brukt av SkjemaUtforsker(FormBrowser)';
$lang['formbuilder_params_passed_from_tag'] = 'Standard felverdier - se modulhelp for info';
$lang['formbuilder_params_field_id'] = 'Felt ID for interne operasjoner';
$lang['formbuilder_params_form_name'] = 'Skjemanavn';
$lang['formbuilder_params_form_id'] = 'Skjema ID for interne operasjoner';
$lang['formbuilder_params_general'] = 'Generelle parametre for interne operasjoner';
$lang['template_variable_help'] = '<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the &amp;#123;$fb_hidden} and &amp;#123;$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., &amp;#123;$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>';
$lang['post_install'] = '<p>Husk &aring; sette &quot;Modify Forms&quot; rettigheter til brukere som skal administrere tilbakemeldings-skjemaer. Og om du vil sende skjema resultater via epost, husk &aring; oppdater innstillingene tilstrekkelig.</p>

<p>V&aelig;r oppmerksom p&aring; at tilbakemeldings skjemaet ikke skal v&aelig;re aktivt (f.eks. tilgjengelig for publikum) n&aring;r du fortsatt redigerer skjemaet. Du b&oslash;r lage skjemaet, og plassere taggen i en aktiv innholdside bare n&aring;r du er ferdig med &aring; redigere. Ellers, kan feilaktige resultater bli returnert.</p>

<p>Obs! Denne versjonen st&oslash;tter ikke parallell redigering av skjemaer. V&aelig;r sikker p&aring; at kun &eacute;n admin  redigerer et gitt skjema p&aring; samme tid.</p>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create feedback forms (in fact, it&#039;s a replacement of the original Feedback Form module), with the added power of database storage. With its companion module Form Browser, you can use it to create simple database applications.</p>
<p>The forms created using the Form Builder may be inserted
into templates and/or content pages. Forms may contain many kinds of inputs, and may have
validation applied to these inputs. The results of these forms may be handled in a variety of ways.</p>

<h3>How Do I Use it?</h3>
<P>Install it, and poke around the menus. Play with it. Try creating forms, and adding them to your content.
If you get stuck, chat with me on the #cms IRC channel, post to the forum, send me email, or, if you&#039;re
really desperate, try reading the instructions on the rest of this page.</P>

<h3>How Do I Create a Form</h3>
<p>In the CMS Admin Menu, you should get a new menu item called FormBuilder. Click on this. On the page
that gets shown, there are options (at the bottom of the list of Forms) to Add a New Form or Modify
Configuration.</p>

<h3>Adding a Form to a Page</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module=&#039;FormBuilder&#039; form=&#039;sample_form&#039;}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page&#039;s content if you use a WYSIWYG editor such as TinyMCE, FCKEdit, or HTMLArea. These editors may stealthily
change the quote marks (&quot;) into HTML entities (&amp;amp;quot;), and the forms will not show up. Try using
single quotes (&#039;) or editing the HTML directly.</p>

<h3>Working with Forms</h3>
<p>By clicking on a Form&#039;s name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you&#039;ll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing.</p>
<p>Below this, if you have it enabled, is the &quot;fast field adder&quot; pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Form Submission</h4>
<p>When the form is submitted, you can either redirect the user to another page of your site, or you can present the user some message (which can contain any of the user&#039;s form entries, or just static text). In this tab, you select which of these approaches you wish to use, and, if you chose redirection, it allows you to pick the page to redirect users to after a successful form submission.</p>
<p>Also on this page, you can specify the labels of various submission buttons (&quot;Previous&quot;, &quot;next&quot;, &quot;submit&quot;). You can also opt to have some Javascript added to the last page of a form that will prevent multiple submissions (useful on slow servers).</p>
<h4>Form Display Options</h4>
<p>This tab allows for other form customizations, like the symbol to show for required fields.</p>
<h4>Captcha Settings</h4>
<p>If you have installed the Captcha module, this tab lets you configure the Captcha settings for your form.</p>
<h4>Form Template</h4>
<p>This is where you do your customization work of your form&#039;s Smarty Template. See the section called Form Template Variables below.</p>
<p>The form should default to a Custom template that documents the Smarty tags available to you.</p>
<p>Unless you&#039;re a Smarty expert, you probably don&#039;t want to mess around with this. If you are a Smarty expert, this is where you can unleash your magic.</p>
<h4>Submission Template</h4>
<p>If, in the Form Submission tab, you selected &#039;Display &quot;Submission Template&quot;, this is where you can create that template. There is a display of which smarty variables are available to you, and a button to generate a sample template.</p>
<p>If you&#039;re a Smarty expert, you can do all manner of creative and powerful things here. If you&#039;re not a Smarty expert, you might just want to use the default.
</p>

<h3>Adding Fields to your Form</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it&#039;s submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it&#039;s safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked &quot;Required&quot;, which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to &quot;view source&quot; on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It&#039;s really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It&#039;s really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Canadian Province. This is a pulldown listing the Canadian Provinces (Contributed by Noel McGran. Thanks!)</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
<li>Time Picker. This is a set of pulldowns allowing the user to select a time (using 12 or 24 hour clock).</li>
<li>File Upload. This is a file upload field.</li>
<li>Link (User Entered). This creates a double input field for getting a link URL and link title.</li>
<li>Text Field (Multiple). This field creates one or more text inputs with add and delete buttons, effectively giving the end user a way of creating variable-length lists.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the &quot;From&quot; field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the &quot;From&quot; field.</li>
<li>Email Subject Field. This allows users to provide a subject for their email. The email generated when the form gets handled will use this in the &quot;Subject&quot; field. This may cause trouble with certain dispositions that want to control the Email Subject, so use it with caution.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Fieldset Start. Combined with Fieldset End, this allows you to group various fields within your form. Use this to start a given grouping.</li>
<li>-Fieldset End. Combined with Fieldset Start, this allows you to group various fields within your form. Use this to end a given grouping.</li>
<li>-Hidden Field. This allows you to embed a hidden field in your form.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you&#039;re not using a Custom Template to render your form.</li>
<li>-Static Link. This allows you to put a link to a given page into your form. Optionally, you can have it autopopulate with the page where the form is embedded (useful if you&#039;re sending results via email).</li>
<li>-Computed Field. This allows you to embed a computed field in your form. It is not visible to the user until after the form is submitted. It allows you to do simple arithmetic or string concatenation.</li>
<li>-Unique Integer (Serial). This is an integer that increases every time someone hits your form. Your results may not be sequential, but they will increase monotonically.</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<ul><li>*Call a User Defined Tag With the Form Results. This submits all the form results to the User-Defined Tag you specify. The UDT can handle the results however it wants. Values are passed as $param[&#039;field_name&#039;].</li>
<li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these &quot;Director&quot; pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email to User-Supplied Address. This puts an input field in the form for the user to populate with an email address. The form results get sent to that address. Beware of Spam abuse! Active the primitive anti-spam features in the FormBuilder configuration screen.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Redirect to Page Based on Pulldown. This allows you to redirect the form to a different site page depending on its value. If you have multiple dispositions, make sure this is used last.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered &quot;approved,&quot; and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the &quot;output&quot; directory under the
module&#039;s installation directory, assuming the web server has permission to write there.</li>
<li>*Save Results to File Based on Pulldown. Like the Flat File disposition, except the value of a pull-down determines which file results get written to.</li>
<li>*Save Results to File(s) Based on Multiple Selections. Like the Flat File disposition, except the value(s) of checkboxes  determines which file(s) results get written to.</li>
<li>*Email to CMS Admin User. Provides a pull-down of CMS Admin users, and directs the results as an email to the selected admin.</li>
<li>*Store Results for FormBrowser Module v.3. Stores the form results in an XML structure as a single database record. This will become the interface to Form Browser in the next release.</li>

</ul></li></li></ul>


<h3>Passing Default Values to Forms</h3>
<p>Calguy added a nice feature, which is that you can pass default field values to your form via the module tag. This allows you to have
the same form in multiple places, but with different default values. It may not work for more exotic field types, but for fields that have
a single value, you can specify like:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_<i>FIELDNAME</i>=&#039;default_value&#039;}</p>
<p>This will set the field with <i>FIELDNAME</i> to &#039;default_value&#039;.</p>
<p>This can be problematic, as sometimes field names are unweildy or contain characters that don&#039;t work well with Smarty. So there is an
alternative like this:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_fld<i>NUMBER</i>=&#039;default_value&#039;}</p>
<p>That uses field <i>NUMBER</i>, where <i>NUMBER</i> is the internal FormBuilder field id. You might wonder how you know what that id is. Simply go into the FormBuilder configuration tab,
and check &quot;Show Field IDs&quot;</p>

<h3>Email and Flat File Templates</h3>
<p>Many disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it&#039;s own best guess, which may or may not work out to your liking. You can always click on the &quot;Create Sample Template&quot; and then customize the results.</p>
<p>To the right, you&#039;ll find a legend which lists all of the variables that are available to you to use in your template. As of version 0.3, variables have two names, one based on the field name, the other based on the field ID. If you use field names that have characters outside of the ASCII 32-126 range, it will be safer to use the ID-based variables.</p>
<p><strong>Note that once you&#039;ve changed a template, it will no longer automatically add new fields.</strong> For this reason, it&#039;s usually best to create your templates as the last step of creating your form.</p>
<p>As of version 0.2.4, you can opt to send any of these emails as HTML email. There should be a checkbox at the top of the template page for this. There is also a &quot;Create Sample HTML Template&quot; button over in the legend area. For HTML email, the email body will also provide the default text-only values.</p>

<h3>Configuration</h3>
<p>There are some global configuration options for FormBuilder:</p>
<ul>
<li>Enable fast field add pulldown. This enables the pulldown on the Form Edit page which saves a step in the creation of new fields.</li>
<li>Hide Errors. This is set by default. Unchecking it will cause more detailed errors to be displayed if there are problems when you submit your form.</li>
<li>Require Field Names. Typically, you will want form fields to be named so you can tell which is which. However, in some cases, you might want to have nameless fields. Uncheck this if you want to allow nameless fields.</li>
<li>Unique Field Names. Typically, you will want form fields to have unique names so you can tell which is which. Uncheck this if you want to allow fields to share names.</li>
<li>Use relaxed email validation. This uses a less restrictive regular expression for validating email; e.g., x@y will be allowed, where typically x@y.tld is required.</li>
<li>Show Form Builder Version. Displays the version of FormBuilder you&#039;re using in a comment when the form is generated. Typically only useful when debugging.</li>
<li>Enable primitive anti-spam features. When turned on, this allows any given IP address to only generate 10 emails per hour.</li>
<li>Show Field IDs. When turned on, FormBuilder will display field ids when adding or editing a form.</li>
</ul>
<h3>Styling and CSS</h3>
<p>Paul Noone graciously provides us all with a pretty good standard CSS that you can use for forms:</p>
<pre>
	/* Sample FormBuilder CSS base */
	form {margin-top:0}
	form, td, th, li { font-size: 100%}
	form div {margin-bottom:0}
	fieldset div {
		margin-bottom:0.5em;
		margin-left:1em;
	}
	fieldset div div {
		margin-top:0.5em;
		margin-left:1em
	}
	fieldset {
		margin-bottom:1em;
		border:1px solid #F60;
		padding:0.5em
	}
	fieldset label {
		width:auto;
	}
	legend {
		color:#FFF;
		background:#F60;
		font-style:italic;
		font-size:1.2em;
		margin-bottom:0.5em;
		padding:0.2em;
		width:auto;
		border:1px solid #CCC
	}
	textarea {
		margin: 0.5em 0;
		width:98%;
		height: 6em
	}

	/* Apply this class to text/select input fields with shorter labels
		to help alignment */
	.short-label label {float:left; width:10em}
	.short-label fieldset div input,
	.short-label fieldset div select {width:16em}

	/* Pretty up your Captcha image output */
	.captcha {
		margin:0.5em 0;
		width:200px;
		text-align:center
	}
	.captcha img {border:1px solid #F60; margin-bottom:0.5em}
	.captcha input {width:196px; margin-top:0.5em}

	/* Just a bit more room for the Submit button */
	.submit {margin-top:0.5em}
</pre>

<h3>Form Template Variables</h3>

<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the &amp;#123;$fb_hidden} and &amp;#123;$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., &amp;#123;$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for label for=&quot;foo&quot;)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>


<h3>Known Issues</h3>
<ul>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn&#039;t matter since the user side is pretty simple.</li>
<li>FileUpload Fields may not work correctly with multipage forms.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you&#039;re running CMS 1.1 or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you&#039;re missing fields in an email that gets generated, check the disposition field&#039;s template, and make sure you&#039;re specifying the missing fields. Seems obvious, but it&#039;s an easy mistake to make.</li>
<li>Uncheck the &quot;Hide Errors&quot; checkbox in the global options, and see what message gets displayed when you submit your form.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is no longer a particularly early version, but it is probably still buggy. While I&#039;ve done all I can
to make sure no egregious bugs have crept in, I have to admit that during early testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor&#039;s nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href="mailto:sjg@cmsmodules.com">&amp;lt;sjg@cmsmodules.com&amp;gt;</a>.</li>
<li>Additional discussion of this module may also be found in the <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
<li>Donations are good motivators, too. Keep in mind that the dollar is weak, and if you are not in the US, your donation gets magnified.</li>
</ul>
<p>Keep in mind that the author has put hundreds and hundreds of hours into the development of this module. Please take the time to read the documentation before sending questions. Either that, or send your questions written on financially negotiable instruments (i.e., checks or cash). Am I sounding like a broken record? Do you kids these days even know what a broken record is? I would say skipping CD, but you might not know what that is either. Like a sample that got stuck on loop? Damn, I am getting old. So is this paragraph. Time to move on, here.</p>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &amp;copy; 2008, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com">&amp;lt;sjg@cmsmodules.com&amp;gt;</a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '
<ul>
<li>Version 0.5.5. 1 Oct 08. Bug fixes. Added .</li>
<li>Version 0.5.4. 29 Aug 08. Scrapping plans for 0.6. Bug fixes. Ted&#039;s new &quot;Email &quot;From Address&quot; Again Field&quot;. Added database indices.</li>
<li>Version 0.5.3. 26 May 08. Bugfixes to previous set of bugfixes. Now ready for major upgrades for 0.6.</li>
<li>Version 0.5.2. 25 May 08. Bugfixes. Release in preparation for substantial reworking for 0.6</li>
<li>Version 0.5.1. 30 April 08. Bugfixes, rewrote some of the File Upload code to prevent white screen of annoyance.</li>
<li>Version 0.5. 19 April 08. Bugfixes, support for FormBrowser fixes and features, disposition type for upcoming FormBrowser version.</li>
<li>Version 0.4.4. 26 Sept 07. Bugfixes for radio button groups, fix for validation of DispositionDeliverToEmailAddressField.</li>
<li>Version 0.4.3. 18 Sept 07. Bugfixes for pulldowns using numbers, option to inline form, fixes for table-layouts provided by Ap Muthu, fix for requirability of Dispositions.</li>
<li>Version 0.4.2. 14 Sept 07. Bugfixes for XML export, RadioButton Group submission, and HTML labels.</li>
<li>Version 0.4.1. Bugfixes for File Disposition Types.</li>
<li>Version 0.4
	<ul>
		<li>Upped minimum CMS version to 1.1</li>
		<li>Numerous Bug fixes; too many to enumerate here</li>
		<li>Massive rejiggering of code to work with CMS MS 1.1 parameter sanitizing regime</li>
		<li>Added field types: &quot;TextField (Multiple)&quot; and &quot;Computed Field&quot;</li>
		<li>Added dispositions: &quot;Save Results to File Based on Pulldown&quot; and &quot;Save Results to File(s) Based on Multiple Selections&quot;(Calguy)</li>
		<li>Added neat-o AJAX-y template-copying for Form Templates, gave versions of old table-based templates to soothe the raging masses.</li>
		<li>Added ability to pass default values to form elements from module tag using value_FIELDNAME=&quot;value&quot; syntax (Calguy)</li>
		<li>Added option to display field ids in admin (Calguy)</li>
	</ul>
</li>
<li>Version 0.3
   <ul>
      <li>Added Captcha module support.</li>
      <li>Reworked labeling of form elements to be XHTML compliant</li>
      <li>Added Paul Noone&#039;s new, improved contact form templates</li>
      <li>Implementation of Email Subject Field</li>
      <li>Added admin-specifiable values to hidden field type, which may contain parsable smarty tags</li>
      <li>Text Area Field now allows specification of rows and cols in the admin, instead of CSS</li>
      <li>Added Drag&#039;n&#039;Drop reordering of form fields.</li>
      <li>Added non-blank field name and unique field name global configuration options and validation</li>
      <li>Implemented templated display of form results upon submission in addition to page redirecting</li>
      <li></li>
   </ul>
</li>
<li>Version 0.2.4 - 09 May 2007
   <p>Big release:<ul>
   <li>Added &quot;Email Form to User-Supplied Address&quot; disposition.</li>
   <li>Added &quot;TimePicker&quot; field type. Split &quot;Link&quot; field into a &quot;User-supplied Link&quot; field and a &quot;Static Link&quot; field.</li>
   <li>Added HTML email option and auto-templates for all email dispositions.</li>
   <li>Added primitive anti-spam features.</li>
   <li>Added XML-based import and export of forms.</li>
   </ul>
   </p>
</li>
<li>Version 0.2.3
   <p>Add the ability to call a selectable user defined tag upon disposition of the form.</p>
</li>
<li>Version 0.2.2
   <p>Many thanks to Utter Design for sponsoring some changes and bugfixes, which include:
   <ul>
      <li>Added file upload capabilities to the email disposition</li>
      <li>Add PageSetStart and PageSetEnd field types
      <p>These field types allow you to create fieldsets in your form, and organise
      your fields logically for the user.  You can even nest fieldsets, and
      associate a style with them appropriately.  The default template was changed
      to prevent it from wrapping a div around these types of fields.
      </p>
      </li>
      <li>Fixed a problem with DATETIME fields on install
      <p>This solves a problem when on install the response table would sometimes not get created when using adodb lite</li>
      </li>
   </ul>
   </p>
</li>
<li>Version 0.2 - 14 November 2006. Calguy &amp;amp; tsw&#039;s bug fixes for field re-ordering and custom templates. Additional bug fixes for field labels.</li>
<li>Version 0.1 - 8 July 2006. Initial Release</li>
</ul>';
$lang['utma'] = '156861353.4516254727077762000.1214829895.1222958915.1222962521.33';
$lang['utmz'] = '156861353.1216811970.10.3.utmcsr=wiki.cmsmadesimple.org|utmccn=(referral)|utmcmd=referral|utmcct=/index.php/main_page';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/nl_NL.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Form Builder ';
$lang['field_type_'] = 'Veldtype niet ingesteld';
$lang['field_type_CatalogerItemsField'] = 'Selecteer een (of meer) cataloger items';
$lang['field_type_FieldsetEnd'] = 'Veld einde';
$lang['field_type_FieldsetStart'] = 'Veld start';
$lang['field_type_TextField'] = 'Tekstinvoer';
$lang['field_type_TextFieldExpandable'] = 'Tekstinvoer (meerdere)';
$lang['field_type_TextAreaField'] = 'Tekstveld';
$lang['field_type_CheckboxField'] = 'Selectievak';
$lang['field_type_CheckboxGroupField'] = 'Selectievak-groep';
$lang['field_type_PulldownField'] = 'Keuzelijst';
$lang['field_type_MultiselectField'] = 'Meerkeuze';
$lang['field_type_StatePickerField'] = 'U.S. State-kiezer';
$lang['field_type_ProvincePickerField'] = 'Canadese Provincie-kiezer';
$lang['field_type_CountryPickerField'] = 'Landenkiezer';
$lang['field_type_DatePickerField'] = 'Datumkiezer';
$lang['field_type_TimePickerField'] = 'Tijdkiezer';
$lang['field_type_RadioGroupField'] = 'Selectierondjes-groep';
$lang['field_type_DispositionDirector'] = '*E-mail resultaten gebaseerd op keuzelijst';
$lang['field_type_DispositionFileDirector'] = '*Bewaar resultaten in een bestand gebaseerd op keuzelijst';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Bewaar resultaten in bestanden gebaseerd op meer-keuzelijsten';
$lang['field_type_DispositionPageRedirector'] = '*Redirect naar pagina gebaseerd op keuzelijst';
$lang['field_type_DispositionEmail'] = '*E-mail resultaten naar ingestelde adres(sen)';
$lang['field_type_DispositionEmailConfirmation'] = '*Valideer-via-emailadres';
$lang['field_type_DispositionFile'] = '*Schrijf resultaten naar bestand';
$lang['field_type_DispositionDatabase'] = '*Resultaten opslaan in database';
$lang['field_type_DispositionFormBrowser'] = '*Sla resultaten op voor FormBrowser Module';
$lang['field_type_DispositionUserTag'] = '*Start een gebruikergedefinieerde tag met de formulierresultaten';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*E-mail naar het opgegeven e-mailadres';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Email naar CMS Admin Gebruiker';
$lang['field_type_PageBreakField'] = '-Paginascheiding';
$lang['field_type_FileUploadField'] = 'Bestand Upload';
$lang['field_type_FromEmailAddressField'] = '&quot;Van Adres&quot; e-mailveld';
$lang['field_type_FromEmailAddressAgainField'] = 'Email &quot;Van Adres&quot; Herhalingsveld';
$lang['field_type_FromEmailNameField'] = '&quot;Van Naam&quot; e-mailveld';
$lang['field_type_FromEmailSubjectField'] = '&quot;Onderwerp&quot; e-mailveld';
$lang['field_type_StaticTextField'] = '-Statische Tekst';
$lang['field_type_SystemLinkField'] = '-Statische link';
$lang['field_type_LinkField'] = '-Link (ingevoerd door gebruiker)';
$lang['field_type_HiddenField'] = 'Verborgen veld';
$lang['field_type_ComputedField'] = 'Berekend veld';
$lang['field_type_UniqueIntegerField'] = '-Uniek Getal (Serienummer)';
$lang['validation_none'] = 'Geen validatie';
$lang['validation_numeric'] = 'Numeriek';
$lang['validation_integer'] = 'Geheel getal';
$lang['validation_email_address'] = 'E-mailadres';
$lang['validation_usphone'] = 'Telefoonnummer (US)';
$lang['validation_must_check'] = 'Moet aangevinkt worden';
$lang['validation_regex_match'] = 'Moet voldoen aan een reguliere expressie';
$lang['validation_regex_nomatch'] = 'Voldoet niet aan de reguliere expressie';
$lang['required_field_missing'] = 'Een waarde ontbreekt voor dit verplichte veld';
$lang['please_enter_a_value'] = 'Voer een waarde in voor &quot;%s&quot;';
$lang['please_enter_a_number'] = 'Voer een nummer in bij &quot;%s&quot;';
$lang['please_enter_valid'] = 'Voer een geldige waarde in bij &quot;%s&quot;';
$lang['please_enter_an_integer'] = 'Voer een getal in bij &quot;%s&quot;';
$lang['please_enter_an_email'] = 'Voer een geldig e-mailadres in bij &quot;%s&quot;';
$lang['email_address_does_not_match'] = 'E-mailadres komt niet overeen met de waarde %s&quot;';
$lang['please_enter_a_phone'] = 'Voer een geldig telefoonnummer is voor &quot;%s&quot;';
$lang['not_valid_email'] = '&quot;%s&quot; is geen geldig e-mailadres.';
$lang['please_enter_no_longer'] = 'Voer een waarde in die niet langer is dan %s tekens';
$lang['title_list_delimiter'] = 'Teken om te gebruiken als scheiding bij resultaten die meer dan &eacute;&eacute;n waarde teruggeven';
$lang['you_need_permission'] = 'Het &quot;%s&quot;-recht is vereist voor die bewerking.';
$lang['lackpermission'] = 'Sorry! U heeft onvoldoende rechten om deze sectie te benaderen.';
$lang['field_order_updated'] = 'Veldvolgorde bijgewerkt.';
$lang['form_deleted'] = 'Formulier verwijderd.';
$lang['field_deleted'] = 'Veld verwijderd.';
$lang['configuration_updated'] = 'Configuratie bijgewerkt.';
$lang['you_must_check'] = '&quot;%s&quot; moet geselecteerd zijn om door te kunnen gaan.';
$lang['must_specify_one_destination'] = 'Er moet tenminste &eacute;&eacute;n bestemmingsadres worden opgegeven.';
$lang['are_you_sure_delete_form'] = 'Het formulier %s verwijderen?';
$lang['are_you_sure_delete_field'] = 'Het veld %s verwijderen?';
$lang['notice_select_type'] = 'Geavanceerde opties zijn niet beschikbaar voordat het veldtype ingesteld is.';
$lang['field_name_in_use'] = 'De veldnaam &quot;%s&quot; is al in gebruik. Gebruik unieke veldnamen of schakel unieke veldnamen uit in de Form Builder-configuratie.';
$lang['field_no_name'] = 'Velden moeten een naam hebben, behalve als deze uitgeschakeld zijn in de Form Builder-configuratie.';
$lang['anonymous'] = 'Anoniem';
$lang['abbreviation_length'] = 'Lengte: %s';
$lang['boxes'] = '%s vakken';
$lang['options'] = '%s opties';
$lang['text_length'] = '%s tekens';
$lang['order'] = 'Volgorde';
$lang['unspecified'] = '[niet opgegeven]';
$lang['added'] = 'toegevoegd';
$lang['updated'] = 'bijgewerkt';
$lang['sort_options'] = 'Sorteeropties van de uitvoer';
$lang['select_one'] = 'Selecteer &eacute;&eacute;n';
$lang['select_type'] = 'Selecteer Type';
$lang['to'] = 'Aan';
$lang['yes'] = 'Ja';
$lang['no'] = 'Nee';
$lang['recipients'] = 'ontvangers';
$lang['file_count'] = '%s mogelijke bestanden';
$lang['destination_count'] = '%s bestemmingen';
$lang['save'] = 'Opslaan';
$lang['add'] = 'Toevoegen';
$lang['update'] = 'Bijwerken';
$lang['save_and_continue'] = 'Opslaan en doorgaan met wijzigen';
$lang['information'] = 'Informatie';
$lang['automatic'] = 'Automatisch';
$lang['forms'] = 'Formulieren';
$lang['form'] = 'Formulier %s';
$lang['configuration'] = 'Configuratie';
$lang['field_requirement_updated'] = 'Veld verplichte toestand bijgewerkt.';
$lang['maximum_size'] = 'Max. grootte';
$lang['permitted_extensions'] = 'Uitbreidingen';
$lang['permitted_filetypes'] = 'Toegestane bestandstypes';
$lang['file_too_large'] = 'Geupload bestand is te groot. Maximum grootte is:';
$lang['illegal_file_type'] = 'Dit type bestand mag niet worden geupload. Controleer de bestandsextensie.';
$lang['upload'] = 'Upload ';
$lang['form_imported'] = 'Formulier ge&iuml;mporteerd.';
$lang['form_import_failed'] = 'Formulierimport mislukt. Er was een probleem met de opmaak van het XML-bestand.';
$lang['rows'] = '%s rijen';
$lang['cols'] = '%s kolommen';
$lang['12_hour'] = '12-uurs klok';
$lang['24_hour'] = '24-uurs klok';
$lang['hour'] = 'uur';
$lang['min'] = 'minuut';
$lang['merid'] = 'meridiaan';
$lang['date_range'] = 'Verzameling: %s - %s';
$lang['thanks'] = 'Bedankt. Uw aanvragen zijn ontvangen.';
$lang['edit'] = 'Bewerken';
$lang['delete'] = 'Verwijderen';
$lang['day'] = 'dag';
$lang['mon'] = 'maand';
$lang['year'] = 'jaar';
$lang['none'] = '(geen)';
$lang['uninstalled'] = 'Module gedeinstaleerd.';
$lang['installed'] = 'Moduleversie %s ge&iuml;nstalleerd.';
$lang['upgraded'] = 'Module bijgewerkt naar versie %s.';
$lang['button_previous'] = 'Terug...';
$lang['button_submit'] = 'Versturen';
$lang['button_continue'] = 'Verder...';
$lang['value_checked'] = 'Geselecteerd';
$lang['value_unchecked'] = 'Niet geselecteerd';
$lang['tab_main'] = 'Start';
$lang['tab_symbol'] = 'Formulierweergaveinstellingen';
$lang['tab_submit'] = 'Formulierverzending';
$lang['tab_captcha'] = 'Captcha-instellingen';
$lang['tab_advanced'] = 'Geavanceerde instellingen';
$lang['tab_templatelayout'] = 'Formuliersjabloon';
$lang['tab_submissiontemplate'] = 'Verzendsjabloon';
$lang['canuse_smarty'] = '<em>Smarty-variabelen mogen in dit veld gebruikt worden.</em>';
$lang['add_options'] = 'Meer opties toevoegen';
$lang['delete_options'] = 'Verwijderen gemarkeerde opties';
$lang['add_checkboxes'] = 'Voeg meer selectievakken toe';
$lang['delete_checkboxes'] = 'Verwijder gemarkeerder selectievakken';
$lang['add_address'] = 'Volgend adres toevoegen';
$lang['delete_address'] = 'Verwijder gemarkeerde adressen';
$lang['add_destination'] = 'Volgende bestemming toevoegen';
$lang['delete_destination'] = 'Verwijder gemarkeerde bestemmingen';
$lang['suspected_spam'] = 'Te veel e-mails verzonden vanaf uw IP-adres. Anti-spam mechanisme blokkeert de verzending.';
$lang['suspected_spam_log'] = 'Verdachte spam van IP %s geblokeerd.';
$lang['reorder'] = 'Herschik velden';
$lang['cancel'] = 'Annuleren';
$lang['value_set'] = 'Waarde gezet: %s';
$lang['help_cataloger_attribute_fields'] = 'Hieronder staat een lijst met attributen die beschikbaar zijn vanuit de Cataloger module.<br/>	
U kunt eventueel geldig reeksen, waarden, of een groot aantal waarden specificeren die worden gebruikt bij het filteren van de lijst van objecten die worden weergegeven aan de gebruiker. <br/>
<br/>
<strong>Reeksen:</strong><br/>
Reeksen kunnen worden opgegeven door een minimale en maximale waarde van het gebruik van deze syntax: &quot;range: minvalue to maxvalue&quot;<br/>
<br/>
<strong>Verschillende waarden:</strong><br/>
Om een waarde te specificeren voor een atribuut, kun je de syntac &quot;multi: value1|value2|value3&quot; gebruiken.<br/>
<br/>
<strong>Waarden in verborgen velden</strong><br/>
Om een waarden toe te kennen aan een verborgen veld, gebruikt u de syntax {$fld_id}<br/>
<br/>';
$lang['help_name_regex'] = 'Een reguliere expressie om de cataloger items te sorteren op naam';
$lang['help_field_height'] = 'The height of the multiselect field';
$lang['title_name_regex'] = 'Cataloger Item Naam Reguliere Expressie';
$lang['title_field_height'] = 'Veld hoogte';
$lang['title_file_path'] = 'Bestemmingsmap voor uitvoerbestanden';
$lang['title_udt_name'] = 'Gebruikergedefineerde tag';
$lang['title_uploads_destpage'] = 'Pagina om naar terug te keren met uploads link';
$lang['title_uploadmodule_summary'] = 'Verzonden met Form Builder';
$lang['title_uploads_category'] = 'Uploads-categorie';
$lang['title_sendto_uploads'] = 'Stuur dit bestand naar de upload-module';
$lang['title_legend'] = 'Legenda';
$lang['title_maximum_length'] = 'Maximum lengte';
$lang['title_checkbox_label'] = 'Selectievaklabel';
$lang['title_radio_label'] = 'Selectierondjelabel';
$lang['title_checked_value'] = 'Waarde indien geselecteerd';
$lang['title_unchecked_value'] = 'Waarde indien niet geselecteerd';
$lang['title_checkbox_details'] = 'Selectievak-groepdetails';
$lang['title_delete'] = 'Verwijderen?';
$lang['title_select_one_message'] = '&quot;Selecteer Een&quot; tekst';
$lang['title_selection_value'] = 'Selectiewaarde';
$lang['title_selection_displayname'] = 'Selectieweergavenaam';
$lang['title_selection_subject'] = 'Selectieonderwerp';
$lang['title_select_default_country'] = 'Standaardselectie';
$lang['title_select_default_state'] = 'Standaardselectie';
$lang['title_select_default_province'] = 'Standaardselectie';
$lang['title_option_name'] = 'Optienaam';
$lang['title_option_value'] = 'Verstuurde waarde';
$lang['title_pulldown_details'] = 'Keuzelijstopties';
$lang['title_multiselect_details'] = 'Meerkeuzeopties';
$lang['title_destination_address'] = 'Bestemmings e-mailadres';
$lang['title_destination_filename'] = 'Bestemmingsbestandsnaam';
$lang['title_email_from_name'] = '&quot;Van Naam&quot; voor e-mail';
$lang['title_relaxed_email_regex'] = 'Gebruik eenvoudige e-mailvalidatie';
$lang['title_relaxed_regex_long'] = 'Gebruik eenvoudige e-mailadresvalidatie (sta bijvoorbeeld &quot;x@y&quot; toe i.p.v. &quot;x@y.tld&quot;)';
$lang['title_email_from_address'] = '&quot;Van adres&quot; voor email';
$lang['title_email_encoding'] = 'Emailtekenset encodering';
$lang['title_director_details'] = 'Keuzelijstgebaseerde e-maildetails';
$lang['title_file_name'] = 'Bestandsnaam';
$lang['title_email_subject'] = 'E-mailonderwerpregel';
$lang['title_form_name'] = 'Formuliernaam';
$lang['title_form_status'] = 'Formulierstatus';
$lang['title_ready_for_deployment'] = 'Klaar voor gebruik';
$lang['title_not_ready1'] = 'Niet klaar';
$lang['title_redirect_page'] = 'Pagina om te tonen na verzending van het formulier';
$lang['title_not_ready2'] = 'Voeg een veld toe zodat de invoer van de gebruiker verwerkt kan worden. U kunt';
$lang['title_not_ready_link'] = 'deze snelkoppeling gebruiken';
$lang['title_form_alias'] = 'Formulieralias';
$lang['title_form_fields'] = 'Formuliervelden';
$lang['title_field_id'] = 'Veld-Id';
$lang['title_show_fieldaliases'] = 'Toon veld-aliassen';
$lang['title_show_fieldaliases_long'] = 'Deze selecteren zorgt voor het tonen van veld-aliassen tijdens toevoegen of wijzigen van een formulier';
$lang['title_field_name'] = 'Veldnaam';
$lang['title_field_alias'] = 'Veld-alias';
$lang['title_radiogroup_details'] = 'Selectierondje-groepsdetails';
$lang['title_field_type'] = 'Veldtype';
$lang['title_not_ready3'] = 'om een formulierverwerkingsveld te maken.';
$lang['title_add_new_form'] = 'Nieuw formulier toevoegen';
$lang['title_show_version'] = 'FormBuilder versie tonen?';
$lang['title_show_version_long'] = 'Dit voegt het versienummer van de ge&iuml;nstalleerde FormBuilder-module als commentaar toe, om te helpen bij debuggen.';
$lang['title_add_new_field'] = 'Nieuw veld toevoegen';
$lang['title_form_submit_button'] = 'Formulierverzendknoptekst';
$lang['title_submit_button_safety'] = 'Javascript aan verzendknop toevoegen om meerdere verzendingen te voorkomen?';
$lang['title_submit_button_safety_help'] = 'Veiligheidsscript toevoegen';
$lang['title_form_next_button'] = 'Formulier &quot;Volgende&quot; knoptekst (gebruikt bij formulieren van meerdere pagina&#039;s)';
$lang['title_form_prev_button'] = 'Formulier &quot;Vorige&quot; knoptekst (gebruikt bij formulieren van meerdere pagina&#039;s)';
$lang['title_field_validation'] = 'Veldvalidatie';
$lang['title_field_to_validate'] = 'Veld om te valideren';
$lang['title_form_css_class'] = 'CSS-klasse voor dit formulier';
$lang['title_field_css_class'] = 'CSS-klasse voor dit veld';
$lang['title_form_required_symbol'] = 'Symbool om vereiste velden te markeren';
$lang['title_field_required'] = 'Vereist';
$lang['title_field_required_long'] = 'Vereist een antwoord voor dit veld';
$lang['title_hide_label'] = 'Verberg Label';
$lang['title_hide_label_long'] = 'Verberg veldnaam op formulier';
$lang['title_text'] = 'Statische tekst om weer te geven';
$lang['title_field_regex'] = 'Validatie regex';
$lang['title_lines_to_show'] = 'Aantal weergegeven regels';
$lang['no_default'] = 'Geen standaard';
$lang['redirect_after_approval'] = 'Toon deze pagina na goedkeuring';
$lang['title_regex_help'] = 'Deze reguliere expressie zal alleen gebruikt worden als &quot;validatietype&quot; ingesteld is op een regex-gerelateerde optie. Bevat een volledige Perl-achtige regex, inclusief de start/stop slashes en vlaggen (b.v., &quot;/image\.(\d+)/i&quot;)';
$lang['title_field_required_abbrev'] = 'Verplicht';
$lang['title_hide_errors'] = 'Verberg Fouten';
$lang['title_form_displaytype'] = 'Formulierweergavetype';
$lang['title_hide_errors_long'] = 'Voorkom debug- / foutmeldingen voor gebruikers.';
$lang['title_email_template'] = 'Emailsjabloon';
$lang['title_maximum_size'] = 'Maximale upload bestandsgrootte (kilobytes)';
$lang['title_maximum_size_long'] = 'Deze begrenzing is een toevoeging op de begrenzingen die zijn ingesteld in de PHP- of webserverconfiguratie.';
$lang['title_permitted_extensions'] = 'Toegestane extensies';
$lang['title_permitted_extensions_long'] = 'Voer een kommagescheiden lijst in, zonder de punt (b.v., &quot;jpg,gif,jpeg&quot;). Spaties worden overgeslagen. Leeg laten betekent dat er geen beperkingen zijn.';
$lang['title_show_limitations'] = 'Beperkingen weergeven?';
$lang['title_show_limitations_long'] = 'Grootte- en extensiebeperkingen tonen bij het upload veld?';
$lang['title_form_template'] = 'Sjabloon voor weergaveformulier';
$lang['title_page_x_of_y'] = 'Pagina %s van %s';
$lang['title_no_advanced_options'] = 'Veld heeft geen geavanceerde opties.';
$lang['title_form_unspecified'] = 'Getoonde tekst bij ongespecificeerde veldwaarden';
$lang['title_enable_fastadd_long'] = 'Snel-veld-toevoegen uitklapmenu inschakelen voor formulieren?';
$lang['title_enable_fastadd'] = 'Snel-veld-toevoegen uitklapmenu inschakelen?';
$lang['title_fastadd'] = 'Snel-veld-toevoeger';
$lang['title_enable_antispam_long'] = 'Dit aanklikken zal slechts 10 emails toestaan vanuit een gegevens IP-adres (per uur).';
$lang['title_enable_antispam'] = 'Primitieve anti-spam mogelijkheden inschakelen?';
$lang['title_show_fieldids'] = 'Toon veld-id&#039;s';
$lang['title_show_fieldids_long'] = 'Dit aanklikken maakt het tonen van veld-id&#039;s mogelijk tijdens toevoegen en wijzigen van een formulier';
$lang['title_xml_to_upload'] = 'Upload formulier uit een XML-bestand';
$lang['title_xml_upload_formname'] = 'Gebruik deze formuliernaam';
$lang['title_import_legend'] = 'XML-formulierimport';
$lang['title_xml_upload_formalias'] = 'Gebruik deze formulieralias';
$lang['title_html_email'] = 'Genereer HTML-email?';
$lang['title_link_autopopulate'] = 'Automatisch laden?';
$lang['title_link_autopopulate_help'] = 'Automatisch laden met de URL van de pagina met het formulier? (dit overschrijft de paginalink-optie hieronder)';
$lang['title_default_link'] = 'Standaardlink-URL';
$lang['title_default_link_title'] = 'Standaardlinktekst';
$lang['title_link_to_sitepage'] = 'Link naar de sitepagina';
$lang['title_captcha_not_installed'] = 'U kunt gebruik maken van <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a> om verzendingen te beveiligen door de Captcha-module te installeren. Voor meer informatie, <a href="http://dev.cmsmadesimple.org/projects/captcha/">zie het Captcha-project</a>.';
$lang['title_use_captcha'] = 'Captcha gebruiken om de formulierverzendingen te beschermen?';
$lang['title_use_captcha_help'] = 'Vink aan om uw formulier te beschermen met een <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a>.';
$lang['title_user_captcha'] = 'Bevestig dat u geen script bent door de karakters in het plaatje in te voeren.';
$lang['title_user_captcha_error'] = 'Verkeerde tekst voor Captcha';
$lang['wrong_captcha'] = 'Captcha was niet goed.';
$lang['title_title_user_captcha'] = 'Hulptekst voor Captcha';
$lang['title_dont_submit_unchecked'] = 'Verstuur geen waardes voor niet-geselecteerde velden';
$lang['title_dont_submit_unchecked_help'] = 'Selecteer deze als enkel waardes verstuurd moeten worden voor geselecteerde velden';
$lang['link_label'] = 'Linklabel';
$lang['link_destination'] = 'Link doel URL';
$lang['title_default_set'] = 'Standaard geselecteerd?';
$lang['title_24_hour'] = 'Gebruik 24-uurs tijd?';
$lang['title_before_noon'] = 'AM ';
$lang['title_after_noon'] = 'PM ';
$lang['title_smarty_eval'] = 'Voer smarty tags uit in het veld?';
$lang['title_textarea_rows'] = 'Rijen (let op: dit kan worden overschreven door CSS)';
$lang['title_textarea_cols'] = 'Kolommen (let op: dit kan worden overschreven door CSS)';
$lang['title_form_main'] = 'Hoofdformulierdetails';
$lang['title_show_username'] = 'Toon zowel de login-naam als de voor- en achternaam?';
$lang['title_show_userfirstname'] = 'Toon gebruikers voornaam?';
$lang['title_show_userlastname'] = 'Toon gebruikers achternaam?';
$lang['title_restrict_to_group'] = 'Beperk gebruikerslijst tot gebruikers in specifieke groep';
$lang['restricted_to_group'] = 'Allen in groep %s';
$lang['title_show_to_user'] = 'Toon aan gebruiker?';
$lang['help_leaveempty'] = 'Dit veld mag leeg gelaten worden';
$lang['help_variables_for_template'] = 'Variabelen voor sjabloon';
$lang['help_variables_for_computation'] = 'Variabelen beschikbaar';
$lang['help_php_variable_name'] = 'PHP variabele';
$lang['help_submission_date'] = 'Datum van verzending';
$lang['help_server_name'] = 'Server';
$lang['help_sub_source_ip'] = 'IP adres';
$lang['help_sub_url'] = 'URL van de pagina';
$lang['help_fb_version'] = 'FormBuilder versie';
$lang['help_tab'] = 'Tab karakter';
$lang['help_other_fields'] = 'Andere velden zijn beschikbaar nadat ze zijn toegevoegd';
$lang['help_array_fields'] = 'Velden met meerdere waarden kunnen ook benaderd worden via de smarty waarde van $fieldname_array of $fld_#_array.';
$lang['help_date_format'] = 'Zie <a href="http://www.php.net/manual/en/function.date.php" target=_NEW>the PHP Manual</a> voor informatie over het format.';
$lang['help_variable_name'] = 'Variabele';
$lang['help_form_field'] = 'Gerepresenteerd Veld';
$lang['link_back_to_form'] = '&laquo; Terug naar het formulier';
$lang['title_create_sample_template'] = 'Voorbeeldsjabloon genereren';
$lang['title_create_sample_html_template'] = 'Cre&euml;er voorbeeld HTML-sjabloon';
$lang['title_create_sample_header_template'] = 'Cre&euml;er een voorbeeld Header-sjabloon';
$lang['title_create_sample_header'] = 'Voorbeeldkopregel genereren';
$lang['help_tab_symbol'] = 'een tab-teken';
$lang['title_file_template'] = 'Sjabloon voor enkele regel uitvoerbestand';
$lang['title_file_header'] = 'Sjabloon voor de kopregel van het uitvoerbestand';
$lang['title_confirmation_url'] = 'URL om te klikken voor formuliervalidatie';
$lang['title_value'] = 'Waarde (zie Geavanceerd tabblad als u Smarty tags gebruikt)';
$lang['title_date_format'] = 'Datumformaat (standaard <a href="http://www.php.net/manual/en/function.date.php">PHP-datumformaten</a>)';
$lang['title_use_wysiwyg'] = 'Gebruik WYSIWYG editor voor tekstveld?';
$lang['title_submit_actions'] = 'Formulierverzendgedrag';
$lang['title_submit_labels'] = 'Verzendknoplabels';
$lang['title_sortable_field'] = 'Sorteerveld #%s';
$lang['title_submit_help'] = 'Deze pagina maakt aanpassen van Formulierverzending mogelijk. Het bepaalt niet wat Form Builder met de verzonden data doet. Dit kunt u instellen door &quot;Disposition&quot; velden toe te voegen aan het formulier ';
$lang['title_start_year'] = 'Begin jaarreeks';
$lang['title_end_year'] = 'Einde jaarreeks';
$lang['title_default_year'] = 'Standaardjaar';
$lang['title_default_year_help'] = '(Stel op -1 in voor het standaardjaar het huidige jaar te maken)';
$lang['title_submit_action'] = 'Na het formulier verzonden is';
$lang['title_submit_response'] = 'Reactie om te tonen';
$lang['display_text'] = 'Toon &quot;Verzendsjabloon&quot;';
$lang['redirect_to_page'] = 'Laad de website pagina';
$lang['title_submit_response_help'] = 'Deze sjabloon is om te tonen aan de gebruiker nadat het formulier verstuurd is. Het heeft geen effect op de aangemaakt emails of andere formulierregels -- die kunt u instellen in sjablonen (indien van toepassing) in het &quot;geavanceerd&quot; tabblad voor de regelvelden.';
$lang['title_destination_page'] = 'Bestemmingspagina';
$lang['title_require_fieldnames'] = 'Verplichte veldnamen';
$lang['title_require_fieldnames_long'] = 'Verplicht velden om een naam te hebben?';
$lang['title_unique_fieldnames'] = 'Verplicht unieke veldnamen';
$lang['title_unique_fieldnames_long'] = 'Verplicht velden om een unieke naam te hebben?';
$lang['title_reorder_form'] = 'Herschik velden';
$lang['title_load_template'] = 'Laad sjabloon';
$lang['title_add_button_text'] = 'Voeg knoptekst toe';
$lang['title_del_button_text'] = 'Verwijder knoptekst';
$lang['title_string_or_number_eval'] = 'Interpreteer variabelen als nummers of strings';
$lang['title_order'] = 'Interpretatievolgorde';
$lang['title_order_help'] = 'Als er meer dan een berekend veld bestaat, dan zullen de worden berekend van het laagste rangnummer tot het hoogste rangnummer';
$lang['title_compute_value'] = 'Waarde om te berekenen';
$lang['title_string'] = 'String ';
$lang['title_numeric'] = 'Numeriek';
$lang['title_inline_form'] = 'Toon het formulier inline?';
$lang['title_inline_form_help'] = 'Inline betekent dat iedere formuliervervolgactie de {cms_module} tag vervangt, non-inline vervangt de {content} tag.';
$lang['title_field_default_value'] = 'Standaardwaarde voor veld';
$lang['title_clear_default'] = 'Leeg standaardwaarde met een klik?';
$lang['title_clear_default_help'] = 'Vink aan om de standaardwaarde te verwijderen als een gebruiker op dit veld klikt.';
$lang['title_remove_file_from_server'] = 'Verwijder het geuploade bestand van de server na het proces';
$lang['title_field_javascript'] = 'Javascript voor veld';
$lang['title_field_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;';
$lang['title_submit_javascript'] = 'Form Submission Javascript';
$lang['title_submit_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;.<br />This will probably not work well if you use the &quot;safety script&quot; option above.';
$lang['email_from_addr_help'] = 'Do not just pick a random address here -- many ISPs will<br />not deliver the mail if you are using a different domain name than your actual<br />host name (i.e., use something like name@%s)';
$lang['title_switch_advanced'] = 'Meer veldtypes nodig?';
$lang['title_switch_basic'] = 'Teveel verwarende veldtypes?';
$lang['title_switch_advanced_link'] = 'Ga naar de geavanceerde modus';
$lang['title_switch_basic_link'] = 'Ga naar de simpele modus';
$lang['title_file_root'] = 'Map voor het opslaan van bestanden';
$lang['title_file_root_help'] = 'This needs to be a directory that your web server has permissions to write in.<br />Chmod it 777 if you have problems/doubts.<br />Also, check to see that you do not have PHP directory restrictions.';
$lang['title_newline_replacement'] = 'Newline/Carriage Return replacement character';
$lang['title_newline_replacement_help'] = 'Leave blank to allow newlines and carriage returns in output';
$lang['error_cataloger_module_not_available'] = '<strong>Cataloger module is niet ge&iuml;nstalleerd/actief.</strong>';
$lang['warning'] = 'WAARSCHUWING';
$lang['default_template'] = 'Standaardsjabloon';
$lang['table_left_template'] = 'Tabelsjabloon, titel links';
$lang['table_top_template'] = 'Tabelsjabloon, titel boven';
$lang['form_template_name'] = 'Sjabloon van %s';
$lang['template_are_you_sure'] = 'Weet u zeker dat u de sjabloon wilt overschrijven met het geselecteerde sjabloon? (Zelfs als u OK aangeeft, zult u de veranderingen moeten bewaren)';
$lang['title_bad_function'] = 'Fout bij het berekenen van &quot;%s&quot;.';
$lang['no_referrer_info'] = 'Geen HTTP_REFERER informatie beschikbaar (waarschijnijk door het gebruik van E-mail Gebruiker Validatie)';
$lang['validation_param_error'] = 'Validatie-parameter-fout. Zorg ervoor dat de URL van uw email correct gekopieerd wordt!';
$lang['validation_response_error'] = 'Validatie-reactie-fout. Zorg ervoor dat de URL van uw email correct gekopieerd wordt!';
$lang['validation_no_field_error'] = 'Validation-reactie-fout. Geen emailvalidatievelden in dit formulier!';
$lang['upgrade03to04'] = 'Formuliersjabloon is automatisch bijgewerkt als onderdeel van de upgrade van versie 0.3 naar versie 0.4. Mogelijk moet u een aantal zaken herstellen. Als u het standaardsjabloon gebruikt, vervang deze sjabloon dan met de standaard, door de bovenstaande keuzelijst te gebruiken.';
$lang['admindesc'] = 'Beheer van interactieve sformulieren';
$lang['operators_help'] = 'Als u string-evaluatie gebruikt, is de enige beschikbare operator (+), terwijl bij het gebruik van nummer-evaluatie eenvoudige wiskundige bewerkingen mogelijk zijn (, +, -, *, /, ).';
$lang['date_january'] = 'januari';
$lang['date_february'] = 'februari';
$lang['date_march'] = 'maart';
$lang['date_april'] = 'april';
$lang['date_may'] = 'mei';
$lang['date_june'] = 'juni';
$lang['date_july'] = 'juli';
$lang['date_august'] = 'augustus';
$lang['date_september'] = 'september';
$lang['date_october'] = 'oktober';
$lang['date_november'] = 'november';
$lang['date_december'] = 'december';
$lang['submission_error'] = 'Sorry! Er is een fout opgetreden tijdens de formulierverwerking.';
$lang['submit_error'] = 'Form Builder verzendingsfout: %s';
$lang['uploads_error'] = 'Fout bij het versturen van het bestand naar de uploadmodule: %s';
$lang['nouploads_error'] = 'De uploadmodule kon niet worden gevonden';
$lang['upload_attach_error'] = 'Upload/Bijlage fout bij bestand %s (tmp_name: %s, type %s)';
$lang['submission_error_file_lock'] = 'Fout. Kan geen lock voor bestand krijgen.';
$lang['unchecked_by_default'] = 'Standaard: niet-geselecteerd';
$lang['checked_by_default'] = 'Standaard: geselecteerd';
$lang['email_default_template'] = 'Form Builder Verzending';
$lang['email_template_not_set'] = '<br/>Emailsjabloon nog niet ingesteld!';
$lang['missing_cms_mailer'] = 'Form Builder: Kan vereiste module CMSMailer niet vinden!';
$lang['user_approved_submission'] = 'Gebruikergoedgekeurde verzending %s van %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Gebeurtenis geactiveerd als een Form Builder-formulier verzonden wordt';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Gebeurtenis geactiveerd als een fout optreedt bij het verzenden van een Form Builder-formulier';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Gebeurtenis geactiveerd als een Form Builder-formulier wordt getoond';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Gebeurtenis geactiveerd als een Form Builder-formulier verzonden wordt.</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - Formuliernaam (string)</li>
<li><em>form_id</em> - Intern formulier ID (int)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Gebeurtenis geactiveerd als een fout optreedt bij het verzenden van een Form Builder-formulier</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - Formuliernaam (string)</li>
<li><em>form_id</em> - Intern formulier ID (int)</li>
<li><em>error</em> - Een lijst van alle bekende fouten (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Gebeurtenis geactiveerd als een Form Builder-formulier wordt getoond</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - Formuliernaam (string)</li>
<li><em>form_id</em> - Intern formulier ID (int)</li>
</ul> ';
$lang['formbuilder_params_response_id'] = 'Reactie-ID. Gebruikt door FormBrowser';
$lang['formbuilder_params_passed_from_tag'] = 'Standaard veldwaarden; zie modulehulp';
$lang['formbuilder_params_field_id'] = 'Veld-ID voor interne operaties';
$lang['formbuilder_params_form_name'] = 'Formuliernaam';
$lang['formbuilder_params_form_id'] = 'Formulier-ID voor interne operatie';
$lang['formbuilder_params_general'] = 'Algemene parameters voor interne operaties';
$lang['template_variable_help'] = '<h3>Formuliersjabloonvariabelen</h3>
<p>Het formuliersjabloon kan bewerkt worden om de opmaak aan te passen. Om het formulier te laten werken, moeten daarin minstens de {$fb_hidden} en {$submit}
   tags worden opgenomen.</p>

<p>U heeft toegang tot de velden via het $fields-array of direct via de veldnamen: (b.v., {$myfield->input} )</p>

<p>Ieder veld heeft de volgende attributen:</p>
<table>
<tr><th>Veld</th><th>Waarde</th></tr>
<tr><td>field->display</td><td>1 als het veld getoond moet worden, anders 0</td></tr>
<tr><td>field->required</td><td>1 als het veld verplicht is, anders 0</td></tr>
<tr><td>field->required_symbol</td><td>Het symbool om verplichte velden te markeren</td></tr>
<tr><td>field->css_class</td><td>de CSS class voor die veld</td></tr>
<tr><td>field->valid</td><td>1 als het veld door de validatie komt, anders 0</td></tr>
<tr><td>field->error</td><td>tekst van het validatieprobleem als het veld niet gevalideerd kon worden</td></tr>
<tr><td>field->hide_name</td><td>1 als de veldnaam verborgen moet zijn, anders 0</td></tr>
<tr><td>field->has_label</td><td>1 als het veldtype een label heeft</td></tr>
<tr><td>field->needs_div</td><td>1 als het veld omsloten moet worden in een DIV (of tabelrij)</td></tr>
<tr><td>field->name</td><td>de veldnaam</td></tr>
<tr><td>field->input</td><td>de veldinvoercontrole (b.v. het invoerveld zelf)</td></tr>
<tr><td>field->op</td><td>een controleknop gekoppeld met het veld, indien van toepassing (b.v. de verwijderknop voor een uitbreidbare tekstinvoer)</td></tr>
<tr><td>field->input_id</td><td>de ID van de veldinvoer (nuttig voor <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>het velddatatype</td></tr>
<tr><td>field->multiple_parts</td><td>1 als field->input een verzameling van controls is</td></tr>
<tr><td>field->label_parts</td><td>1 als de verzameling van controls aparte labels voor ieder control heeft</td></tr>
</table>

<p>In bepaalde gevallen is field->input een array van objecten in plaats van een invoer. Dit is bijvoorbeeld het geval in CheckBoxGroups of RadioButtonGroups. Hierbij kunt u door field->input->name en field->input->inputs lopen.</p>
    
<p>Extra smarty-variabelen die u kunt toevoegen:</p>
<table>
<tr><th>Variabele</th><th>Waarde</th></tr>
<tr><td>total_pages</td><td>aantal pagina&#039;s voor meerpagina-formulieren</td></tr>
<tr><td>this_page</td><td>nummer van de huidige pagina bij meerpagina-formulieren</td></tr>
<tr><td>title_page_x_of_y</td><td>toont &quot;page x of y&quot; bij meerpagina-formulieren</td></tr>
<tr><td>css_class</td><td>CSS class voor het formulier</td></tr>
<tr><td>form_name</td><td>Formuliernaam</td></tr>
<tr><td>form_id</td><td>Formulier-database-ID</td></tr>
<tr><td>prev</td><td>&quot;Terug&quot; knop voor meerpagina-formulieren</td></tr>
<tr><td>submit</td><td>&quot;Volgende&quot; or &quot;Versturen&quot; knop voor meerpagina-formulieren, past automatisch aan</td></tr>
</table>

';
$lang['post_install'] = '<p>Vergewis u ervan om &quot;Modify Forms&quot; rechten toe te kennen aan gebruikers die de formulieren moeten beheren. Als u de formulierresultaten wilt emailen zorg er dan voor dat de instellingen goed staan.</p>
<p>Let erop dat een formulier niet actief is (dus gebruikt kan worden vanaf de website) als u nog aan het bewerken bent. U moet eerst het formulier aanmaken en de tag pas in een actieve pagina plaatsen als u klaar bent met bewerken. Ander kunnen er verkeerde resultaten worden verstuurd.</p>
<p>Tevens ondersteund deze versie niet het gelijktijdig bewerken van formulieren. Let erop dat slechts een persoon een formulier gelijktijdig bewerkt.</p>';
$lang['help'] = 'h3>Wat doet het?</h3>
<p>De FormBuilder-module laat u formulieren aanmaken (in feite is dit de opvolger van de originele FeedbackForm-module) met de toegevoegde kracht van database-opslag. Samen met de module Form Browser kunt u het gebruiken om eenvoudige database-applicatie te bouwen.</p>
<p>De formulieren die aangemaakt zijn met FormBuilder kunnen ingevoegd worden in sjablonen en/of webpagina&#039;s. Formulieren kunnen vele vormen van invoer bevatten en de invoer kan gevalideerd worden voor versturen. De resultaten van deze formulieren kunnen verschillende manieren verwerkt worden.</p>

<h3>Hoe maak ik een formulier aan?</h3>
<p>Aan het beheerpaneel is, na installatie van de module, een nieuw menuitem toegevoegd, FormBuilder. Door hierop te klikken verschijnt een scherm met daarin de mogelijkheid een Nieuw formulier aan te maken of de Voorkeuren te bewerken.</p>

<h3>Het toevoegen van een formulier aan een pagina</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module=&#039;FormBuilder&#039; form=&#039;sample_form&#039;}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page&#039;s content if you use a WYSIWYG editor such as TinyMCE, FCKEdit, or HTMLArea. These editors may stealthily
change the quote marks (&quot;) into HTML entities (&amp;amp;quot;), and the forms will not show up. Try using
single quotes (&#039;) or editing the HTML directly.</p>

<h3>Working with Forms</h3>
<p>By clicking on a Form&#039;s name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you&#039;ll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing.</p>
<p>Below this, if you have it enabled, is the &quot;fast field adder&quot; pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Form Submission</h4>
<p>When the form is submitted, you can either redirect the user to another page of your site, or you can present the user some message (which can contain any of the user&#039;s form entries, or just static text). In this tab, you select which of these approaches you wish to use, and, if you chose redirection, it allows you to pick the page to redirect users to after a successful form submission.</p>
<p>Also on this page, you can specify the labels of various submission buttons (&quot;Previous&quot;, &quot;next&quot;, &quot;submit&quot;). You can also opt to have some Javascript added to the last page of a form that will prevent multiple submissions (useful on slow servers).</p>
<h4>Form Display Options</h4>
<p>This tab allows for other form customizations, like the symbol to show for required fields.</p>
<h4>Captcha Settings</h4>
<p>If you have installed the Captcha module, this tab lets you configure the Captcha settings for your form.</p>
<h4>Form Template</h4>
<p>This is where you do your customization work of your form&#039;s Smarty Template. See the section called Form Template Variables below.</p>
<p>The form should default to a Custom template that documents the Smarty tags available to you.</p>
<p>Unless you&#039;re a Smarty expert, you probably don&#039;t want to mess around with this. If you are a Smarty expert, this is where you can unleash your magic.</p>
<h4>Submission Template</h4>
<p>If, in the Form Submission tab, you selected &#039;Display &quot;Submission Template&quot;, this is where you can create that template. There is a display of which smarty variables are available to you, and a button to generate a sample template.</p>
<p>If you&#039;re a Smarty expert, you can do all manner of creative and powerful things here. If you&#039;re not a Smarty expert, you might just want to use the default.
</p>

<h3>Adding Fields to your Form</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it&#039;s submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it&#039;s safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked &quot;Required&quot;, which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to &quot;view source&quot; on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It&#039;s really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It&#039;s really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
<li>Time Picker. This is a set of pulldowns allowing the user to select a time (using 12 or 24 hour clock).</li>
<li>File Upload. This is a file upload field.</li>
<li>Link (User Entered). This creates a double input field for getting a link URL and link title.</li>
<li>Text Field (Multiple). This field creates one or more text inputs with add and delete buttons, effectively giving the end user a way of creating variable-length lists.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the &quot;From&quot; field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the &quot;From&quot; field.</li>
<li>Email Subject Field. This allows users to provide a subject for their email. The email generated when the form gets handled will use this in the &quot;Subject&quot; field. This may cause trouble with certain dispositions that want to control the Email Subject, so use it with caution.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Fieldset Start. Combined with Fieldset End, this allows you to group various fields within your form. Use this to start a given grouping.</li>
<li>-Fieldset End. Combined with Fieldset Start, this allows you to group various fields within your form. Use this to end a given grouping.</li>
<li>-Hidden Field. This allows you to embed a hidden field in your form.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you&#039;re not using a Custom Template to render your form.</li>
<li>-Static Link. This allows you to put a link to a given page into your form. Optionally, you can have it autopopulate with the page where the form is embedded (useful if you\&#039;re sending results via email).</li>
<li>-Computed Field. This allows you to embed a computed field in your form. It is not visible to the user until after the form is submitted. It allows you to do simple arithmetic or string concatenation.</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<ul><li>*Call a User Defined Tag With the Form Results. This submits all the form results to the User-Defined Tag you specify. The UDT can handle the results however it wants.</li>
<li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these &quot;Director&quot; pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email to User-Supplied Address. This puts an input field in the form for the user to populate with an email address. The form results get sent to that address. Beware of Spam abuse! Active the primitive anti-spam features in the FormBuilder configuration screen.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Redirect to Page Based on Pulldown. This allows you to redirect the form to a different site page depending on its value. If you have multiple dispositions, make sure this is used last.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered &quot;approved,&quot; and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the &quot;output&quot; directory under the
module&#039;s installation directory, assuming the web server has permission to write there.</li>
<li>*Save Results to File Based on Pulldown. Like the Flat File disposition, except the value of a pull-down determines which file results get written to.</li>
<li>*Save Results to File(s) Based on Multiple Selections. Like the Flat File disposition, except the value(s) of checkboxes  determines which file(s) results get written to.</li>
</ul></li></li></ul>


<h3>Passing Default Values to Forms</h3>
<p>Calguy added a nice feature, which is that you can pass default field values to your form via the module tag. This allows you to have
the same form in multiple places, but with different default values. It may not work for more exotic field types, but for fields that have
a single value, you can specify like:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_<i>FIELDNAME</i>=&#039;default_value&#039;}</p>
<p>This will set the field with <i>FIELDNAME</i> to &#039;default_value&#039;.</p>
<p>This can be problematic, as sometimes field names are unweildy or contain characters that don&#039;t work well with Smarty. So there is an
alternative like this:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_fld<i>NUMBER</i>=&#039;default_value&#039;}</p>
<p>That uses field <i>NUMBER</i>, where <i>NUMBER</i> is the internal FormBuilder field id. You might wonder how you know what that id is. Simply go into the FormBuilder configuration tab,
and check &quot;Show Field IDs&quot;</p>

<h3>Email and Flat File Templates</h3>
<p>Many disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it&#039;s own best guess, which may or may not work out to your liking. You can always click on the &quot;Create Sample Template&quot; and then customize the results.</p>
<p>To the right, you&#039;ll find a legend which lists all of the variables that are available to you to use in your template. As of version 0.3, variables have two names, one based on the field name, the other based on the field ID. If you use field names that have characters outside of the ASCII 32-126 range, it will be safer to use the ID-based variables.</p>
<p><strong>Note that once you&#039;ve changed a template, it will no longer automatically add new fields.</strong> For this reason, it&#039;s usually best to create your templates as the last step of creating your form.</p>
<p>As of version 0.2.4, you can opt to send any of these emails as HTML email. There should be a checkbox at the top of the template page for this. There is also a &quot;Create Sample HTML Template&quot; button over in the legend area. For HTML email, the email body will also provide the default text-only values.</p>

<h3>Configuration</h3>
<p>There are some global configuration options for FormBuilder:</p>
<ul>
<li>Enable fast field add pulldown. This enables the pulldown on the Form Edit page which saves a step in the creation of new fields.</li>
<li>Hide Errors. This is set by default. Unchecking it will cause more detailed errors to be displayed if there are problems when you submit your form.</li>
<li>Require Field Names. Typically, you will want form fields to be named so you can tell which is which. However, in some cases, you might want to have nameless fields. Uncheck this if you want to allow nameless fields.</li>
<li>Unique Field Names. Typically, you will want form fields to have unique names so you can tell which is which. Uncheck this if you want to allow fields to share names.</li>
<li>Use relaxed email validation. This uses a less restrictive regular expression for validating email; e.g., x@y will be allowed, where typically x@y.tld is required.</li>
<li>Show Form Builder Version. Displays the version of FormBuilder you&#039;re using in a comment when the form is generated. Typically only useful when debugging.</li>
<li>Enable primitive anti-spam features. When turned on, this allows any given IP address to only generate 10 emails per hour.</li>
<li>Show Field IDs. When turned on, FormBuilder will display field ids when adding or editing a form.</li>
</ul>
<h3>Styling and CSS</h3>
<p>Paul Noone graciously provides us all with a pretty good standard CSS that you can use for forms:</p>
<pre>
	/* Sample FormBuilder CSS base */
	form {margin-top:0}
	form, td, th, li { font-size: 100%}
	form div {margin-bottom:0}
	fieldset div {
		margin-bottom:0.5em;
		margin-left:1em;
	}
	fieldset div div {
		margin-top:0.5em;
		margin-left:1em
	}
	fieldset {
		margin-bottom:1em;
		border:1px solid #F60;
		padding:0.5em
	}
	fieldset label {
		width:auto;
	}
	legend {
		color:#FFF;
		background:#F60;
		font-style:italic;
		font-size:1.2em;
		margin-bottom:0.5em;
		padding:0.2em;
		width:auto;
		border:1px solid #CCC
	}
	textarea {
		margin: 0.5em 0;
		width:98%;
		height: 6em
	}

	/* Apply this class to text/select input fields with shorter labels
		to help alignment */
	.short-label label {float:left; width:10em}
	.short-label fieldset div input,
	.short-label fieldset div select {width:16em}

	/* Pretty up your Captcha image output */
	.captcha {
		margin:0.5em 0;
		width:200px;
		text-align:center
	}
	.captcha img {border:1px solid #F60; margin-bottom:0.5em}
	.captcha input {width:196px; margin-top:0.5em}

	/* Just a bit more room for the Submit button */
	.submit {margin-top:0.5em}
</pre>

<h3>Form Template Variables</h3>

<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the &amp;#123;$fb_hidden} and &amp;#123;$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., &amp;#123;$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>


<h3>Known Issues</h3>
<ul>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder cannot yet be inlined. That should be a simple upgrade down the line.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn&#039;t matter since the user side is pretty simple.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you&#039;re running CMS 1.1 or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you&#039;re missing fields in an email that gets generated, check the disposition field&#039;s template, and make sure you&#039;re specifying the missing fields. Seems obvious, but it&#039;s an easy mistake to make.</li>
<li>Uncheck the &quot;Hide Errors&quot; checkbox in the global options, and see what message gets displayed when you submit your form.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is no longer a particularly early version, but it is probably still buggy. While I&#039;ve done all I can
to make sure no egregious bugs have crept in, I have to admit that during early testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor&#039;s nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href="mailto:sjg@cmsmodules.com">&amp;lt;sjg@cmsmodules.com&amp;gt;</a>.</li>
<li>Additional discussion of this module may also be found in the <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &amp;copy; 2007, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com">&amp;lt;sjg@cmsmodules.com&amp;gt;</a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '<ul>
<li>Version 0.4.3. 18 Sept 07. Bugfixes for pulldowns using numbers, option to inline form, fixes for table-layouts provided by Ap Muthu, fix for requirability of Dispositions.</li>
<li>Version 0.4.2. 14 Sept 07. Bugfixes for XML export, RadioButton Group submission, and HTML labels.</li>
<li>Version 0.4.1. Bugfixes for File Disposition Types.</li>
<li>Version 0.4
	<ul>
		<li>Upped minimum CMS version to 1.1</li>
		<li>Numerous Bug fixes; too many to enumerate here</li>
		<li>Massive rejiggering of code to work with CMS MS 1.1 parameter sanitizing regime</li>
		<li>Added field types: &quot;TextField (Multiple)&quot; and &quot;Computed Field&quot;</li>
		<li>Added dispositions: &quot;Save Results to File Based on Pulldown&quot; and &quot;Save Results to File(s) Based on Multiple Selections&quot;(Calguy)</li>
		<li>Added neat-o AJAX-y template-copying for Form Templates, gave versions of old table-based templates to soothe the raging masses.</li>
		<li>Added ability to pass default values to form elements from module tag using value_FIELDNAME=&quot;value&quot; syntax (Calguy)</li>
		<li>Added option to display field ids in admin (Calguy)</li>
	</ul>
</li>
<li>Version 0.3
   <ul>
      <li>Added Captcha module support.</li>
      <li>Reworked labeling of form elements to be XHTML compliant</li>
      <li>Added Paul Noone&#039;s new, improved contact form templates</li>
      <li>Implementation of Email Subject Field</li>
      <li>Added admin-specifiable values to hidden field type, which may contain parsable smarty tags</li>
      <li>Text Area Field now allows specification of rows and cols in the admin, instead of CSS</li>
      <li>Added Drag&#039;n&#039;Drop reordering of form fields.</li>
      <li>Added non-blank field name and unique field name global configuration options and validation</li>
      <li>Implemented templated display of form results upon submission in addition to page redirecting</li>
      <li></li>
   </ul>
</li>
<li>Version 0.2.4 - 09 May 2007
   <p>Big release:<ul>
   <li>Added &quot;Email Form to User-Supplied Address&quot; disposition.</li>
   <li>Added &quot;TimePicker&quot; field type. Split &quot;Link&quot; field into a &quot;User-supplied Link&quot; field and a &quot;Static Link&quot; field.</li>
   <li>Added HTML email option and auto-templates for all email dispositions.</li>
   <li>Added primitive anti-spam features.</li>
   <li>Added XML-based import and export of forms.</li>
   </ul>
   </p>
</li>
<li>Version 0.2.3
   <p>Add the ability to call a selectable user defined tag upon disposition of the form.</p>
</li>
<li>Version 0.2.2
   <p>Many thanks to Utter Design for sponsoring some changes and bugfixes, which include:
   <ul>
      <li>Added file upload capabilities to the email disposition</li>
      <li>Add PageSetStart and PageSetEnd field types
      <p>These field types allow you to create fieldsets in your form, and organise
      your fields logically for the user.  You can even nest fieldsets, and
      associate a style with them appropriately.  The default template was changed
      to prevent it from wrapping a div around these types of fields.
      </p>
      </li>
      <li>Fixed a problem with DATETIME fields on install
      <p>This solves a problem when on install the response table would sometimes not get created when using adodb lite</li>
      </li>
   </ul>
   </p>
</li>
<li>Version 0.2 - 14 November 2006. Calguy &amp;amp; tsw&#039;s bug fixes for field re-ordering and custom templates. Additional bug fixes for field labels.</li>
<li>Version 0.1 - 8 July 2006. Initial Release</li>
</ul>
';
$lang['utma'] = '156861353.2412126582329889000.1214040345.1220379226.1220422316.13';
$lang['utmz'] = '156861353.1218193067.11.6.utmcsr=dev.cmsmadesimple.org|utmccn=(referral)|utmcmd=referral|utmcct=/frs/shownotes.php';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/pl_PL.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Kreator formularzy';
$lang['field_type_'] = 'Typ pola nie został ustawiony';
$lang['field_type_CatalogerItemsField'] = 'Wybierz jeden lub więcej wpis&oacute;w modułu Cataloger';
$lang['field_type_FieldsetEnd'] = '-Koniec pola';
$lang['field_type_FieldsetStart'] = '-Początek pola';
$lang['field_type_TextField'] = 'Pole tekstowego wprowadzania (Text Input)';
$lang['field_type_TextFieldExpandable'] = 'Pole tekstowego wprowadzania (wielokrotne)';
$lang['field_type_TextAreaField'] = 'Pole tekstowe (text area)';
$lang['field_type_CheckboxField'] = 'Checkbox';
$lang['field_type_CheckboxGroupField'] = 'Grupa checkbox&oacute;w';
$lang['field_type_PulldownField'] = 'Lista rozwijalna';
$lang['field_type_MultiselectField'] = 'Lista wielokrotnego wyboru';
$lang['field_type_StatePickerField'] = 'Kontrolka wyboru stan&oacute;w USA';
$lang['field_type_ProvincePickerField'] = 'Kontrolka wyboru region&oacute;w Kanady';
$lang['field_type_CountryPickerField'] = 'Kontrolka wyboru kraju';
$lang['field_type_DatePickerField'] = 'Kontrolka wyboru daty';
$lang['field_type_TimePickerField'] = 'Kontrolka wyboru czasu';
$lang['field_type_RadioGroupField'] = 'Grupa radiobutton&oacute;w';
$lang['field_type_DispositionDirector'] = '*Wysyłaj wyniki emailem wybranym z listy';
$lang['field_type_DispositionFileDirector'] = '*Zapisz wyniki do pliku wybieranego z listy';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Zapisz wyniki do pliku(&oacute;w) wybieranego z listy wielokrtonego wyboru';
$lang['field_type_DispositionPageRedirector'] = '*Przekieruj do strony wybranej z listy';
$lang['field_type_DispositionEmail'] = '*Wyślij wyniki pod email(e)';
$lang['field_type_DispositionEmailConfirmation'] = '*Adres Walidacji-przez-email';
$lang['field_type_DispositionFile'] = '*Zapisz wyniki do zwykłego pliku';
$lang['field_type_DispositionDatabase'] = '*Zapisz wyniki do bazy danych';
$lang['field_type_DispositionFormBrowser'] = '*Zapisz wynik w formacie zgodnym z modułem FormBrowser v.3';
$lang['field_type_DispositionUserTag'] = '*Wywołaj znacznik użytkownika z wynikami formularza';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Wyślij wyniki na email podany przez użytkownika';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Wyślij wynik do administratora CMS';
$lang['field_type_PageBreakField'] = '-Koniec strony';
$lang['field_type_FileUploadField'] = 'Wgrywanie pliku';
$lang['field_type_FromEmailAddressField'] = 'Pole w emailu &quot;Adres od&quot;';
$lang['field_type_FromEmailNameField'] = 'Pole w emailu &quot;Od&quot;';
$lang['field_type_FromEmailSubjectField'] = 'Pole w emailu &quot;Tytuł&quot;';
$lang['field_type_StaticTextField'] = '-Tekst statyczny';
$lang['field_type_SystemLinkField'] = '-Link statyczny';
$lang['field_type_LinkField'] = 'Link (wprowadzony przez użytkownika)';
$lang['field_type_HiddenField'] = '-Pole ukryte';
$lang['field_type_ComputedField'] = '-Pole obliczeniowe';
$lang['field_type_UniqueIntegerField'] = '-Unikalny identyfikator (numer seryjny)';
$lang['validation_none'] = 'Bez walidacji';
$lang['validation_numeric'] = 'Numeryczne';
$lang['validation_integer'] = 'Pełno-liczbowe (integer)';
$lang['validation_email_address'] = 'Adres email';
$lang['validation_usphone'] = 'Numer telefoniczny (format USA)';
$lang['validation_must_check'] = 'Musi zostać zaznaczone';
$lang['validation_regex_match'] = 'Sprawdzaj poprawność z wyrażeniem regularnym';
$lang['validation_regex_nomatch'] = 'Nie spełnia warunk&oacute;w określonych przez podane wyrażenie regularne';
$lang['required_field_missing'] = 'Wartość dla wymaganego pola nie została podana';
$lang['please_enter_a_value'] = 'Wprowadź wartość dla pola &quot;%s&quot;';
$lang['please_enter_a_number'] = 'Wprowadź liczbę w polu &quot;%s&quot;';
$lang['please_enter_valid'] = 'Wprowadź poprawną wartość w polu &quot;%s&quot;';
$lang['please_enter_an_integer'] = 'Wprowadź wartość pełno-liczbową w polu &quot;%s&quot;';
$lang['please_enter_an_email'] = 'Wprowadź poprawny email w polu &quot;%s&quot;';
$lang['please_enter_a_phone'] = 'Wprowadź poprawny numer telefonicznych w polu &quot;%s&quot;';
$lang['not_valid_email'] = '&quot;%s&quot; nie wydaje się poprawnym adresem email!';
$lang['please_enter_no_longer'] = 'Wprowadź wartość nie dłuższą niż %s znak&oacute;w';
$lang['title_list_delimiter'] = 'Znak używany jako separator w wynikach dających więcej niż jedną wartość';
$lang['you_need_permission'] = 'Potrzebujesz uprawnienie &quot;%s&quot; by wykonać tę operację';
$lang['lackpermission'] = 'Sorry! Nie masz odpowiednich uprawnień by korzystać z tej sekcji.';
$lang['field_order_updated'] = 'Kolejność p&oacute;l zaktualizowana';
$lang['form_deleted'] = 'Formularz został usunięty';
$lang['field_deleted'] = 'Pole zostało usunięte';
$lang['configuration_updated'] = 'Konfiguracja zapisana.';
$lang['you_must_check'] = 'Musisz zaznaczyć &quot;%s&quot; by przejść dalej';
$lang['must_specify_one_destination'] = 'Musisz podać co najmniej jeden adres docelowy!';
$lang['are_you_sure_delete_form'] = 'Na pewno chcesz usunąć formularz %s?';
$lang['are_you_sure_delete_field'] = 'Na pewno chcesz usunąć pole %s?';
$lang['notice_select_type'] = 'Opcje zaawansowane nie są dostępne, dop&oacute;ki nie ustawisz typu pola';
$lang['field_name_in_use'] = 'Nazwa pola &quot;%s&quot; już jest w systemie. Używaj niepowtarzalnych nazw albo wyłącz odpowiednią opcję w konfiguracji modułu.';
$lang['field_no_name'] = 'Pola muszą mieć nazwę, dop&oacute;ki nie wyłączysz tej opcji z konfiguracji modułu.';
$lang['anonymous'] = 'Anonim';
$lang['abbreviation_length'] = 'Dł: %s';
$lang['boxes'] = '%s boks&oacute;w';
$lang['options'] = '%s opcji';
$lang['text_length'] = '%s znak&oacute;w';
$lang['order'] = 'Kolejność';
$lang['unspecified'] = '[nieznane]';
$lang['added'] = 'dodano';
$lang['updated'] = 'zaktualizowano';
$lang['sort_options'] = 'Opcje sortowania wyjścia';
$lang['select_one'] = 'Wybierz jedno';
$lang['select_type'] = 'Wybierz typ';
$lang['to'] = 'Do';
$lang['yes'] = 'Tak';
$lang['no'] = 'Nie';
$lang['recipients'] = 'odbiorcy';
$lang['file_count'] = '%s możliwych plik&oacute;w';
$lang['destination_count'] = '%s cel&oacute;w';
$lang['save'] = 'Zapisz';
$lang['add'] = 'Dodaj';
$lang['update'] = 'Aktualizuj';
$lang['save_and_continue'] = 'Zapisz i kontynuuj edycję';
$lang['information'] = 'Informacje';
$lang['automatic'] = 'Automatycznie';
$lang['forms'] = 'Formularze';
$lang['form'] = 'Formularz %s';
$lang['configuration'] = 'Konfiguracja';
$lang['field_requirement_updated'] = 'Status wymagalności pola został zaktualizowany.';
$lang['maximum_size'] = 'Maksymalny rozmiar';
$lang['permitted_extensions'] = 'Rozrzeszenia';
$lang['permitted_filetypes'] = 'Dozwolone typy plik&oacute;w';
$lang['file_too_large'] = 'Wgrywany plik jest za duży! Maksymalny rozmiar to:';
$lang['illegal_file_type'] = 'Pliki tego typu (tego rozszerzenia) nie mogą być wgrywane do naszego systemu. Sprawdź, czy rozszerzenie jest prawidłowe.';
$lang['upload'] = 'Wgrywanie';
$lang['form_imported'] = 'Formularz zaimportowany.';
$lang['form_import_failed'] = 'Import formularza się nie powi&oacute;dł! Był problem z formatem pliku XML.';
$lang['rows'] = '%s wierszy';
$lang['cols'] = '%s kolumn';
$lang['12_hour'] = '12-godzinny zegar';
$lang['24_hour'] = '24-godzinny zegar';
$lang['hour'] = 'Godzina';
$lang['min'] = 'Minuta';
$lang['merid'] = 'Południk';
$lang['date_range'] = 'Zakres: %s - %s';
$lang['thanks'] = 'Dzięki! Twoja wysyłka została otrzymana.';
$lang['edit'] = 'Edytuj';
$lang['delete'] = 'Kasuj';
$lang['day'] = 'Dzień';
$lang['mon'] = 'Miesiąc';
$lang['year'] = 'Rok';
$lang['none'] = '(brak)';
$lang['uninstalled'] = 'Moduł odinstalowany';
$lang['installed'] = 'Moduł w wersji %s został zainstalowany.';
$lang['upgraded'] = 'Moduł zaktualizowano do wersji %s.';
$lang['button_previous'] = 'Powr&oacute;t...';
$lang['button_submit'] = 'Wyślij formularz';
$lang['button_continue'] = 'Kontynuuj...';
$lang['value_checked'] = 'Zaznaczony';
$lang['value_unchecked'] = 'Odznaczony';
$lang['tab_main'] = 'Gł&oacute;wna';
$lang['tab_symbol'] = 'Ustawienia wyświetlenia formularza';
$lang['tab_submit'] = 'Wysłanie formularza';
$lang['tab_captcha'] = 'Ustawienia Captcha';
$lang['tab_advanced'] = 'Ustawienia Zaawansowane';
$lang['tab_templatelayout'] = 'Szablon formularza';
$lang['tab_submissiontemplate'] = 'Szablon wysłania';
$lang['canuse_smarty'] = '<em>Zmienne smarty są w tym polu dozwolone!</em>';
$lang['add_options'] = 'Dodaj więcej opcji';
$lang['delete_options'] = 'Skasuj zaznaczone opcje';
$lang['add_checkboxes'] = 'Dodaj więcej checkbox-&oacute;w';
$lang['delete_checkboxes'] = 'Skasuj zaznaczone checkbox-y';
$lang['add_address'] = 'Dodaj kolejny adres';
$lang['delete_address'] = 'Skasuj zaznaczone adresy';
$lang['add_destination'] = 'Dodaj kolejnego adresata (cel)';
$lang['delete_destination'] = 'Skasuj wybranych adresat&oacute;w (cele)';
$lang['suspected_spam'] = 'Za dużo emaili zostało wygenerowanych z twojego adresu IP. System anty-spamowy już nie będzie nic od ciebie dostarczał.';
$lang['suspected_spam_log'] = 'Podejrzany spam z adresu IP %s - został zatrzymany.';
$lang['reorder'] = 'Zmień kolejność p&oacute;l';
$lang['cancel'] = 'Anuluj';
$lang['value_set'] = 'Wartość ustawiona: %s';
$lang['help_cataloger_attribute_fields'] = 'Below is a list of the attributes available from the Cataloger module.<br/>You can optionally specify valid ranges, values, or numerous values to be used in filtering the list of items that is displayed to the user.<br/>
<br/>
<strong>Ranges:</strong><br/>
Ranges can be specified by signifying a minimum and maximum value using this syntax: &quot;range: minvalue to maxvalue&quot;<br/>
<br/>
<strong>Multiple Values:</strong><br/>
To specify multiple values for an attribute use the syntax &quot;multi: value1|value2|value3&quot;<br/>
<br/>
<strong>Values from hidden fields</strong><br/>
To specify a value from a hidden field use the syntax {$fld_id}<br/>
<br/>';
$lang['help_name_regex'] = 'Wyrażenie regularne pozwala filtrować wpisy modułu Cataloger po nazwie';
$lang['help_field_height'] = 'Wysokośc listy wielokrotnego wyboru';
$lang['title_name_regex'] = 'Wyrażenie regularne dla nazw wpis&oacute;w modułu Cataloger';
$lang['title_field_height'] = 'Wysokość pola';
$lang['title_file_path'] = 'Docelowy katalog dla plik&oacute;w wytwarzanych przez moduł:';
$lang['title_udt_name'] = 'Znacznik użytkownika';
$lang['title_uploads_destpage'] = 'Strona powrotu z linkiem po uploadzie';
$lang['title_uploadmodule_summary'] = 'Wysłano z modułu FormBuilder';
$lang['title_uploads_category'] = 'Kategoria uploadu';
$lang['title_sendto_uploads'] = 'Wyślij plik do modułu Uploads';
$lang['title_legend'] = 'Legenda';
$lang['title_maximum_length'] = 'Długość maksymalna';
$lang['title_checkbox_label'] = 'Etykieta checkboxa';
$lang['title_radio_label'] = 'Etykieta radiobuttona';
$lang['title_checked_value'] = 'Wartość gdy zaznaczono';
$lang['title_unchecked_value'] = 'Wartość gdy niezaznaczono';
$lang['title_checkbox_details'] = 'Szczeg&oacute;ły grupy checkbox&oacute;w';
$lang['title_delete'] = 'Skasować';
$lang['title_select_one_message'] = 'Tekst dla opcji &quot;Wybierz jeden&quot;';
$lang['title_selection_value'] = 'Wartość zaznaczenia';
$lang['title_selection_displayname'] = 'Nazwa wartości zaznaczenia';
$lang['title_selection_subject'] = 'Temat zaznaczenia';
$lang['title_select_default_country'] = 'Domyślne zaznaczenie';
$lang['title_select_default_state'] = 'Domyślne zaznaczenie';
$lang['title_select_default_province'] = 'Domyślne zaznaczenie';
$lang['title_option_name'] = 'Nazwa opcji';
$lang['title_option_value'] = 'Wysyłana wartość';
$lang['title_pulldown_details'] = 'Opcje listy rozwijalnej';
$lang['title_multiselect_details'] = 'Opcje listy wielokrotnego wyboru';
$lang['title_destination_address'] = 'Docelowy adres e-mail';
$lang['title_destination_filename'] = 'Docelowa nazwa pliku';
$lang['title_email_from_name'] = 'Pole &quot;Od&quot; dla e-maila';
$lang['title_relaxed_email_regex'] = 'Używaj uproszczoną walidację emaila';
$lang['title_relaxed_regex_long'] = 'Używaj szybką walidację dla pola email (np., pozw&oacute;l na wpisanie &quot;x@y&quot; zamiast sprawdzania składni typu &quot;x@y.tld&quot;)';
$lang['title_email_from_address'] = '&quot;Adres od&quot; dla emaila';
$lang['title_email_encoding'] = 'Kodowanie znak&oacute;w dla emaila';
$lang['title_director_details'] = 'Szczeg&oacute;ły listy rozwijalnej dla emaila';
$lang['title_file_name'] = 'Nazwa pliku';
$lang['title_email_subject'] = 'Linia tytułu emaila';
$lang['title_form_name'] = 'Nazwa formularza';
$lang['title_form_status'] = 'Status formularza';
$lang['title_ready_for_deployment'] = 'Gotowy do wdrożenia';
$lang['title_not_ready1'] = 'Niegotowy';
$lang['title_redirect_page'] = 'Strona przekierowania po wysłaniu formularza';
$lang['title_not_ready2'] = 'Dodaj pole obsługi formularza, określające zapisywanie wprowadzonych danych. Możesz';
$lang['title_not_ready_link'] = 'używaj tego skr&oacute;tu';
$lang['title_form_alias'] = 'Alias formularza';
$lang['title_form_fields'] = 'Pola formularza';
$lang['title_field_id'] = 'ID pola';
$lang['title_show_fieldaliases'] = 'Pokaż aliasy p&oacute;l';
$lang['title_show_fieldaliases_long'] = 'Zaznaczenie tego pola spowoduje, że aliasy p&oacute;l będą pokazywane podczas dodawania lub edycji formularza';
$lang['title_field_name'] = 'Nazwa pola';
$lang['title_field_alias'] = 'Alias pola';
$lang['title_radiogroup_details'] = 'Szczeg&oacute;ly grupy radiobutton&oacute;w';
$lang['title_field_type'] = 'Typ pola';
$lang['title_not_ready3'] = 'by stworzyć pole obsługi formularza.';
$lang['title_add_new_form'] = 'Dodaj nowy formularz';
$lang['title_show_version'] = 'Pokazuj wersję modułu Kreatora Formularzy?';
$lang['title_show_version_long'] = 'Ta opcja wstawi numer wersji modułu Kreatora Formularzy (Form Builder) jako komentarz w treści strony, co ułatwi debugowanie i analizę systemu.';
$lang['title_add_new_field'] = 'Dodaj nowe pole';
$lang['title_form_submit_button'] = 'Tekst przycisku wysłania formularza';
$lang['title_submit_button_safety'] = 'Dodać skrypt Javascript do ostatecznego przycisku wysyłania formularza, by uniemożliwić wielokrotne jego naciśnięcie?';
$lang['title_submit_button_safety_help'] = 'Dodaj skrypt bezpieczeństwa';
$lang['title_form_next_button'] = 'Tekst przycisku &quot;Następna strona&quot; (używany przy wielostronicowych formularzach)';
$lang['title_form_prev_button'] = 'Tekst przycisku &quot;Poprzednia strona&quot; (używany przy wielostronicowych formularzach)';
$lang['title_field_validation'] = 'Walidacja pola';
$lang['title_form_css_class'] = 'Klasa CSS dla tego formularza';
$lang['title_field_css_class'] = 'Klasa CSS dla tego pola';
$lang['title_form_required_symbol'] = 'Znak oznaczający pole wymagane';
$lang['title_field_required'] = 'Wymagane';
$lang['title_field_required_long'] = 'Wymagaj wypełnienia tego pola';
$lang['title_hide_label'] = 'Ukryj etykietę';
$lang['title_hide_label_long'] = 'Ukryj nazwę tego pola w widoku formularza';
$lang['title_text'] = 'Statyczny tekst do wyświetlenia';
$lang['title_field_regex'] = 'Regex (regułka) do walidacji';
$lang['title_lines_to_show'] = 'Lista linii do wyświetlenia';
$lang['no_default'] = 'Bez wartości domyślny';
$lang['redirect_after_approval'] = 'Strona przekierowania po zatwierdzeniu';
$lang['title_regex_help'] = 'This regular expression will only be used if &quot;validation type&quot; is set to a regex-related option. Include a full Perl-style regex, including the start/stop slashes and flags (e.g., &quot;/image\.(\d+)/i&quot;)';
$lang['title_field_required_abbrev'] = 'Wymagane';
$lang['title_hide_errors'] = 'Ukryj błędy';
$lang['title_form_displaytype'] = 'Typ wyświetlania formularza';
$lang['title_hide_errors_long'] = 'Ustaw wiadomości o błędach i działaniu systemu (debug) niewidoczne dla użytkownik&oacute;w';
$lang['title_email_template'] = 'Szablon emaila';
$lang['title_maximum_size'] = 'Maksymalny rozmiar pliku wgrywanego (kilobajty)';
$lang['title_maximum_size_long'] = 'Ten limit jest dodatkowym limitem - na pewno Tw&oacute;j serwer lub język PHP ma swoje własne ograniczenia.';
$lang['title_permitted_extensions'] = 'Dozwolone rozszerzenia';
$lang['title_permitted_extensions_long'] = 'Wpisz listę rozszerzeń po przecinku, bez kropek (np., &quot;jpg,gif,jpeg&quot;). Spacje będą ignorowane. Pozostawiając to pole puste - nie będzie ograniczeń w systemie!';
$lang['title_show_limitations'] = 'Wyświetlać dozwolone rozszerzenia?';
$lang['title_show_limitations_long'] = 'Wyświetl każde ograniczenie rozmiaru i rozszerzenia przy polach wgrywania plik&oacute;w?';
$lang['title_form_template'] = 'Szablon do użycia przy Wyświetlaniu formularza';
$lang['title_page_x_of_y'] = 'Strona %s z %s';
$lang['title_no_advanced_options'] = 'To pole nie ma opcji zaawansowanych';
$lang['title_form_unspecified'] = 'Tekst informacji przy niewpisanej wartości pola';
$lang['title_enable_fastadd_long'] = 'Lista nad formularzem, usprawniająca dodawanie nowych p&oacute;l.';
$lang['title_enable_fastadd'] = 'Włącz listę szybkiego wybierania nowego pola dla formularzy?';
$lang['title_fastadd'] = 'Szybki kreator nowych p&oacute;l';
$lang['title_enable_antispam_long'] = 'Zaznaczając tę opcję pozwolisz na wysłanie tylko 10 emaili z jednego adresu IP - w ciągu jednej godziny.';
$lang['title_enable_antispam'] = 'Włącz prymitywne opcje anty-spamowe?';
$lang['title_show_fieldids'] = 'Pokaz ID p&oacute;l';
$lang['title_show_fieldids_long'] = 'Zaznaczając tę opcję wyświetli numer ID gdy dodajesz lub edytujesz formularz';
$lang['title_xml_to_upload'] = 'Wgraj formularz z pliku XML';
$lang['title_xml_upload_formname'] = 'Używaj tej nazwy formularza';
$lang['title_import_legend'] = 'Import formularza XML';
$lang['title_xml_upload_formalias'] = 'Używaj tego aliasu formularza';
$lang['title_html_email'] = 'Generuj email formatu HTML?';
$lang['title_link_autopopulate'] = 'Wypełniać automatycznie?';
$lang['title_link_autopopulate_help'] = 'Automatycznie linkuje do strony na kt&oacute;rej jest formularz (ta opcja nadpisuje poniższą)';
$lang['title_default_link'] = 'Dunyślny URL linku';
$lang['title_default_link_title'] = 'Domyślny tekst linku';
$lang['title_link_to_sitepage'] = 'Link do strony';
$lang['title_captcha_not_installed'] = 'Możesz użyć <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a> do zabezpiecznia formularza po zainstalowania modułu Captcha. Więcej informacji możesz znaleźć na <a href="http://dev.cmsmadesimple.org/projects/captcha/">stronie projektu</a>.';
$lang['title_use_captcha'] = 'Użyć Captcha do zebezpieczenia formularza?';
$lang['title_use_captcha_help'] = 'Zaznacz tę opcję aby używać <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a>.';
$lang['title_user_captcha'] = 'Wpisz tekst z obrazka w to pole (wielkość liter ma znaczenie)';
$lang['title_user_captcha_error'] = 'Komunikat gdy kod Captcha jest niepoprawny';
$lang['wrong_captcha'] = '<ul><li>Tekst z obrazka jest niepoprawny.</l></ul>';
$lang['title_title_user_captcha'] = 'tekst pomocy wyświetlany w formularzu';
$lang['title_dont_submit_unchecked'] = 'Nie zapisuj zmiennych dla niezaznaczonych checkbox&oacute;w';
$lang['title_dont_submit_unchecked_help'] = 'Zaznacz to pole jeśli chcesz aby tylko zaznaczone checkboxy zwracały wartości';
$lang['link_label'] = 'Etykieta linku';
$lang['link_destination'] = 'Docelowy URL linku';
$lang['title_default_set'] = 'Zaznaczony domyślnie?';
$lang['title_24_hour'] = 'Używaj zegara 24-godzinnego?';
$lang['title_before_noon'] = 'AM';
$lang['title_after_noon'] = 'PM';
$lang['title_smarty_eval'] = 'Przetwarzać tagi Smarty w tym polu';
$lang['title_textarea_rows'] = 'Wiersze (może być nadpisane przez style CSS)';
$lang['title_textarea_cols'] = 'Kolumny (może być nadpisane przez style CSS)';
$lang['title_form_main'] = 'Szczeg&oacute;ły głowne formularza';
$lang['title_show_username'] = 'Wyświetlać nazwę użytkownika?';
$lang['title_show_userfirstname'] = 'Wyświetlać imię użytkownika?';
$lang['title_show_userlastname'] = 'Wyświetlać nazwisko użytkownika?';
$lang['title_restrict_to_group'] = 'Limituj listę użytkownik&oacute;w do członk&oacute;w następujących grup';
$lang['restricted_to_group'] = 'Tylko w grupie %s';
$lang['title_show_to_user'] = 'Wyświetlić użytkownikowi?';
$lang['help_leaveempty'] = 'To pole może byc puste';
$lang['help_variables_for_template'] = 'Zmienne dla szablonu';
$lang['help_variables_for_computation'] = 'Dostepne zmienne';
$lang['help_php_variable_name'] = 'Zmienna PHP';
$lang['help_submission_date'] = 'Data wysłania';
$lang['help_server_name'] = 'Tw&oacute;j server';
$lang['help_sub_source_ip'] = 'Adres IP użytkownika, w czasie wysyłania formularza';
$lang['help_sub_url'] = 'URL strony zawierającej formularz';
$lang['help_fb_version'] = 'Wersja modułu FormBuilder';
$lang['help_tab'] = 'Znak tabulacji';
$lang['help_other_fields'] = 'Alternatywne nazwy p&oacute;l formularza mogą być używane zamiennie z normalnymi nazwami. Jest to szczeg&oacute;lnie przydatne przy uzywaniu tag&oacute;w Smarty (gdyż ten ma problemy z obsługą znak&oacute;w ASCII spoza zakresu 32-126). <br />Inne pola będą dostepne gdy dodasz je do formularza.';
$lang['help_array_fields'] = 'Aby uzyskać dostęp do wartości p&oacute;l formularza możesz użyć notacji $fieldname_obj, $alias_obj, or $fld_#_obj, gdzie każde pole jest obiektem zawierającym:<br /><table>
<tr><td class=&quot;odd&quot;>name</td><td class=&quot;odd&quot;>Nazwa pola</td></tr>
<tr><td>type</td><td>Typ pola</td></tr>
<tr><td class=&quot;odd&quot;>id</td><td class=&quot;odd&quot;>Wewnętrzne ID pola</td></tr>
<tr><td>value</td><td>Wartość czytelną dla człowieka</td></tr>
<tr><td class=&quot;odd&quot;>valueArray</td><td class=&quot;odd&quot;>Tablica wartości pola</td></tr></table>
<em>Na przykład:</em>, możesz użyć &quot;{$fld_1_obj->name} = {$fld_1_obj->value}';
$lang['help_date_format'] = 'Sprawdź <a href="http://www.php.net/manual/en/function.date.php" target=_NEW>dokumentacji PHP</a> aby uzyskać pomoc.';
$lang['help_variable_name'] = 'Zmienna';
$lang['help_form_field'] = 'Pole reprezentowane';
$lang['link_back_to_form'] = '&laquo; Wr&oacute;ć do formularza';
$lang['title_create_sample_template'] = 'Stw&oacute;rz przykładowy szablon';
$lang['title_create_sample_html_template'] = 'Stw&oacute;rz przykładowy szablon HTML';
$lang['title_create_sample_header_template'] = 'Stw&oacute;rz przykładowy szablon nagł&oacute;wka';
$lang['title_create_sample_header'] = 'Stw&oacute;rz przykładowy nagł&oacute;wek';
$lang['help_tab_symbol'] = 'znak tabulacji';
$lang['title_file_template'] = 'Szablon jednej linii pliku wynikowego';
$lang['title_file_header'] = 'Szablon nagł&oacute;wka pliku wynikowego';
$lang['title_confirmation_url'] = 'URL do kliknmięcia aby potwierdzić formularz';
$lang['title_value'] = 'Wartość (zobacz zakładkę Zaawansowane, jeśli chcesz uzyć tag&oacute;w Smarty)';
$lang['title_date_format'] = 'Format daty (<a href="http://www.php.net/manual/en/function.date.php">formaty daty w PHP</a>)';
$lang['title_use_wysiwyg'] = 'Używać edytora WYSIWYG dla p&oacute;l tekstowych (tylko w Adminie)?';
$lang['title_submit_actions'] = 'Po wysłaniu formularza';
$lang['title_submit_labels'] = 'Przyciski akcji formularza';
$lang['title_sortable_field'] = 'Pole sortujące #%s';
$lang['title_submit_help'] = 'This page lets you customize Form Submission. It doesn&#039;t determine what the Form Builder does with the submitted data. You can set that up by adding &quot;Disposition&quot; fields to your form.';
$lang['title_start_year'] = 'Start zakresu lat';
$lang['title_end_year'] = 'Koniec zakresu lat';
$lang['title_default_year'] = 'Domyślny rok';
$lang['title_default_year_help'] = '(Ustaw jako -1 by domyślnym był obecny rok)';
$lang['title_submit_action'] = 'Po wysłaniu formularza';
$lang['title_submit_response'] = 'Odpowiedź do wyświetlenia';
$lang['display_text'] = 'Wyświetl szablon wysyłania';
$lang['redirect_to_page'] = 'Przekieruj do strony serwisu';
$lang['title_submit_response_help'] = 'This template is for display to the user after the form is submitted. This template does not effect emails generated or other form dispositions -- you set those templates (where appropriate) in the &quot;advanced&quot; tab for those disposition fields.';
$lang['title_destination_page'] = 'Docelowa strona';
$lang['title_require_fieldnames'] = 'Nazwy p&oacute;l są wymagane';
$lang['title_require_fieldnames_long'] = 'Wymagaj, żeby każe pole miało swoją nazwę?';
$lang['title_unique_fieldnames'] = 'Wymagaj unikalnych nazw p&oacute;l';
$lang['title_unique_fieldnames_long'] = 'Wymagaj, żeby wszystkie nazwy p&oacute;l były unikalne (r&oacute;żniły się od siebie)?';
$lang['title_reorder_form'] = 'Przegrupuj pola';
$lang['title_load_template'] = 'Załaduj szablon';
$lang['title_add_button_text'] = 'Tekst przycisku &quot;Dodaj&quot;';
$lang['title_del_button_text'] = 'Tekst przycisku &quot;Skasuj&quot;';
$lang['title_string_or_number_eval'] = 'Interpretuj zmienne jako numery lub łańcuchy znakowe (stringi)';
$lang['title_order'] = 'Porządek interpretowania';
$lang['title_order_help'] = 'Jeżeli istnieje więcej niż jedno pole obliczeniowe, są one przetwarzane od najmniejszego do największego numeru w kolejności';
$lang['title_compute_value'] = 'Wartość do obliczenia';
$lang['title_string'] = 'Łańcuch znakowy (string)';
$lang['title_numeric'] = 'Numeryczne';
$lang['title_inline_form'] = 'Wyświetlaj formularz w treści strony (inline)?';
$lang['title_inline_form_help'] = 'Wyświetlanie w treści oznacza, że formularz zastępuje znacznik {cms_module}, bez tego ustawienia formularz zastąpi ({content}).';
$lang['title_field_default_value'] = 'Wartość domyślna dla pola';
$lang['title_clear_default'] = 'Wyczyścić wartość domyślną po kliknięciu?';
$lang['title_clear_default_help'] = 'Zaznacz tę opcję by silnik wykasował domyślną wartość kiedy użytkownik naciśnie na to pole w formularzu';
$lang['title_remove_file_from_server'] = 'Skasuj plik z serwera po przetworzeniu (wysłaniu maila)';
$lang['title_field_javascript'] = 'Javascript dla tego pola';
$lang['title_field_javascript_long'] = 'Użyj pełnego wywołania Javascript,włączając wydarzenie, kt&oacute;re chcesz śledzić , np. onclick=&quot;yourfn()&quot;';
$lang['title_submit_javascript'] = 'Javascript dla wysyłania formularza';
$lang['title_submit_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;.<br />This will probably not work well if you use the &quot;safety script&quot; option above.';
$lang['email_from_addr_help'] = 'Nie wybieraj tutaj dowolnego adresu- wielu dostawc&oacute;w internetowych nie dostarczy<br />wiadomości jeśli użyjesz domeny innej niż Twoja własna<br />(użyj na przkład  admin@%s)';
$lang['title_switch_advanced'] = 'Potzrebujesz nowego typu pola? ';
$lang['title_switch_basic'] = 'Za dużo typ&oacute;w p&oacute;l? ';
$lang['title_switch_advanced_link'] = 'Przełącz w Tryb Zaawansowany';
$lang['title_switch_basic_link'] = 'Przełącz w Tryb Prosty';
$lang['title_file_root'] = 'Katalog gdzie zapisany będzie plik';
$lang['title_file_root_help'] = 'To musi być katalog z prawami zapisu dla serwera.<br />Jeśli masz wątpliwości ustaw maskę 777.<br />Sprawdź także czy nie masz ustawionych resrtykcji zapisu w katalogach w konfiguracji PHP.';
$lang['error_cataloger_module_not_available'] = '<strong>Moduł Cataloger jest niezainstalowany lub wyłączony.</strong>';
$lang['warning'] = 'UWAGA!';
$lang['default_template'] = 'Szablon domyślny';
$lang['table_left_template'] = 'Szablon tabelki, tytuły po lewej';
$lang['table_top_template'] = 'Szablon tabelki, tytuł na g&oacute;rze';
$lang['form_template_name'] = 'Szablon z %s';
$lang['template_are_you_sure'] = 'Czy napewno chcesz nadpisać sw&oacute;j szablon wybranym szablonem? (Nawet jeśli naciśniesz OK, będziesz musiał zapisac zmiany)';
$lang['title_bad_function'] = 'Błąd przy obliczaniu wartości &quot;%s&quot;.';
$lang['no_referrer_info'] = 'Brak informacji o HTTP_REFERER';
$lang['validation_param_error'] = 'Błąd walidacji! Upewnij się, że skopiowałeś poprawnie adres z wiadomości!';
$lang['validation_response_error'] = 'Błąd walidacji! Upewnij się, że skopiowałeś poprawnie adres z wiadomości!';
$lang['validation_no_field_error'] = 'Błąd walidacji! Brak pola e-mail w formularzu!';
$lang['upgrade03to04'] = 'Form Template was updated automatically as part of the version 0.3 to version 0.4 upgrade. You may need to make some fixes. If you&#039;re using the default form, simply replace this template with &quot;default&quot; using the pulldown above.';
$lang['admindesc'] = 'Dodawaj, edytuj i zarządzaj interaktywnymi formularzami';
$lang['operators_help'] = 'Jeżeli używasz ewaluacji ciąg&oacute;w, jedyną operacją jest łączenie (+), jeśli zaś używasz ewaluacji numerycznej możesz skorzystac z podstawowych działań matematycznych (+, -, *, /).';
$lang['date_january'] = 'Styczeń';
$lang['date_february'] = 'Luty';
$lang['date_march'] = 'Marzec';
$lang['date_april'] = 'Kwiecień';
$lang['date_may'] = 'Maj';
$lang['date_june'] = 'Czerwiec';
$lang['date_july'] = 'Lipiec';
$lang['date_august'] = 'Sierpień';
$lang['date_september'] = 'Wrzesień';
$lang['date_october'] = 'Październik';
$lang['date_november'] = 'Listopad';
$lang['date_december'] = 'Grudzień';
$lang['submission_error'] = 'Wystąpił błąd podczas przetwarzania formularza.';
$lang['submit_error'] = 'Błąd podczas wysyłania: %s';
$lang['uploads_error'] = 'Błąd podczas zapisu pliku do modułu Uploads: %s';
$lang['nouploads_error'] = 'Nie znaleziono modułu Uploads';
$lang['upload_attach_error'] = 'Wystąpił błąd podczas przetwarzania pliku %s (nazwa tymczasowa: %s, typ %s)';
$lang['submission_error_file_lock'] = 'Błąd: Nie można uzyskać wyłącznego dostępu do pliku.';
$lang['unchecked_by_default'] = 'Dimyślnie: odznacziny';
$lang['checked_by_default'] = 'Dimyślnie: zaznacziny';
$lang['email_default_template'] = 'Wynik wysłania formularza';
$lang['email_template_not_set'] = '<br/>Szablon emaila jeszcze nie jest ustawiony!';
$lang['missing_cms_mailer'] = 'FormBuilder: Brak wymaganego modułu CMSMailer!';
$lang['user_approved_submission'] = 'Użytkownik zaakceptował %s od %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Wydarzenie generowane gdy formularz jest wysyłany';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Wydarzenie generowane gdy wystąpi błąd podczas wysyłania formularza';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Wydarzenie generowane gdy formularz jest wyświetlany';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Event triggered when a FormBuilder form is submitted.</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>value_<name></em> - Supply a default value to a field with the specified name.</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Event triggered if there is an error when a FormBuilder form is submitted</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>error</em> - A list of all known errors (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Event triggered when a FormBuilder form is displayed</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
</ul> ';
$lang['formbuilder_params_response_id'] = 'ID odpowiedzi. Używane przez moduł FormBrowser';
$lang['formbuilder_params_passed_from_tag'] = 'Domyślne wartości pola (sprawdź w pomocy modułu)';
$lang['formbuilder_params_field_id'] = 'ID pola dla wewnętrznych operacji';
$lang['formbuilder_params_form_name'] = 'Nazwa formularza';
$lang['formbuilder_params_form_id'] = 'ID formularza dla wewnętrznych operacji';
$lang['formbuilder_params_general'] = 'Og&oacute;lne parametry dla wewnętrznych operacji';
$lang['template_variable_help'] = '<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>';
$lang['post_install'] = '<p>Make sure to set the &quot;Modify Forms&quot; permissions
on users who will be administering feedback forms. Also, if you&#039;ll be emailing form
results, be sure to update the Configuration appropriately.</p>
<p>Please be aware that a feedback form should not be active (e.g., usable by the public) while
you are still editing the form. You should create the form, and place the tag into an active
content page only when you have finished editing. Otherwise, erroneous results could be returned.</p>
<p>Additionally, this version does not support parallel editing of forms. Please take care that
only one admin is editing a given form at a given time.</p>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create feedback forms (in fact, it&#039;s a replacement of the original Feedback Form module), with the added power of database storage. With its companion module Form Browser, you can use it to create simple database applications.</p>
<p>The forms created using the Form Builder may be inserted
into templates and/or content pages. Forms may contain many kinds of inputs, and may have
validation applied to these inputs. The results of these forms may be handled in a variety of ways.</p>

<h3>How Do I Use it?</h3>
<P>Install it, and poke around the menus. Play with it. Try creating forms, and adding them to your content.
If you get stuck, chat with me on the #cms IRC channel, post to the forum, send me email, or, if you&#039;re
really desperate, try reading the instructions on the rest of this page.</P>

<h3>How Do I Create a Form</h3>
<p>In the CMS Admin Menu, you should get a new menu item called FormBuilder. Click on this. On the page
that gets shown, there are options (at the bottom of the list of Forms) to Add a New Form or Modify
Configuration.</p>

<h3>Adding a Form to a Page</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module=&#039;FormBuilder&#039; form=&#039;sample_form&#039;}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page&#039;s content if you use a WYSIWYG editor such as TinyMCE, FCKEdit, or HTMLArea. These editors may stealthily
change the quote marks (&quot;) into HTML entities (&amp;amp;quot;), and the forms will not show up. Try using
single quotes (&#039;) or editing the HTML directly.</p>

<h3>Working with Forms</h3>
<p>By clicking on a Form&#039;s name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you&#039;ll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing.</p>
<p>Below this, if you have it enabled, is the &quot;fast field adder&quot; pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Form Submission</h4>
<p>When the form is submitted, you can either redirect the user to another page of your site, or you can present the user some message (which can contain any of the user&#039;s form entries, or just static text). In this tab, you select which of these approaches you wish to use, and, if you chose redirection, it allows you to pick the page to redirect users to after a successful form submission.</p>
<p>Also on this page, you can specify the labels of various submission buttons (&quot;Previous&quot;, &quot;next&quot;, &quot;submit&quot;). You can also opt to have some Javascript added to the last page of a form that will prevent multiple submissions (useful on slow servers).</p>
<h4>Form Display Options</h4>
<p>This tab allows for other form customizations, like the symbol to show for required fields.</p>
<h4>Captcha Settings</h4>
<p>If you have installed the Captcha module, this tab lets you configure the Captcha settings for your form.</p>
<h4>Form Template</h4>
<p>This is where you do your customization work of your form&#039;s Smarty Template. See the section called Form Template Variables below.</p>
<p>The form should default to a Custom template that documents the Smarty tags available to you.</p>
<p>Unless you&#039;re a Smarty expert, you probably don&#039;t want to mess around with this. If you are a Smarty expert, this is where you can unleash your magic.</p>
<h4>Submission Template</h4>
<p>If, in the Form Submission tab, you selected &#039;Display &quot;Submission Template&quot;, this is where you can create that template. There is a display of which smarty variables are available to you, and a button to generate a sample template.</p>
<p>If you&#039;re a Smarty expert, you can do all manner of creative and powerful things here. If you&#039;re not a Smarty expert, you might just want to use the default.
</p>

<h3>Adding Fields to your Form</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it&#039;s submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it&#039;s safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked &quot;Required&quot;, which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to &quot;view source&quot; on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It&#039;s really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It&#039;s really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Canadian Province. This is a pulldown listing the Canadian Provinces (Contributed by Noel McGran. Thanks!)</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
<li>Time Picker. This is a set of pulldowns allowing the user to select a time (using 12 or 24 hour clock).</li>
<li>File Upload. This is a file upload field.</li>
<li>Link (User Entered). This creates a double input field for getting a link URL and link title.</li>
<li>Text Field (Multiple). This field creates one or more text inputs with add and delete buttons, effectively giving the end user a way of creating variable-length lists.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the &quot;From&quot; field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the &quot;From&quot; field.</li>
<li>Email Subject Field. This allows users to provide a subject for their email. The email generated when the form gets handled will use this in the &quot;Subject&quot; field. This may cause trouble with certain dispositions that want to control the Email Subject, so use it with caution.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Fieldset Start. Combined with Fieldset End, this allows you to group various fields within your form. Use this to start a given grouping.</li>
<li>-Fieldset End. Combined with Fieldset Start, this allows you to group various fields within your form. Use this to end a given grouping.</li>
<li>-Hidden Field. This allows you to embed a hidden field in your form.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you&#039;re not using a Custom Template to render your form.</li>
<li>-Static Link. This allows you to put a link to a given page into your form. Optionally, you can have it autopopulate with the page where the form is embedded (useful if you&#039;re sending results via email).</li>
<li>-Computed Field. This allows you to embed a computed field in your form. It is not visible to the user until after the form is submitted. It allows you to do simple arithmetic or string concatenation.</li>
<li>-Unique Integer (Serial). This is an integer that increases every time someone hits your form. Your results may not be sequential, but they will increase monotonically.</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<ul><li>*Call a User Defined Tag With the Form Results. This submits all the form results to the User-Defined Tag you specify. The UDT can handle the results however it wants. Values are passed as $param[&#039;field_name&#039;].</li>
<li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these &quot;Director&quot; pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email to User-Supplied Address. This puts an input field in the form for the user to populate with an email address. The form results get sent to that address. Beware of Spam abuse! Active the primitive anti-spam features in the FormBuilder configuration screen.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Redirect to Page Based on Pulldown. This allows you to redirect the form to a different site page depending on its value. If you have multiple dispositions, make sure this is used last.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered &quot;approved,&quot; and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the &quot;output&quot; directory under the
module&#039;s installation directory, assuming the web server has permission to write there.</li>
<li>*Save Results to File Based on Pulldown. Like the Flat File disposition, except the value of a pull-down determines which file results get written to.</li>
<li>*Save Results to File(s) Based on Multiple Selections. Like the Flat File disposition, except the value(s) of checkboxes  determines which file(s) results get written to.</li>
<li>*Email to CMS Admin User. Provides a pull-down of CMS Admin users, and directs the results as an email to the selected admin.</li>
<li>*Store Results for FormBrowser Module v.3. Stores the form results in an XML structure as a single database record. This will become the interface to Form Browser in the next release.</li>

</ul></li></li></ul>


<h3>Passing Default Values to Forms</h3>
<p>Calguy added a nice feature, which is that you can pass default field values to your form via the module tag. This allows you to have
the same form in multiple places, but with different default values. It may not work for more exotic field types, but for fields that have
a single value, you can specify like:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_<i>FIELDNAME</i>=&#039;default_value&#039;}</p>
<p>This will set the field with <i>FIELDNAME</i> to &#039;default_value&#039;.</p>
<p>This can be problematic, as sometimes field names are unweildy or contain characters that don&#039;t work well with Smarty. So there is an
alternative like this:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_fld<i>NUMBER</i>=&#039;default_value&#039;}</p>
<p>That uses field <i>NUMBER</i>, where <i>NUMBER</i> is the internal FormBuilder field id. You might wonder how you know what that id is. Simply go into the FormBuilder configuration tab,
and check &quot;Show Field IDs&quot;</p>

<h3>Email and Flat File Templates</h3>
<p>Many disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it&#039;s own best guess, which may or may not work out to your liking. You can always click on the &quot;Create Sample Template&quot; and then customize the results.</p>
<p>To the right, you&#039;ll find a legend which lists all of the variables that are available to you to use in your template. As of version 0.3, variables have two names, one based on the field name, the other based on the field ID. If you use field names that have characters outside of the ASCII 32-126 range, it will be safer to use the ID-based variables.</p>
<p><strong>Note that once you&#039;ve changed a template, it will no longer automatically add new fields.</strong> For this reason, it&#039;s usually best to create your templates as the last step of creating your form.</p>
<p>As of version 0.2.4, you can opt to send any of these emails as HTML email. There should be a checkbox at the top of the template page for this. There is also a &quot;Create Sample HTML Template&quot; button over in the legend area. For HTML email, the email body will also provide the default text-only values.</p>

<h3>Configuration</h3>
<p>There are some global configuration options for FormBuilder:</p>
<ul>
<li>Enable fast field add pulldown. This enables the pulldown on the Form Edit page which saves a step in the creation of new fields.</li>
<li>Hide Errors. This is set by default. Unchecking it will cause more detailed errors to be displayed if there are problems when you submit your form.</li>
<li>Require Field Names. Typically, you will want form fields to be named so you can tell which is which. However, in some cases, you might want to have nameless fields. Uncheck this if you want to allow nameless fields.</li>
<li>Unique Field Names. Typically, you will want form fields to have unique names so you can tell which is which. Uncheck this if you want to allow fields to share names.</li>
<li>Use relaxed email validation. This uses a less restrictive regular expression for validating email; e.g., x@y will be allowed, where typically x@y.tld is required.</li>
<li>Show Form Builder Version. Displays the version of FormBuilder you&#039;re using in a comment when the form is generated. Typically only useful when debugging.</li>
<li>Enable primitive anti-spam features. When turned on, this allows any given IP address to only generate 10 emails per hour.</li>
<li>Show Field IDs. When turned on, FormBuilder will display field ids when adding or editing a form.</li>
</ul>
<h3>Styling and CSS</h3>
<p>Paul Noone graciously provides us all with a pretty good standard CSS that you can use for forms:</p>
<pre>
	/* Sample FormBuilder CSS base */
	form {margin-top:0}
	form, td, th, li { font-size: 100%}
	form div {margin-bottom:0}
	fieldset div {
		margin-bottom:0.5em;
		margin-left:1em;
	}
	fieldset div div {
		margin-top:0.5em;
		margin-left:1em
	}
	fieldset {
		margin-bottom:1em;
		border:1px solid #F60;
		padding:0.5em
	}
	fieldset label {
		width:auto;
	}
	legend {
		color:#FFF;
		background:#F60;
		font-style:italic;
		font-size:1.2em;
		margin-bottom:0.5em;
		padding:0.2em;
		width:auto;
		border:1px solid #CCC
	}
	textarea {
		margin: 0.5em 0;
		width:98%;
		height: 6em
	}

	/* Apply this class to text/select input fields with shorter labels
		to help alignment */
	.short-label label {float:left; width:10em}
	.short-label fieldset div input,
	.short-label fieldset div select {width:16em}

	/* Pretty up your Captcha image output */
	.captcha {
		margin:0.5em 0;
		width:200px;
		text-align:center
	}
	.captcha img {border:1px solid #F60; margin-bottom:0.5em}
	.captcha input {width:196px; margin-top:0.5em}

	/* Just a bit more room for the Submit button */
	.submit {margin-top:0.5em}
</pre>

<h3>Form Template Variables</h3>

<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the &amp;#123;$fb_hidden} and &amp;#123;$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., &amp;#123;$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for label for=&quot;foo&quot;)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>


<h3>Known Issues</h3>
<ul>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn&#039;t matter since the user side is pretty simple.</li>
<li>FileUpload Fields may not work correctly with multipage forms.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you&#039;re running CMS 1.1 or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you&#039;re missing fields in an email that gets generated, check the disposition field&#039;s template, and make sure you&#039;re specifying the missing fields. Seems obvious, but it&#039;s an easy mistake to make.</li>
<li>Uncheck the &quot;Hide Errors&quot; checkbox in the global options, and see what message gets displayed when you submit your form.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is no longer a particularly early version, but it is probably still buggy. While I&#039;ve done all I can
to make sure no egregious bugs have crept in, I have to admit that during early testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor&#039;s nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href="mailto:sjg@cmsmodules.com">&amp;lt;sjg@cmsmodules.com&amp;gt;</a>.</li>
<li>Additional discussion of this module may also be found in the <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
</ul>
<p>Keep in mind that the author has put hundreds of hours into the development of this module. Please take the time to read the documentation before sending questions. Either that, or write your questions on financially negotiable instruments (i.e., cash).</p>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &amp;copy; 2008, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com">&amp;lt;sjg@cmsmodules.com&amp;gt;</a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '<ul>
<li>Version 0.5.3. 26 May 08. Bugfixes to previous set of bugfixes. Now ready for major upgrades for 0.6.</li>
<li>Version 0.5.2. 25 May 08. Bugfixes. Release in preparation for substantial reworking for 0.6</li>
<li>Version 0.5.1. 30 April 08. Bugfixes, rewrote some of the File Upload code to prevent white screen of annoyance.</li>
<li>Version 0.5. 19 April 08. Bugfixes, support for FormBrowser fixes and features, disposition type for upcoming FormBrowser version.</li>
<li>Version 0.4.4. 26 Sept 07. Bugfixes for radio button groups, fix for validation of DispositionDeliverToEmailAddressField.</li>
<li>Version 0.4.3. 18 Sept 07. Bugfixes for pulldowns using numbers, option to inline form, fixes for table-layouts provided by Ap Muthu, fix for requirability of Dispositions.</li>
<li>Version 0.4.2. 14 Sept 07. Bugfixes for XML export, RadioButton Group submission, and HTML labels.</li>
<li>Version 0.4.1. Bugfixes for File Disposition Types.</li>
<li>Version 0.4
	<ul>
		<li>Upped minimum CMS version to 1.1</li>
		<li>Numerous Bug fixes; too many to enumerate here</li>
		<li>Massive rejiggering of code to work with CMS MS 1.1 parameter sanitizing regime</li>
		<li>Added field types: &quot;TextField (Multiple)&quot; and &quot;Computed Field&quot;</li>
		<li>Added dispositions: &quot;Save Results to File Based on Pulldown&quot; and &quot;Save Results to File(s) Based on Multiple Selections&quot;(Calguy)</li>
		<li>Added neat-o AJAX-y template-copying for Form Templates, gave versions of old table-based templates to soothe the raging masses.</li>
		<li>Added ability to pass default values to form elements from module tag using value_FIELDNAME=&quot;value&quot; syntax (Calguy)</li>
		<li>Added option to display field ids in admin (Calguy)</li>
	</ul>
</li>
<li>Version 0.3
   <ul>
      <li>Added Captcha module support.</li>
      <li>Reworked labeling of form elements to be XHTML compliant</li>
      <li>Added Paul Noone&#039;s new, improved contact form templates</li>
      <li>Implementation of Email Subject Field</li>
      <li>Added admin-specifiable values to hidden field type, which may contain parsable smarty tags</li>
      <li>Text Area Field now allows specification of rows and cols in the admin, instead of CSS</li>
      <li>Added Drag&#039;n&#039;Drop reordering of form fields.</li>
      <li>Added non-blank field name and unique field name global configuration options and validation</li>
      <li>Implemented templated display of form results upon submission in addition to page redirecting</li>
      <li></li>
   </ul>
</li>
<li>Version 0.2.4 - 09 May 2007
   <p>Big release:<ul>
   <li>Added &quot;Email Form to User-Supplied Address&quot; disposition.</li>
   <li>Added &quot;TimePicker&quot; field type. Split &quot;Link&quot; field into a &quot;User-supplied Link&quot; field and a &quot;Static Link&quot; field.</li>
   <li>Added HTML email option and auto-templates for all email dispositions.</li>
   <li>Added primitive anti-spam features.</li>
   <li>Added XML-based import and export of forms.</li>
   </ul>
   </p>
</li>
<li>Version 0.2.3
   <p>Add the ability to call a selectable user defined tag upon disposition of the form.</p>
</li>
<li>Version 0.2.2
   <p>Many thanks to Utter Design for sponsoring some changes and bugfixes, which include:
   <ul>
      <li>Added file upload capabilities to the email disposition</li>
      <li>Add PageSetStart and PageSetEnd field types
      <p>These field types allow you to create fieldsets in your form, and organise
      your fields logically for the user.  You can even nest fieldsets, and
      associate a style with them appropriately.  The default template was changed
      to prevent it from wrapping a div around these types of fields.
      </p>
      </li>
      <li>Fixed a problem with DATETIME fields on install
      <p>This solves a problem when on install the response table would sometimes not get created when using adodb lite</li>
      </li>
   </ul>
   </p>
</li>
<li>Version 0.2 - 14 November 2006. Calguy &amp;amp; tsw&#039;s bug fixes for field re-ordering and custom templates. Additional bug fixes for field labels.</li>
<li>Version 0.1 - 8 July 2006. Initial Release</li>
</ul>
';
$lang['utma'] = '156861353.2359145497878676500.1213200278.1219058659.1219062741.88';
$lang['utmz'] = '156861353.1219058659.87.16.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/|utmcmd=referral';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/pt_PT.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Form Builder';
$lang['field_type_'] = 'Field Type Not Set';
$lang['field_type_FieldsetEnd'] = '-Fieldset End';
$lang['field_type_FieldsetStart'] = '-Fieldset Start';
$lang['field_type_TextField'] = 'Text Input';
$lang['field_type_TextFieldExpandable'] = 'Text Input (Multiple)';
$lang['field_type_TextAreaField'] = 'Text Area';
$lang['field_type_CheckboxField'] = 'Check Box';
$lang['field_type_CheckboxGroupField'] = 'Check Box Group';
$lang['field_type_PulldownField'] = 'Pulldown';
$lang['field_type_MultiselectField'] = 'Multiselect';
$lang['field_type_StatePickerField'] = 'U.S. State Picker';
$lang['field_type_ProvincePickerField'] = 'Canadian Province Picker';
$lang['field_type_CountryPickerField'] = 'Country Picker';
$lang['field_type_DatePickerField'] = 'Date Picker';
$lang['field_type_TimePickerField'] = 'Time Picker';
$lang['field_type_RadioGroupField'] = 'Radio Button Group';
$lang['field_type_DispositionDirector'] = '*Email Results Based on Pulldown';
$lang['field_type_DispositionFileDirector'] = '*Save Results to File Based on Pulldown';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Save Results to File(s) Based on Multiple Selections';
$lang['field_type_DispositionPageRedirector'] = '*Redirect to Page Based on Pulldown';
$lang['field_type_DispositionEmail'] = '*Email Results to set Address(es)';
$lang['field_type_DispositionEmailConfirmation'] = '*Validate-via-Email Address';
$lang['field_type_DispositionFile'] = '*Write Results to Flat File';
$lang['field_type_DispositionDatabase'] = '*Store Results in Database';
$lang['field_type_DispositionFormBrowser'] = '*Store Results for FormBrowser Module v.3';
$lang['field_type_DispositionUserTag'] = '*Call A User Defined Tag With the Form Results';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Email to User-Supplied Email Address';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Email to CMS Admin User';
$lang['field_type_PageBreakField'] = '-Page Break';
$lang['field_type_FileUploadField'] = 'File Upload';
$lang['field_type_FromEmailAddressField'] = 'Email &quot;From Address&quot; Field';
$lang['field_type_FromEmailNameField'] = 'Email &quot;From Name&quot; Field';
$lang['field_type_FromEmailSubjectField'] = 'Email &quot;Subject&quot; Field';
$lang['field_type_StaticTextField'] = '-Static Text';
$lang['field_type_SystemLinkField'] = '-Static Link';
$lang['field_type_LinkField'] = 'Link (User-entered)';
$lang['field_type_HiddenField'] = '-Hidden Field';
$lang['field_type_ComputedField'] = '-Computed Field';
$lang['field_type_UniqueIntegerField'] = '-Unique Integer (Serial)';
$lang['validation_none'] = 'No Validation';
$lang['validation_numeric'] = 'Numeric';
$lang['validation_integer'] = 'Integer';
$lang['validation_email_address'] = 'Email Address';
$lang['validation_usphone'] = 'Phone Number (US)';
$lang['validation_must_check'] = 'Must Be Checked';
$lang['validation_regex_match'] = 'Match Regular Expression';
$lang['validation_regex_nomatch'] = 'Doesn&#039;t match Regular Expression';
$lang['required_field_missing'] = 'A value was not supplied for a required field';
$lang['please_enter_a_value'] = 'Digite um valor para &quot;%s&quot;';
$lang['please_enter_a_number'] = 'Digite um numero para &quot;%s&quot;';
$lang['please_enter_valid'] = 'Digite uma entrada v&aacute;lida para &quot;%s&quot;';
$lang['please_enter_an_integer'] = 'Please enter an integer value for &quot;%s&quot;';
$lang['please_enter_an_email'] = 'Digite um E-mail v&aacute;lido para &quot;%s&quot;';
$lang['please_enter_a_phone'] = 'Digite um Numero de Telefone v&aacute;lido para &quot;%s&quot;';
$lang['not_valid_email'] = '&quot;%s&quot; n&atilde;o parece ser um E-mail v&aacute;lido!';
$lang['please_enter_no_longer'] = 'Digite um valor que n&atilde;o seja mais do que %s caracteres';
$lang['title_list_delimiter'] = 'Character to use as delimiter in results that return more than one value';
$lang['you_need_permission'] = 'You need the &quot;%s&quot; permission to perform that operation.';
$lang['lackpermission'] = 'Sorry! You don&#039;t have adequate privileges to access this section.';
$lang['field_order_updated'] = 'Field order updated.';
$lang['form_deleted'] = 'Form deleted.';
$lang['field_deleted'] = 'Field deleted.';
$lang['configuration_updated'] = 'Configuration Updated.';
$lang['you_must_check'] = 'You must check &quot;%s&quot; in order to continue.';
$lang['must_specify_one_destination'] = 'You need to specify at least one destination address!';
$lang['are_you_sure_delete_form'] = 'Are you sure you want to delete the form %s?';
$lang['are_you_sure_delete_field'] = 'Are you sure you want to delete the field %s?';
$lang['notice_select_type'] = 'Advanced options are not available until the field type has been set.';
$lang['field_name_in_use'] = 'The field name &quot;%s&quot; is already in use. Please use unique field names, or disable unique field names in the Form Builder configuration.';
$lang['field_no_name'] = 'Fields must be named, unless you disable this in the Form Builder configuration.';
$lang['anonymous'] = 'Anonymous';
$lang['abbreviation_length'] = 'Len: %s';
$lang['boxes'] = '%s boxes';
$lang['options'] = '%s options';
$lang['text_length'] = '%s chars.';
$lang['order'] = 'Order';
$lang['unspecified'] = '[unspecified]';
$lang['added'] = 'added';
$lang['updated'] = 'updated';
$lang['sort_options'] = 'Sort options on output';
$lang['select_one'] = 'Select One';
$lang['select_type'] = 'Select Type';
$lang['to'] = 'To';
$lang['yes'] = 'Yes';
$lang['no'] = 'No';
$lang['recipients'] = 'recipients';
$lang['file_count'] = '%s possible files';
$lang['destination_count'] = '%s destinations';
$lang['save'] = 'Save';
$lang['add'] = 'Add';
$lang['update'] = 'Update';
$lang['save_and_continue'] = 'Save and Continue Editing';
$lang['information'] = 'Information';
$lang['automatic'] = 'Automatic';
$lang['forms'] = 'Forms';
$lang['form'] = 'Form %s';
$lang['configuration'] = 'Configuration';
$lang['field_requirement_updated'] = 'Field required state updated.';
$lang['maximum_size'] = 'Max. Size';
$lang['permitted_extensions'] = 'Extensions';
$lang['permitted_filetypes'] = 'Allowed file types';
$lang['file_too_large'] = 'Uploaded file is too large! Maximum size is:';
$lang['illegal_file_type'] = 'This type of file may not be uploaded. Please check that the extension is correct.';
$lang['upload'] = 'Upload';
$lang['form_imported'] = 'Form Imported.';
$lang['form_import_failed'] = 'Form import failed! There was a problem with the format of the XML file.';
$lang['rows'] = '%s rows';
$lang['cols'] = '%s cols';
$lang['12_hour'] = '12 Hour Clock';
$lang['24_hour'] = '24 Hour Clock';
$lang['hour'] = 'Hour';
$lang['min'] = 'Minute';
$lang['merid'] = 'Meridian';
$lang['date_range'] = 'Range: %s - %s';
$lang['thanks'] = 'Thanks! Your submissions have been received.';
$lang['edit'] = 'Edit';
$lang['delete'] = 'Delete';
$lang['day'] = 'Day';
$lang['mon'] = 'Month';
$lang['year'] = 'Year';
$lang['none'] = '(none)';
$lang['uninstalled'] = 'Module uninstalled.';
$lang['installed'] = 'Module version %s installed.';
$lang['upgraded'] = 'Module upgraded to version %s.';
$lang['button_previous'] = 'Back...';
$lang['button_submit'] = 'Submit Form';
$lang['button_continue'] = 'Continue...';
$lang['value_checked'] = 'Checked';
$lang['value_unchecked'] = 'Unchecked';
$lang['tab_main'] = 'Main';
$lang['tab_symbol'] = 'Form Display Settings';
$lang['tab_submit'] = 'Form Submission';
$lang['tab_captcha'] = 'Captcha Settings';
$lang['tab_advanced'] = 'Advanced Settings';
$lang['tab_templatelayout'] = 'Form Template';
$lang['tab_submissiontemplate'] = 'Submission Template';
$lang['canuse_smarty'] = '<em>Smarty variables are valid in this field.</em>';
$lang['add_options'] = 'Add More Options';
$lang['delete_options'] = 'Delete Marked Options';
$lang['add_checkboxes'] = 'Add More Checkboxes';
$lang['delete_checkboxes'] = 'Delete Marked Checkboxes';
$lang['add_address'] = 'Add Another Address';
$lang['delete_address'] = 'Delete Marked Addresses';
$lang['add_destination'] = 'Add Another Destination';
$lang['delete_destination'] = 'Delete Marked Destinations';
$lang['suspected_spam'] = 'Too many emails generated from your IP address. Anti-Spam code has prevented delivery.';
$lang['suspected_spam_log'] = 'Suspected spam from IP %s stopped.';
$lang['reorder'] = 'Reorder Fields';
$lang['cancel'] = 'Cancel';
$lang['value_set'] = 'Value set: %s';
$lang['title_file_path'] = 'Destination Directory for output files';
$lang['title_udt_name'] = 'User Defined Tag';
$lang['title_uploads_destpage'] = 'Page to return to with uploads link';
$lang['title_uploadmodule_summary'] = 'Submitted with formbuilder';
$lang['title_uploads_category'] = 'Uploads category';
$lang['title_sendto_uploads'] = 'Send this file to the uploads module';
$lang['title_legend'] = 'Legend';
$lang['title_maximum_length'] = 'Maximum Length';
$lang['title_checkbox_label'] = 'Checkbox label';
$lang['title_radio_label'] = 'Radio Button label';
$lang['title_checked_value'] = 'Value when checked';
$lang['title_unchecked_value'] = 'Value when not checked.';
$lang['title_checkbox_details'] = 'Checkbox Group Details';
$lang['title_delete'] = 'Delete?';
$lang['title_select_one_message'] = '&quot;Select One&quot; Text';
$lang['title_selection_value'] = 'Selection Value';
$lang['title_selection_displayname'] = 'Selection Display Name';
$lang['title_selection_subject'] = 'Selection Subject';
$lang['title_select_default_country'] = 'Default Selection';
$lang['title_select_default_state'] = 'Default Selection';
$lang['title_select_default_province'] = 'Default Selection';
$lang['title_option_name'] = 'Option Name';
$lang['title_option_value'] = 'Value Submitted';
$lang['title_pulldown_details'] = 'Pulldown Options';
$lang['title_multiselect_details'] = 'Multiselect Options';
$lang['title_destination_address'] = 'Destination Email Address';
$lang['title_destination_filename'] = 'Destination File Name';
$lang['title_email_from_name'] = '&quot;From name&quot; for email';
$lang['title_relaxed_email_regex'] = 'Use relaxed email validation';
$lang['title_relaxed_regex_long'] = 'Use relaxed email address validation (e.g., allow &quot;x@y&quot; instead of requiring &quot;x@y.tld&quot;)';
$lang['title_email_from_address'] = '&quot;From address&quot; for email';
$lang['title_email_encoding'] = 'Email character set encoding';
$lang['title_director_details'] = 'Pulldown-based Emailer Details';
$lang['title_file_name'] = 'File Name';
$lang['title_email_subject'] = 'Email Subject Line';
$lang['title_form_name'] = 'Form Name';
$lang['title_form_status'] = 'Form Status';
$lang['title_ready_for_deployment'] = 'Ready for Deployment';
$lang['title_not_ready1'] = 'Not Ready';
$lang['title_redirect_page'] = 'Page to redirect to after form submission';
$lang['title_not_ready2'] = 'Please add a field to the form so that the user&#039;s input gets handled. You can';
$lang['title_not_ready_link'] = 'use this shortcut';
$lang['title_form_alias'] = 'Form Alias';
$lang['title_form_fields'] = 'Form Fields';
$lang['title_field_id'] = 'Field Id';
$lang['title_show_fieldaliases'] = 'Show Field Aliases';
$lang['title_show_fieldaliases_long'] = 'Clicking this will display field aliases when adding or editing a form';
$lang['title_field_name'] = 'Field Name';
$lang['title_field_alias'] = 'Field Alias';
$lang['title_radiogroup_details'] = 'Radio Button Group Details';
$lang['title_field_type'] = 'Field Type';
$lang['title_not_ready3'] = 'to create a form handling field.';
$lang['title_add_new_form'] = 'Add New Form';
$lang['title_show_version'] = 'Show Form Builder Version?';
$lang['title_show_version_long'] = 'This will embed your installed version number of Form Builder module in a comment, to aid in debugging';
$lang['title_add_new_field'] = 'Add New Field';
$lang['title_form_submit_button'] = 'Form Submit Button Text';
$lang['title_submit_button_safety'] = 'Add Javascript to final Submit Button that will help prevent multiple submissions?';
$lang['title_submit_button_safety_help'] = 'Add safety script';
$lang['title_form_next_button'] = 'Form &quot;Next&quot; Button Text (used for multipage forms)';
$lang['title_form_prev_button'] = 'Form &quot;Previous&quot; Button Text (used for multipage forms)';
$lang['title_field_validation'] = 'Field Validation';
$lang['title_form_css_class'] = 'CSS Class for this form';
$lang['title_field_css_class'] = 'CSS Class for this field';
$lang['title_form_required_symbol'] = 'Symbol to mark required Fields';
$lang['title_field_required'] = 'Required';
$lang['title_field_required_long'] = 'Require a response for this Field';
$lang['title_hide_label'] = 'Hide Label';
$lang['title_hide_label_long'] = 'Hide this field&#039;s name on Form';
$lang['title_text'] = 'Static text to display';
$lang['title_field_regex'] = 'Validation Regex';
$lang['title_lines_to_show'] = 'Number of Lines to display';
$lang['no_default'] = 'No Default';
$lang['redirect_after_approval'] = 'Page to redirect after approval';
$lang['title_regex_help'] = 'This regular expression will only be used if &quot;validation type&quot; is set to a regex-related option. Include a full Perl-style regex, including the start/stop slashes and flags (e.g., &quot;/image\.(\d+)/i&quot;)';
$lang['title_field_required_abbrev'] = 'Req&#039;d';
$lang['title_hide_errors'] = 'Hide Errors';
$lang['title_form_displaytype'] = 'Form Display Type';
$lang['title_hide_errors_long'] = 'Prevent debug / error messages from being seen by users.';
$lang['title_email_template'] = 'Email Template';
$lang['title_maximum_size'] = 'Maximum upload file size (kilobytes)';
$lang['title_maximum_size_long'] = 'This limitation is in addition to any limits set by the php or web server configuration';
$lang['title_permitted_extensions'] = 'Permitted Extensions';
$lang['title_permitted_extensions_long'] = 'Enter a comma-separated list, excluding the dot (e.g., &quot;jpg,gif,jpeg&quot;). Spaces will be ignored. Leaving this blank means there will be no restrictions.';
$lang['title_show_limitations'] = 'Display restrictions?';
$lang['title_show_limitations_long'] = 'Display any size and extension restrictions with the upload field?';
$lang['title_form_template'] = 'Template to use to Display Form';
$lang['title_page_x_of_y'] = 'Page %s of %s';
$lang['title_no_advanced_options'] = 'Field has no advanced options.';
$lang['title_form_unspecified'] = 'Text to return for unspecified field values';
$lang['title_enable_fastadd_long'] = 'Enable fast field adding pulldown for forms?';
$lang['title_enable_fastadd'] = 'Enable fast field add pulldown?';
$lang['title_fastadd'] = 'Fast field adder';
$lang['title_enable_antispam_long'] = 'Clicking this will only allow 10 emails to be triggered from a given IP address (per hour).';
$lang['title_enable_antispam'] = 'Enable primitive anti-spam features?';
$lang['title_show_fieldids'] = 'Show Field IDs';
$lang['title_show_fieldids_long'] = 'Clicking this will allow displaying field ids when adding or editing a form';
$lang['title_xml_to_upload'] = 'Upload form from XML file';
$lang['title_xml_upload_formname'] = 'Use this form name';
$lang['title_import_legend'] = 'XML Form Import';
$lang['title_xml_upload_formalias'] = 'Use this form alias';
$lang['title_html_email'] = 'Generate HTML email?';
$lang['title_link_autopopulate'] = 'Automatically populate?';
$lang['title_link_autopopulate_help'] = 'Automatically populate with the URL of the page containing the form? (this overrides site page link option below)';
$lang['title_default_link'] = 'Default link URL';
$lang['title_default_link_title'] = 'Default link text';
$lang['title_link_to_sitepage'] = 'Link to site page';
$lang['title_captcha_not_installed'] = 'You can use <a href=&quot;http://www.wikipedia.org/wiki/Captcha&quot; target=&quot;_new&quot;>&quot;Captcha&quot;</a> to protect form submissions if you install the Captcha module. For more information, <a href=&quot;http://dev.cmsmadesimple.org/projects/captcha/&quot;>check the Captcha project</a>.';
$lang['title_use_captcha'] = 'Use Captcha to protect form submissions?';
$lang['title_use_captcha_help'] = 'Check here to protect your form with a <a href=&quot;http://www.wikipedia.org/wiki/Captcha&quot; target=&quot;_new&quot;>&quot;Captcha&quot;</a>.';
$lang['title_user_captcha'] = 'Please confirm that you are not a script by entering the letters from the image.';
$lang['title_user_captcha_error'] = 'Failed text for Captcha';
$lang['wrong_captcha'] = 'Captcha was not correct.';
$lang['title_title_user_captcha'] = 'Help text for Captcha';
$lang['title_dont_submit_unchecked'] = 'Don&#039;t submit values for unchecked boxes';
$lang['title_dont_submit_unchecked_help'] = 'Check this if you only want checked boxes to return values.';
$lang['link_label'] = 'Link Label';
$lang['link_destination'] = 'Link Destination URL';
$lang['title_default_set'] = 'Checked by Default?';
$lang['title_24_hour'] = 'Use 24-hour clock?';
$lang['title_before_noon'] = 'AM';
$lang['title_after_noon'] = 'PM';
$lang['title_smarty_eval'] = 'Process smarty tags within field?';
$lang['title_textarea_rows'] = 'Rows (note: this may be overridden by CSS)';
$lang['title_textarea_cols'] = 'Columns (note: this may be overridden by CSS)';
$lang['title_form_main'] = 'Main Form Details';
$lang['title_show_username'] = 'Display User&#039;s login name?';
$lang['title_show_userfirstname'] = 'Display User&#039;s first name?';
$lang['title_show_userlastname'] = 'Display User&#039;s last name?';
$lang['title_restrict_to_group'] = 'Restrict user list to users in specified group';
$lang['restricted_to_group'] = 'Only in group %s';
$lang['title_show_to_user'] = 'Display to user?';
$lang['help_leaveempty'] = 'This field may be left empty';
$lang['help_variables_for_template'] = 'Variables For Template';
$lang['help_variables_for_computation'] = 'Variables Available';
$lang['help_php_variable_name'] = 'PHP variable';
$lang['help_submission_date'] = 'Date of Submission';
$lang['help_server_name'] = 'Your server';
$lang['help_sub_source_ip'] = 'IP address of person using form';
$lang['help_sub_url'] = 'URL of page containing form';
$lang['help_fb_version'] = 'FormBuilder version';
$lang['help_tab'] = 'Tab Character';
$lang['help_other_fields'] = 'Alternate field names can be used interchangeably (especially useful if Smarty is choking on characters outside of ASCII 32-126). <br />Other fields will be available as you add them to the form.';
$lang['help_array_fields'] = 'Fields that have multiple values may also be accessed via the smarty value of $fieldname_array or $fld_#_array.';
$lang['help_date_format'] = 'See <a href=&quot;http://www.php.net/manual/en/function.date.php&quot; target=_NEW>the PHP Manual</a> for formatting help.';
$lang['help_variable_name'] = 'Variable';
$lang['help_form_field'] = 'Field Represented';
$lang['link_back_to_form'] = '&laquo; Back to Form';
$lang['title_create_sample_template'] = 'Create Sample Template';
$lang['title_create_sample_html_template'] = 'Create Sample HTML Template';
$lang['title_create_sample_header'] = 'Create Sample Header';
$lang['help_tab_symbol'] = 'a tab character';
$lang['title_file_template'] = 'Template for one line of output file';
$lang['title_file_header'] = 'Template for the header of output file';
$lang['title_confirmation_url'] = 'URL to click for form confirmation';
$lang['title_value'] = 'Value (see Advanced Tab if you use Smarty tags)';
$lang['title_date_format'] = 'Date Format (standard <a href=&quot;http://www.php.net/manual/en/function.date.php&quot;>PHP Date Formats</a>)';
$lang['title_use_wysiwyg'] = 'Use WYSIWYG editor for text Area (Admin side only)?';
$lang['title_submit_actions'] = 'Form Submission Behavior';
$lang['title_submit_labels'] = 'Submission Button Labels';
$lang['title_sortable_field'] = 'Sortable Field #%s';
$lang['title_submit_help'] = 'This page lets you customize Form Submission. It doesn&#039;t determine what the Form Builder does with the submitted data. You can set that up by adding &quot;Disposition&quot; fields to your form.';
$lang['title_start_year'] = 'Year range start';
$lang['title_end_year'] = 'Year range end';
$lang['title_default_year'] = 'Default Year';
$lang['title_default_year_help'] = '(Set to -1 for default year to be the current year)';
$lang['title_submit_action'] = 'After form is submitted';
$lang['title_submit_response'] = 'Response to display';
$lang['display_text'] = 'Display &quot;Submission Template&quot;';
$lang['redirect_to_page'] = 'Redirect to site page';
$lang['title_submit_response_help'] = 'This template is for display to the user after the form is submitted. This template does not effect emails generated or other form dispositions -- you set those templates (where appropriate) in the &quot;advanced&quot; tab for those disposition fields.';
$lang['title_destination_page'] = 'Destination Page';
$lang['title_require_fieldnames'] = 'Require Fieldnames';
$lang['title_require_fieldnames_long'] = 'Require fields to have a name?';
$lang['title_unique_fieldnames'] = 'Require Unique Fieldnames';
$lang['title_unique_fieldnames_long'] = 'Require fields to have unique names?';
$lang['title_reorder_form'] = 'Reorder Fields';
$lang['title_load_template'] = 'Load template';
$lang['title_add_button_text'] = 'Add Button text';
$lang['title_del_button_text'] = 'Delete Button text';
$lang['title_string_or_number_eval'] = 'Interpret variables as being numbers or strings';
$lang['title_order'] = 'Interpretation Order';
$lang['title_order_help'] = 'If more than one Computed Field exists, they will be computed from lowest order number to highest order number';
$lang['title_compute_value'] = 'Value to compute';
$lang['title_string'] = 'String';
$lang['title_numeric'] = 'Numeric';
$lang['title_inline_form'] = 'Display form inline?';
$lang['title_inline_form_help'] = 'Inline means any form followup replaces the {cms_module} tag, non-inline replaces the {content} tag.';
$lang['title_field_default_value'] = 'Default value for field';
$lang['title_clear_default'] = 'Clear default on click?';
$lang['title_clear_default_help'] = 'Check this to clear the default value when the user clicks this field. Since this uses a javascript string compare, it will fail if you put single quotes in your default text. Other un-javascript-friendly characters may also cause it to fail.';
$lang['default_template'] = 'Default Template';
$lang['table_left_template'] = 'Table Template, Titles on left';
$lang['table_top_template'] = 'Table Template, Title on top';
$lang['form_template_name'] = 'Template from %s';
$lang['template_are_you_sure'] = 'Are you sure you want to overwrite your template with the selected template? (Even if you say OK, you will still need to save the change)';
$lang['title_bad_function'] = 'Error when computing &quot;%s&quot;.';
$lang['no_referrer_info'] = 'No HTTP_REFERER info available (probably due to use of User Email Validation)';
$lang['validation_param_error'] = 'Validation Parameter Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_response_error'] = 'Validation Repsonse Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_no_field_error'] = 'Validation Repsonse Error. No email validation field in this form!';
$lang['upgrade03to04'] = 'Form Template was updated automatically as part of the version 0.3 to version 0.4 upgrade. You may need to make some fixes. If you&#039;re using the default form, simply replace this template with &quot;default&quot; using the pulldown above.';
$lang['admindesc'] = 'Add, edit and manage interactive Forms';
$lang['operators_help'] = 'If you use String evaluation, the only operation available is concatenation (+), while if you use Number evaluation you have basic, very simple math (, +, -, *, /, ).';
$lang['date_january'] = 'January';
$lang['date_february'] = 'February';
$lang['date_march'] = 'March';
$lang['date_april'] = 'April';
$lang['date_may'] = 'May';
$lang['date_june'] = 'June';
$lang['date_july'] = 'July';
$lang['date_august'] = 'August';
$lang['date_september'] = 'September';
$lang['date_october'] = 'October';
$lang['date_november'] = 'November';
$lang['date_december'] = 'December';
$lang['submission_error'] = 'Desculpe! Houve um erro de manipula&ccedil;&atilde;o no seu formul&aacute;rio.';
$lang['submit_error'] = 'FormBuilder submit error: %s';
$lang['uploads_error'] = 'Error committing file to the uploads module: %s';
$lang['nouploads_error'] = 'Could not find the uploads module';
$lang['upload_attach_error'] = 'Upload/Attachment error on file %s (tmp_name: %s, of type %s)';
$lang['submission_error_file_lock'] = 'Error. Unable to obtain lock for file.';
$lang['unchecked_by_default'] = 'Default: unchecked';
$lang['checked_by_default'] = 'Default: checked';
$lang['email_default_template'] = 'FormBuilder Submission';
$lang['email_template_not_set'] = '<br/>Email Template not yet set!';
$lang['missing_cms_mailer'] = 'FormBuilder: Cannot find required module CMSMailer!';
$lang['user_approved_submission'] = 'User approved submission %s from %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Event triggered when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Event triggered if there is an error when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Event triggered when a FormBuilder form is displayed';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Event triggered when a FormBuilder form is submitted.</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>value_<name></em> - Supply a default value to a field with the specified name.</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Event triggered if there is an error when a FormBuilder form is submitted</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>error</em> - A list of all known errors (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Event triggered when a FormBuilder form is displayed</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
</ul> ';
$lang['formbuilder_params_response_id'] = 'Response ID. Used by FormBrowser';
$lang['formbuilder_params_passed_from_tag'] = 'Default field values; see module help';
$lang['formbuilder_params_field_id'] = 'Field ID for internal operations';
$lang['formbuilder_params_form_name'] = 'Form Name';
$lang['formbuilder_params_form_id'] = 'Form ID for internal operations';
$lang['formbuilder_params_general'] = 'General parameters for internal operations';
$lang['template_variable_help'] = '<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>
';
$lang['post_install'] = '<p>Make sure to set the &quot;Modify Forms&quot; permissions
on users who will be administering feedback forms. Also, if you&#039;ll be emailing form
results, be sure to update the Configuration appropriately.</p>
<p>Please be aware that a feedback form should not be active (e.g., usable by the public) while
you are still editing the form. You should create the form, and place the tag into an active
content page only when you have finished editing. Otherwise, erroneous results could be returned.</p>
<p>Additionally, this version does not support parallel editing of forms. Please take care that
only one admin is editing a given form at a given time.</p>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create feedback forms (in fact, it&#039;s a replacement of the original Feedback Form module), with the added power of database storage. With its companion module Form Browser, you can use it to create simple database applications.</p>
<p>The forms created using the Form Builder may be inserted
into templates and/or content pages. Forms may contain many kinds of inputs, and may have
validation applied to these inputs. The results of these forms may be handled in a variety of ways.</p>

<h3>How Do I Use it?</h3>
<P>Install it, and poke around the menus. Play with it. Try creating forms, and adding them to your content.
If you get stuck, chat with me on the #cms IRC channel, post to the forum, send me email, or, if you&#039;re
really desperate, try reading the instructions on the rest of this page.</P>

<h3>How Do I Create a Form</h3>
<p>In the CMS Admin Menu, you should get a new menu item called FormBuilder. Click on this. On the page
that gets shown, there are options (at the bottom of the list of Forms) to Add a New Form or Modify
Configuration.</p>

<h3>Adding a Form to a Page</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module=&#039;FormBuilder&#039; form=&#039;sample_form&#039;}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page&#039;s content if you use a WYSIWYG editor such as TinyMCE, FCKEdit, or HTMLArea. These editors may stealthily
change the quote marks (&quot;) into HTML entities (&amp;amp;quot;), and the forms will not show up. Try using
single quotes (&#039;) or editing the HTML directly.</p>

<h3>Working with Forms</h3>
<p>By clicking on a Form&#039;s name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you&#039;ll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing.</p>
<p>Below this, if you have it enabled, is the &quot;fast field adder&quot; pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Form Submission</h4>
<p>When the form is submitted, you can either redirect the user to another page of your site, or you can present the user some message (which can contain any of the user&#039;s form entries, or just static text). In this tab, you select which of these approaches you wish to use, and, if you chose redirection, it allows you to pick the page to redirect users to after a successful form submission.</p>
<p>Also on this page, you can specify the labels of various submission buttons (&quot;Previous&quot;, &quot;next&quot;, &quot;submit&quot;). You can also opt to have some Javascript added to the last page of a form that will prevent multiple submissions (useful on slow servers).</p>
<h4>Form Display Options</h4>
<p>This tab allows for other form customizations, like the symbol to show for required fields.</p>
<h4>Captcha Settings</h4>
<p>If you have installed the Captcha module, this tab lets you configure the Captcha settings for your form.</p>
<h4>Form Template</h4>
<p>This is where you do your customization work of your form&#039;s Smarty Template. See the section called Form Template Variables below.</p>
<p>The form should default to a Custom template that documents the Smarty tags available to you.</p>
<p>Unless you&#039;re a Smarty expert, you probably don&#039;t want to mess around with this. If you are a Smarty expert, this is where you can unleash your magic.</p>
<h4>Submission Template</h4>
<p>If, in the Form Submission tab, you selected &#039;Display &quot;Submission Template&quot;, this is where you can create that template. There is a display of which smarty variables are available to you, and a button to generate a sample template.</p>
<p>If you&#039;re a Smarty expert, you can do all manner of creative and powerful things here. If you&#039;re not a Smarty expert, you might just want to use the default.
</p>

<h3>Adding Fields to your Form</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it&#039;s submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it&#039;s safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked &quot;Required&quot;, which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to &quot;view source&quot; on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It&#039;s really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It&#039;s really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Canadian Province. This is a pulldown listing the Canadian Provinces (Contributed by Noel McGran. Thanks!)</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
<li>Time Picker. This is a set of pulldowns allowing the user to select a time (using 12 or 24 hour clock).</li>
<li>File Upload. This is a file upload field.</li>
<li>Link (User Entered). This creates a double input field for getting a link URL and link title.</li>
<li>Text Field (Multiple). This field creates one or more text inputs with add and delete buttons, effectively giving the end user a way of creating variable-length lists.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the &quot;From&quot; field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the &quot;From&quot; field.</li>
<li>Email Subject Field. This allows users to provide a subject for their email. The email generated when the form gets handled will use this in the &quot;Subject&quot; field. This may cause trouble with certain dispositions that want to control the Email Subject, so use it with caution.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Fieldset Start. Combined with Fieldset End, this allows you to group various fields within your form. Use this to start a given grouping.</li>
<li>-Fieldset End. Combined with Fieldset Start, this allows you to group various fields within your form. Use this to end a given grouping.</li>
<li>-Hidden Field. This allows you to embed a hidden field in your form.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you&#039;re not using a Custom Template to render your form.</li>
<li>-Static Link. This allows you to put a link to a given page into your form. Optionally, you can have it autopopulate with the page where the form is embedded (useful if you&#039;re sending results via email).</li>
<li>-Computed Field. This allows you to embed a computed field in your form. It is not visible to the user until after the form is submitted. It allows you to do simple arithmetic or string concatenation.</li>
<li>-Unique Integer (Serial). This is an integer that increases every time someone hits your form. Your results may not be sequential, but they will increase monotonically.</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<ul><li>*Call a User Defined Tag With the Form Results. This submits all the form results to the User-Defined Tag you specify. The UDT can handle the results however it wants. Values are passed as $param[&#039;field_name&#039;].</li>
<li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these &quot;Director&quot; pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email to User-Supplied Address. This puts an input field in the form for the user to populate with an email address. The form results get sent to that address. Beware of Spam abuse! Active the primitive anti-spam features in the FormBuilder configuration screen.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Redirect to Page Based on Pulldown. This allows you to redirect the form to a different site page depending on its value. If you have multiple dispositions, make sure this is used last.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered &quot;approved,&quot; and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the &quot;output&quot; directory under the
module&#039;s installation directory, assuming the web server has permission to write there.</li>
<li>*Save Results to File Based on Pulldown. Like the Flat File disposition, except the value of a pull-down determines which file results get written to.</li>
<li>*Save Results to File(s) Based on Multiple Selections. Like the Flat File disposition, except the value(s) of checkboxes  determines which file(s) results get written to.</li>
<li>*Email to CMS Admin User. Provides a pull-down of CMS Admin users, and directs the results as an email to the selected admin.</li>
<li>*Store Results for FormBrowser Module v.3. Stores the form results in an XML structure as a single database record. This will become the interface to Form Browser in the next release.</li>

</ul></li></li></ul>


<h3>Passing Default Values to Forms</h3>
<p>Calguy added a nice feature, which is that you can pass default field values to your form via the module tag. This allows you to have
the same form in multiple places, but with different default values. It may not work for more exotic field types, but for fields that have
a single value, you can specify like:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_<i>FIELDNAME</i>=&#039;default_value&#039;}</p>
<p>This will set the field with <i>FIELDNAME</i> to &#039;default_value&#039;.</p>
<p>This can be problematic, as sometimes field names are unweildy or contain characters that don&#039;t work well with Smarty. So there is an
alternative like this:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_fld<i>NUMBER</i>=&#039;default_value&#039;}</p>
<p>That uses field <i>NUMBER</i>, where <i>NUMBER</i> is the internal FormBuilder field id. You might wonder how you know what that id is. Simply go into the FormBuilder configuration tab,
and check &quot;Show Field IDs&quot;</p>

<h3>Email and Flat File Templates</h3>
<p>Many disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it&#039;s own best guess, which may or may not work out to your liking. You can always click on the &quot;Create Sample Template&quot; and then customize the results.</p>
<p>To the right, you&#039;ll find a legend which lists all of the variables that are available to you to use in your template. As of version 0.3, variables have two names, one based on the field name, the other based on the field ID. If you use field names that have characters outside of the ASCII 32-126 range, it will be safer to use the ID-based variables.</p>
<p><strong>Note that once you&#039;ve changed a template, it will no longer automatically add new fields.</strong> For this reason, it&#039;s usually best to create your templates as the last step of creating your form.</p>
<p>As of version 0.2.4, you can opt to send any of these emails as HTML email. There should be a checkbox at the top of the template page for this. There is also a &quot;Create Sample HTML Template&quot; button over in the legend area. For HTML email, the email body will also provide the default text-only values.</p>

<h3>Configuration</h3>
<p>There are some global configuration options for FormBuilder:</p>
<ul>
<li>Enable fast field add pulldown. This enables the pulldown on the Form Edit page which saves a step in the creation of new fields.</li>
<li>Hide Errors. This is set by default. Unchecking it will cause more detailed errors to be displayed if there are problems when you submit your form.</li>
<li>Require Field Names. Typically, you will want form fields to be named so you can tell which is which. However, in some cases, you might want to have nameless fields. Uncheck this if you want to allow nameless fields.</li>
<li>Unique Field Names. Typically, you will want form fields to have unique names so you can tell which is which. Uncheck this if you want to allow fields to share names.</li>
<li>Use relaxed email validation. This uses a less restrictive regular expression for validating email; e.g., x@y will be allowed, where typically x@y.tld is required.</li>
<li>Show Form Builder Version. Displays the version of FormBuilder you&#039;re using in a comment when the form is generated. Typically only useful when debugging.</li>
<li>Enable primitive anti-spam features. When turned on, this allows any given IP address to only generate 10 emails per hour.</li>
<li>Show Field IDs. When turned on, FormBuilder will display field ids when adding or editing a form.</li>
</ul>
<h3>Styling and CSS</h3>
<p>Paul Noone graciously provides us all with a pretty good standard CSS that you can use for forms:</p>
<pre>
	/* Sample FormBuilder CSS base */
	form {margin-top:0}
	form, td, th, li { font-size: 100%}
	form div {margin-bottom:0}
	fieldset div {
		margin-bottom:0.5em;
		margin-left:1em;
	}
	fieldset div div {
		margin-top:0.5em;
		margin-left:1em
	}
	fieldset {
		margin-bottom:1em;
		border:1px solid #F60;
		padding:0.5em
	}
	fieldset label {
		width:auto;
	}
	legend {
		color:#FFF;
		background:#F60;
		font-style:italic;
		font-size:1.2em;
		margin-bottom:0.5em;
		padding:0.2em;
		width:auto;
		border:1px solid #CCC
	}
	textarea {
		margin: 0.5em 0;
		width:98%;
		height: 6em
	}

	/* Apply this class to text/select input fields with shorter labels
		to help alignment */
	.short-label label {float:left; width:10em}
	.short-label fieldset div input,
	.short-label fieldset div select {width:16em}

	/* Pretty up your Captcha image output */
	.captcha {
		margin:0.5em 0;
		width:200px;
		text-align:center
	}
	.captcha img {border:1px solid #F60; margin-bottom:0.5em}
	.captcha input {width:196px; margin-top:0.5em}

	/* Just a bit more room for the Submit button */
	.submit {margin-top:0.5em}
</pre>

<h3>Form Template Variables</h3>

<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the &amp;#123;$fb_hidden} and &amp;#123;$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., &amp;#123;$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>


<h3>Known Issues</h3>
<ul>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn&#039;t matter since the user side is pretty simple.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you&#039;re running CMS 1.1 or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you&#039;re missing fields in an email that gets generated, check the disposition field&#039;s template, and make sure you&#039;re specifying the missing fields. Seems obvious, but it&#039;s an easy mistake to make.</li>
<li>Uncheck the &quot;Hide Errors&quot; checkbox in the global options, and see what message gets displayed when you submit your form.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is no longer a particularly early version, but it is probably still buggy. While I&#039;ve done all I can
to make sure no egregious bugs have crept in, I have to admit that during early testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor&#039;s nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href=&quot;http://dev.cmsmadesimple.org&quot;>Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href=&quot;mailto:sjg@cmsmodules.com&quot;>&amp;lt;sjg@cmsmodules.com&amp;gt;</a>.</li>
<li>Additional discussion of this module may also be found in the <a href=&quot;http://forum.cmsmadesimple.org&quot;>CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href=&quot;irc://irc.freenode.net/#cms&quot;>CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
</ul>
<p>Keep in mind that the author has put hundreds of hours into the development of this module. Please take the time to read the documentation before sending questions. Either that, or write your questions on financially negotiable instruments (i.e., cash).</p>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &amp;copy; 2008, Samuel Goldstein <a href=&quot;mailto:sjg@cmsmodules.com&quot;>&amp;lt;sjg@cmsmodules.com&amp;gt;</a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href=&quot;http://www.gnu.org/licenses/licenses.html#GPL&quot;>GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '
<ul>
<li>Version 0.5. 19 April 08. Bugfixes, support for FormBrowser fixes and features, disposition type for upcoming FormBrowser version.</li>
<li>Version 0.4.4. 26 Sept 07. Bugfixes for radio button groups, fix for validation of DispositionDeliverToEmailAddressField.</li>
<li>Version 0.4.3. 18 Sept 07. Bugfixes for pulldowns using numbers, option to inline form, fixes for table-layouts provided by Ap Muthu, fix for requirability of Dispositions.</li>
<li>Version 0.4.2. 14 Sept 07. Bugfixes for XML export, RadioButton Group submission, and HTML labels.</li>
<li>Version 0.4.1. Bugfixes for File Disposition Types.</li>
<li>Version 0.4
	<ul>
		<li>Upped minimum CMS version to 1.1</li>
		<li>Numerous Bug fixes; too many to enumerate here</li>
		<li>Massive rejiggering of code to work with CMS MS 1.1 parameter sanitizing regime</li>
		<li>Added field types: &quot;TextField (Multiple)&quot; and &quot;Computed Field&quot;</li>
		<li>Added dispositions: &quot;Save Results to File Based on Pulldown&quot; and &quot;Save Results to File(s) Based on Multiple Selections&quot;(Calguy)</li>
		<li>Added neat-o AJAX-y template-copying for Form Templates, gave versions of old table-based templates to soothe the raging masses.</li>
		<li>Added ability to pass default values to form elements from module tag using value_FIELDNAME=&quot;value&quot; syntax (Calguy)</li>
		<li>Added option to display field ids in admin (Calguy)</li>
	</ul>
</li>
<li>Version 0.3
   <ul>
      <li>Added Captcha module support.</li>
      <li>Reworked labeling of form elements to be XHTML compliant</li>
      <li>Added Paul Noone&#039;s new, improved contact form templates</li>
      <li>Implementation of Email Subject Field</li>
      <li>Added admin-specifiable values to hidden field type, which may contain parsable smarty tags</li>
      <li>Text Area Field now allows specification of rows and cols in the admin, instead of CSS</li>
      <li>Added Drag&#039;n&#039;Drop reordering of form fields.</li>
      <li>Added non-blank field name and unique field name global configuration options and validation</li>
      <li>Implemented templated display of form results upon submission in addition to page redirecting</li>
      <li></li>
   </ul>
</li>
<li>Version 0.2.4 - 09 May 2007
   <p>Big release:<ul>
   <li>Added &quot;Email Form to User-Supplied Address&quot; disposition.</li>
   <li>Added &quot;TimePicker&quot; field type. Split &quot;Link&quot; field into a &quot;User-supplied Link&quot; field and a &quot;Static Link&quot; field.</li>
   <li>Added HTML email option and auto-templates for all email dispositions.</li>
   <li>Added primitive anti-spam features.</li>
   <li>Added XML-based import and export of forms.</li>
   </ul>
   </p>
</li>
<li>Version 0.2.3
   <p>Add the ability to call a selectable user defined tag upon disposition of the form.</p>
</li>
<li>Version 0.2.2
   <p>Many thanks to Utter Design for sponsoring some changes and bugfixes, which include:
   <ul>
      <li>Added file upload capabilities to the email disposition</li>
      <li>Add PageSetStart and PageSetEnd field types
      <p>These field types allow you to create fieldsets in your form, and organise
      your fields logically for the user.  You can even nest fieldsets, and
      associate a style with them appropriately.  The default template was changed
      to prevent it from wrapping a div around these types of fields.
      </p>
      </li>
      <li>Fixed a problem with DATETIME fields on install
      <p>This solves a problem when on install the response table would sometimes not get created when using adodb lite</li>
      </li>
   </ul>
   </p>
</li>
<li>Version 0.2 - 14 November 2006. Calguy &amp;amp; tsw&#039;s bug fixes for field re-ordering and custom templates. Additional bug fixes for field labels.</li>
<li>Version 0.1 - 8 July 2006. Initial Release</li>
</ul>';
$lang['utma'] = '156861353.719775824.1208952011.1209235418.1209466507.10';
$lang['utmz'] = '156861353.1209213046.7.3.utmcsr=cmsmadesimple.org|utmccn=(referral)|utmcmd=referral|utmcct=/';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/ru_RU.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Конструктор форм';
$lang['field_type_'] = 'Не указан тип поля';
$lang['field_type_FieldsetEnd'] = 'Конец группы полей';
$lang['field_type_FieldsetStart'] = 'Начало группы полей';
$lang['field_type_TextField'] = 'Текстовое поле';
$lang['field_type_TextFieldExpandable'] = 'Text Input (Multiple)';
$lang['field_type_TextAreaField'] = 'Текстовое окно';
$lang['field_type_CheckboxField'] = 'Контрольный индикатор';
$lang['field_type_CheckboxGroupField'] = 'Группа контрольных индикаторов';
$lang['field_type_PulldownField'] = 'Выпадающий список';
$lang['field_type_MultiselectField'] = 'Multiselect';
$lang['field_type_StatePickerField'] = 'Выбор штатов США';
$lang['field_type_CountryPickerField'] = 'Country Picker';
$lang['field_type_DatePickerField'] = 'Date Picker';
$lang['field_type_TimePickerField'] = 'Time Picker';
$lang['field_type_RadioGroupField'] = 'Radio Button Group';
$lang['field_type_DispositionDirector'] = '*Email Results Based on Pulldown';
$lang['field_type_DispositionFileDirector'] = '*Save Results to File Based on Pulldown';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Save Results to File(s) Based on Multiple Selections';
$lang['field_type_DispositionPageRedirector'] = '*Redirect to Page Based on Pulldown';
$lang['field_type_DispositionEmail'] = '*Email Results to set Address(es)';
$lang['field_type_DispositionEmailConfirmation'] = '*Validate-via-Email Address';
$lang['field_type_DispositionFile'] = '*Write Results to Flat File';
$lang['field_type_DispositionDatabase'] = '*Store Results in Database';
$lang['field_type_DispositionUserTag'] = '*Call A User Defined Tag With the Form Results';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Email to User-Supplied Email Address';
$lang['field_type_PageBreakField'] = '-Page Break';
$lang['field_type_FileUploadField'] = 'File Upload';
$lang['field_type_FromEmailAddressField'] = 'Email "From Address" Field';
$lang['field_type_FromEmailNameField'] = 'Email "From Name" Field';
$lang['field_type_FromEmailSubjectField'] = 'Email "Subject" Field';
$lang['field_type_StaticTextField'] = '-Static Text';
$lang['field_type_SystemLinkField'] = '-Static Link';
$lang['field_type_LinkField'] = '-Link';
$lang['field_type_HiddenField'] = 'Hidden Field';
$lang['field_type_ComputedField'] = '-Computed Field';
$lang['validation_none'] = 'No Validation';
$lang['validation_numeric'] = 'Numeric';
$lang['validation_integer'] = 'Integer';
$lang['validation_email_address'] = 'Email Address';
$lang['validation_usphone'] = 'Phone Number (US)';
$lang['validation_must_check'] = 'Must Be Checked';
$lang['validation_regex_match'] = 'Match Regular Expression';
$lang['validation_regex_nomatch'] = 'Doesn\'t match Regular Expression';
$lang['required_field_missing'] = 'A value was not supplied for a required field';
$lang['please_enter_a_value'] = 'Пожалуйста заполните "%s"';
$lang['please_enter_a_number'] = 'Пожалуйста заполните "%s"';
$lang['please_enter_valid'] = 'Please enter a valid entry for "%s"';
$lang['please_enter_an_integer'] = 'Please enter an integer value for "%s"';
$lang['please_enter_an_email'] = 'Введите корректный email адрес в поле "%s"';
$lang['please_enter_a_phone'] = 'Please enter a valid phone number for "%s"';
$lang['not_valid_email'] = '"%s" does not appear to be a valid email address!';
$lang['please_enter_no_longer'] = 'Please enter a value that is no longer than %s characters';
$lang['title_list_delimiter'] = 'Character to use as delimiter in results that return more than one value';
$lang['you_need_permission'] = 'You need the "%s" permission to perform that operation.';
$lang['lackpermission'] = 'Sorry! You don\'t have adequate privileges to access this section.';
$lang['field_order_updated'] = 'Field order updated.';
$lang['form_deleted'] = 'Form deleted.';
$lang['field_deleted'] = 'Field deleted.';
$lang['configuration_updated'] = 'Configuration Updated.';
$lang['you_must_check'] = 'You must check "%s" in order to continue.';
$lang['must_specify_one_destination'] = 'You need to specify at least one destination address!';
$lang['are_you_sure_delete_form'] = 'Are you sure you want to delete the form %s?';
$lang['are_you_sure_delete_field'] = 'Are you sure you want to delete the field %s?';
$lang['notice_select_type'] = 'Advanced options are not available until the field type has been set.';
$lang['field_name_in_use'] = 'The field name "%s" is already in use. Please use unique field names.';
$lang['field_no_name'] = 'Fields must be named, unless you disable this in the Form Builder configuration.';
$lang['anonymous'] = 'Anonymous';
$lang['abbreviation_length'] = 'Len: %s';
$lang['boxes'] = '%s boxes';
$lang['options'] = '%s options';
$lang['text_length'] = '%s chars.';
$lang['order'] = 'Order';
$lang['unspecified'] = '[unspecified]';
$lang['added'] = 'added';
$lang['updated'] = 'updated';
$lang['sort_options'] = 'Sort options on output';
$lang['select_one'] = 'Select One';
$lang['select_type'] = 'Select Type';
$lang['to'] = 'To';
$lang['yes'] = 'Yes';
$lang['no'] = 'No';
$lang['recipients'] = 'recipients';
$lang['file_count'] = '%s possible files';
$lang['destination_count'] = '%s destinations';
$lang['save'] = 'Save';
$lang['add'] = 'Add';
$lang['update'] = 'Update';
$lang['save_and_continue'] = 'Save and Continue Editing';
$lang['information'] = 'Information';
$lang['automatic'] = 'Automatic';
$lang['forms'] = 'Forms';
$lang['form'] = 'Form %s';
$lang['configuration'] = 'Configuration';
$lang['field_requirement_updated'] = 'Field required state updated.';
$lang['maximum_size'] = 'Max. Size';
$lang['permitted_extensions'] = 'Extensions';
$lang['permitted_filetypes'] = 'Allowed file types';
$lang['file_too_large'] = 'Uploaded file is too large! Maximum size is:';
$lang['illegal_file_type'] = 'This type of file may not be uploaded. Please check that the extension is correct.';
$lang['upload'] = 'Upload';
$lang['form_imported'] = 'Form Imported.';
$lang['form_import_failed'] = 'Form import failed! There was a problem with the format of the XML file.';
$lang['rows'] = '%s rows';
$lang['cols'] = '%s cols';
$lang['12_hour'] = '12 Hour Clock';
$lang['24_hour'] = '24 Hour Clock';
$lang['hour'] = 'Hour';
$lang['min'] = 'Minute';
$lang['merid'] = 'Meridian';
$lang['date_range'] = 'Range: %s - %s';
$lang['thanks'] = 'Thanks! Your submissions have been received.';
$lang['edit'] = 'Edit';
$lang['delete'] = 'Delete';
$lang['day'] = 'Day';
$lang['mon'] = 'Month';
$lang['year'] = 'Year';
$lang['uninstalled'] = 'Module uninstalled.';
$lang['installed'] = 'Module version %s installed.';
$lang['upgraded'] = 'Module upgraded to version %s.';
$lang['button_previous'] = 'Back...';
$lang['button_submit'] = 'Отправить';
$lang['button_continue'] = 'Continue...';
$lang['value_checked'] = 'Checked';
$lang['value_unchecked'] = 'Unchecked';
$lang['tab_main'] = 'Main';
$lang['tab_symbol'] = 'Form Display Settings';
$lang['tab_submit'] = 'Form Submission';
$lang['tab_captcha'] = 'Captcha Settings';
$lang['tab_advanced'] = 'Advanced Settings';
$lang['tab_templatelayout'] = 'Template Layout Options';
$lang['tab_submissiontemplate'] = 'Submission Template';
$lang['canuse_smarty'] = '<em>Smarty variables are valid in this field.</em>';
$lang['add_options'] = 'Add More Options';
$lang['delete_options'] = 'Delete Marked Options';
$lang['add_checkboxes'] = 'Add More Checkboxes';
$lang['delete_checkboxes'] = 'Delete Marked Checkboxes';
$lang['add_address'] = 'Add Another Address';
$lang['delete_address'] = 'Delete Marked Addresses';
$lang['add_destination'] = 'Add Another Destination';
$lang['delete_destination'] = 'Delete Marked Destinations';
$lang['suspected_spam'] = 'Too many emails generated from your IP address. Anti-Spam code has prevented delivery.';
$lang['suspected_spam_log'] = 'Suspected spam from IP %s stopped.';
$lang['reorder'] = 'Reorder Fields';
$lang['cancel'] = 'Cancel';
$lang['title_file_path'] = 'Destination Directory for output files';
$lang['title_udt_name'] = 'User Defined Tag';
$lang['title_uploads_destpage'] = 'Page to return to with uploads link';
$lang['title_uploadmodule_summary'] = 'Submitted with formbuilder';
$lang['title_uploads_category'] = 'Uploads category';
$lang['title_sendto_uploads'] = 'Send this file to the uploads module';
$lang['title_legend'] = 'Legend';
$lang['title_maximum_length'] = 'Maximum Length';
$lang['title_checkbox_label'] = 'Checkbox label';
$lang['title_radio_label'] = 'Radio Button label';
$lang['title_checked_value'] = 'Value when checked';
$lang['title_unchecked_value'] = 'Value when not checked.';
$lang['title_checkbox_details'] = 'Checkbox Group Details';
$lang['title_delete'] = 'Delete?';
$lang['title_select_one_message'] = '"Select One" Text';
$lang['title_selection_displayname'] = 'Selection Display Name';
$lang['title_selection_subject'] = 'Selection Subject';
$lang['title_select_default_country'] = 'Default Selection';
$lang['title_select_default_state'] = 'Default Selection';
$lang['title_option_name'] = 'Option Name';
$lang['title_option_value'] = 'Value Submitted';
$lang['title_pulldown_details'] = 'Pulldown Options';
$lang['title_multiselect_details'] = 'Multiselect Options';
$lang['title_destination_address'] = 'Destination Email Address';
$lang['title_destination_filename'] = 'Destination File Name';
$lang['title_email_from_name'] = '"From name" for email';
$lang['title_relaxed_email_regex'] = 'Use relaxed email validation';
$lang['title_relaxed_regex_long'] = 'Use relaxed email address validation (e.g., allow "x@y" instead of requiring "x@y.tld")';
$lang['title_email_from_address'] = '"From address" for email';
$lang['title_email_encoding'] = 'Email character set encoding';
$lang['title_director_details'] = 'Pulldown-based Emailer Details';
$lang['title_file_name'] = 'File Name';
$lang['title_email_subject'] = 'Email Subject Line';
$lang['title_form_name'] = 'Form Name';
$lang['title_form_status'] = 'Form Status';
$lang['title_ready_for_deployment'] = 'Ready for Deployment';
$lang['title_not_ready1'] = 'Not Ready';
$lang['title_redirect_page'] = 'Page to redirect to after form submission';
$lang['title_not_ready2'] = 'Please add a field to the form so that the user\'s input gets handled. You can';
$lang['title_not_ready_link'] = 'use this shortcut';
$lang['title_form_alias'] = 'Form Alias';
$lang['title_form_fields'] = 'Form Fields';
$lang['title_field_id'] = 'Field Id';
$lang['title_field_name'] = 'Field Name';
$lang['title_radiogroup_details'] = 'Radio Button Group Details';
$lang['title_field_type'] = 'Field Type';
$lang['title_not_ready3'] = 'to create a form handling field.';
$lang['title_add_new_form'] = 'Add New Form';
$lang['title_show_version'] = 'Show Form Builder Version?';
$lang['title_show_version_long'] = 'This will embed your installed version number of Form Builder module in a comment, to aid in debugging';
$lang['title_add_new_field'] = 'Add New Field';
$lang['title_form_submit_button'] = 'Form Submit Button Text';
$lang['title_submit_button_safety'] = 'Add Javascript to Submit Button to prevent multiple submissions?';
$lang['title_submit_button_safety_help'] = 'Add safety script';
$lang['title_form_next_button'] = 'Form "Next" Button Text (used for multipage forms)';
$lang['title_form_prev_button'] = 'Form "Previous" Button Text (used for multipage forms)';
$lang['title_field_validation'] = 'Field Validation';
$lang['title_form_css_class'] = 'CSS Class for this form';
$lang['title_field_css_class'] = 'CSS Class for this field';
$lang['title_form_required_symbol'] = 'Symbol to mark required Fields';
$lang['title_field_required'] = 'Required';
$lang['title_field_required_long'] = 'Require a response for this Field';
$lang['title_hide_label'] = 'Hide Label';
$lang['title_hide_label_long'] = 'Hide this field\'s name on Form';
$lang['title_text'] = 'Static text to display';
$lang['title_field_regex'] = 'Validation Regex';
$lang['title_lines_to_show'] = 'Number of Lines to display';
$lang['no_default'] = 'No Default';
$lang['redirect_after_approval'] = 'Page to redirect after approval';
$lang['title_regex_help'] = 'This regular expression will only be used if "validation type" is set to a regex-related option. Include a full Perl-style regex, including the start/stop slashes and flags (e.g., "/image\\.(\\d+)/i")';
$lang['title_field_required_abbrev'] = 'Req\'d';
$lang['title_hide_errors'] = 'Hide Errors';
$lang['title_form_displaytype'] = 'Form Display Type';
$lang['title_hide_errors_long'] = 'Prevent debug / error messages from being seen by users.';
$lang['title_email_template'] = 'Email Template';
$lang['title_maximum_size'] = 'Maximum upload file size (kilobytes)';
$lang['title_maximum_size_long'] = 'This limitation is in addition to any limits set by the php or web server configuration';
$lang['title_permitted_extensions'] = 'Permitted Extensions';
$lang['title_permitted_extensions_long'] = 'Enter a comma-separated list, excluding the dot (e.g., "jpg,gif,jpeg"). Spaces will be ignored. Leaving this blank means there will be no restrictions.';
$lang['title_show_limitations'] = 'Display restrictions?';
$lang['title_show_limitations_long'] = 'Display any size and extension restrictions with the upload field?';
$lang['title_form_template'] = 'Template to use to Display Form';
$lang['title_page_x_of_y'] = 'Page %s of %s';
$lang['title_no_advanced_options'] = 'Field has no advanced options.';
$lang['title_form_unspecified'] = 'Text to return for unspecified field values';
$lang['title_enable_fastadd_long'] = 'Enable fast field adding pulldown for forms?';
$lang['title_enable_fastadd'] = 'Enable fast field add pulldown?';
$lang['title_fastadd'] = 'Fast field adder';
$lang['title_enable_antispam_long'] = 'Clicking this will only allow 10 emails to be triggered from a given IP address (per hour).';
$lang['title_enable_antispam'] = 'Enable primitive anti-spam features?';
$lang['title_show_fieldids'] = 'Show Field IDs';
$lang['title_show_fieldids_long'] = 'Clicking this will allow displaying field ids when adding or editing a form';
$lang['title_xml_to_upload'] = 'Upload form from XML file';
$lang['title_xml_upload_formname'] = 'Use this form name';
$lang['title_import_legend'] = 'XML Form Import';
$lang['title_xml_upload_formalias'] = 'Use this form alias';
$lang['title_html_email'] = 'Generate HTML email?';
$lang['title_link_autopopulate'] = 'Automatically populate?';
$lang['title_link_autopopulate_help'] = 'Automatically populate with the URL of the page containing the form? (this overrides site page link option below)';
$lang['title_default_link'] = 'Default link URL';
$lang['title_default_link_title'] = 'Default link text';
$lang['title_link_to_sitepage'] = 'Link to site page';
$lang['title_captcha_not_installed'] = 'You can use <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">"Captcha"</a> to protect form submissions if you install the Captcha module. For more information, <a href="http://dev.cmsmadesimple.org/projects/captcha/">check the Captcha project</a>.';
$lang['title_use_captcha'] = 'Use Captcha to protect form submissions?';
$lang['title_use_captcha_help'] = 'Check here to protect your form with a <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">"Captcha"</a>.';
$lang['title_user_captcha'] = 'Please confirm that you are not a script by entering the letters from the image.';
$lang['title_user_captcha_error'] = 'Failed text for Captcha';
$lang['wrong_captcha'] = 'Captcha was not correct.';
$lang['title_title_user_captcha'] = 'Help text for Captcha';
$lang['link_label'] = 'Link Label';
$lang['link_destination'] = 'Link Destination URL';
$lang['title_default_set'] = 'Checked by Default?';
$lang['title_24_hour'] = 'Use 24-hour clock?';
$lang['title_before_noon'] = 'AM';
$lang['title_after_noon'] = 'PM';
$lang['title_smarty_eval'] = 'Process smarty tags within field?';
$lang['title_textarea_rows'] = 'Rows (note: this may be overridden by CSS)';
$lang['title_textarea_cols'] = 'Columns (note: this may be overridden by CSS)';
$lang['title_form_main'] = 'Main Form Details';
$lang['help_leaveempty'] = 'This field may be left empty';
$lang['help_variables_for_template'] = 'Variables For Template';
$lang['help_variables_for_computation'] = 'Variables Available';
$lang['help_php_variable_name'] = 'PHP variable';
$lang['help_submission_date'] = 'Date of Submission';
$lang['help_server_name'] = 'Your server';
$lang['help_sub_source_ip'] = 'IP address of person using form';
$lang['help_sub_url'] = 'URL of page containing form';
$lang['help_other_fields'] = 'Other fields will be available as you add them to the form.';
$lang['help_array_fields'] = 'Fields that have multiple values may also be accessed via the smarty value of $fieldname_array or $fld_#_array.';
$lang['help_date_format'] = 'See <a href="http://www.php.net/manual/en/function.date.php" target=_NEW>the PHP Manual</a> for formatting help.';
$lang['help_variable_name'] = 'Variable';
$lang['help_form_field'] = 'Field Represented';
$lang['link_back_to_form'] = '« Back to Form';
$lang['title_create_sample_template'] = 'Create Sample Template';
$lang['title_create_sample_html_template'] = 'Create Sample HTML Template';
$lang['title_create_sample_header'] = 'Create Sample Header';
$lang['help_tab_symbol'] = 'a tab character';
$lang['title_file_template'] = 'Template for one line of output file';
$lang['title_file_header'] = 'Template for the header of output file';
$lang['title_confirmation_url'] = 'URL to click for form confirmation';
$lang['title_value'] = 'Value (see Advanced Tab if you use Smarty tags)';
$lang['title_date_format'] = 'Date Format (standard <a href="http://www.php.net/manual/en/function.date.php">PHP Date Formats</a>)';
$lang['title_use_wysiwyg'] = 'Use WYSIWYG editor for text Area?';
$lang['title_submit_actions'] = 'Form Submission Behavior';
$lang['title_submit_labels'] = 'Submission Button Labels';
$lang['title_submit_help'] = 'This page lets you customize Form Submission. It doesn\'t determine what the Form Builder does with the submitted data. You can set that up by adding "Disposition" fields to your form.';
$lang['title_start_year'] = 'Year range start';
$lang['title_end_year'] = 'Year range end';
$lang['title_default_year'] = 'Default Year';
$lang['title_default_year_help'] = '(Set to -1 for default year to be the current year)';
$lang['title_submit_action'] = 'After form is submitted';
$lang['title_submit_response'] = 'Response to display';
$lang['display_text'] = 'Display "Submission Template"';
$lang['redirect_to_page'] = 'Redirect to site page';
$lang['title_submit_response_help'] = 'This template is for display to the user after the form is submitted. This template does not effect emails generated or other form dispositions -- you set those templates (where appropriate) in the "advanced" tab for those disposition fields.';
$lang['title_destination_page'] = 'Destination Page';
$lang['title_require_fieldnames'] = 'Require Fieldnames';
$lang['title_require_fieldnames_long'] = 'Require fields to have a name?';
$lang['title_unique_fieldnames'] = 'Require Unique Fieldnames';
$lang['title_unique_fieldnames_long'] = 'Require fields to have unique names?';
$lang['title_reorder_form'] = 'Reorder Fields';
$lang['title_load_template'] = 'Load template';
$lang['title_add_button_text'] = 'Add Button text';
$lang['title_del_button_text'] = 'Delete Button text';
$lang['title_string_or_number_eval'] = 'Interpret variables as being numbers or strings';
$lang['title_order'] = 'Interpretation Order';
$lang['title_order_help'] = 'If more than one Computed Field exists, they will be computed from lowest order number to highest order number';
$lang['title_compute_value'] = 'Value to compute';
$lang['title_string'] = 'String';
$lang['title_numeric'] = 'Numeric';
$lang['title_inline_form'] = 'Display form inline?';
$lang['title_inline_form_help'] = 'Inline means any form followup replaces the {cms_module} tag, non-inline replaces the {content} tag.';
$lang['default_template'] = 'Default Template';
$lang['table_left_template'] = 'Table Template, Titles on left';
$lang['table_top_template'] = 'Table Template, Title on top';
$lang['form_template_name'] = 'Template from %s';
$lang['template_are_you_sure'] = 'Are you sure you want to overwrite your template with the selected template? (Even if you say OK, you will still need to save the change)';
$lang['title_bad_function'] = 'Error when computing "%s".';
$lang['no_referrer_info'] = 'No HTTP_REFERER info available (probably due to use of User Email Validation)';
$lang['validation_param_error'] = 'Validation Parameter Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_response_error'] = 'Validation Repsonse Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_no_field_error'] = 'Validation Repsonse Error. No email validation field in this form!';
$lang['upgrade03to04'] = 'Form Template was updated automatically as part of the version 0.3 to version 0.4 upgrade. You may need to make some fixes. If you\'re using the default form, simply replace this template with "default" using the pulldown above.';
$lang['admindesc'] = 'Add, edit and manage interactive Forms';
$lang['operators_help'] = 'If you use String evaluation, the only operation available is concatenation (+), while if you use Number evaluation you have basic, very simple math (, +, -, *, /, ).';
$lang['date_january'] = 'January';
$lang['date_february'] = 'February';
$lang['date_march'] = 'March';
$lang['date_april'] = 'April';
$lang['date_may'] = 'May';
$lang['date_june'] = 'June';
$lang['date_july'] = 'July';
$lang['date_august'] = 'August';
$lang['date_september'] = 'September';
$lang['date_october'] = 'October';
$lang['date_november'] = 'November';
$lang['date_december'] = 'December';
$lang['submission_error'] = 'Sorry! There was an error handling your form submission.';
$lang['submit_error'] = 'FormBuilder submit error: %s';
$lang['uploads_error'] = 'Error committing file to the uploads module: %s';
$lang['nouploads_error'] = 'Could not find the uploads module';
$lang['upload_attach_error'] = 'Upload/Attachment error on file %s (tmp_name: %s, of type %s)';
$lang['submission_error_file_lock'] = 'Error. Unable to obtain lock for file.';
$lang['email_default_template'] = 'FormBuilder Submission
';
$lang['email_template_not_set'] = '<br/>Email Template not yet set!';
$lang['missing_cms_mailer'] = 'FormBuilder: Cannot find required module CMSMailer!';
$lang['user_approved_submission'] = 'User approved submission %s from %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Event triggered when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Event triggered if there is an error when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Event triggered when a FormBuilder form is displayed';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Event triggered when a FormBuilder form is submitted.</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>value_<name></em> - Supply a default value to a field with the specified name.</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Event triggered if there is an error when a FormBuilder form is submitted</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>error</em> - A list of all known errors (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Event triggered when a FormBuilder form is displayed</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
</ul> ';
$lang['formbuilder_params_response_id'] = 'Response ID. Used by FormBrowser';
$lang['formbuilder_params_passed_from_tag'] = 'Default field values; see module help';
$lang['formbuilder_params_field_id'] = 'Field ID for internal operations';
$lang['formbuilder_params_form_name'] = 'Form Name';
$lang['formbuilder_params_form_id'] = 'Form ID for internal operations';
$lang['formbuilder_params_general'] = 'General parameters for internal operations';
$lang['template_variable_help'] = '<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you\'d like.
   To make the form work, you\'ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that\'s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field\'s name</td></tr>
<tr><td>field->input</td><td>the field\'s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field\'s input (useful for <label for="">)</td></tr>
<tr><td>field->type</td><td>the field\'s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays "page x of y" for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>"Back" button for multipart forms</td></tr>
<tr><td>submit</td><td>"Continue" or "Submit" button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you\'d want some of those, but there you go...</p>
';
$lang['post_install'] = '<p>Make sure to set the "Modify Forms" permissions
on users who will be administering feedback forms. Also, if you\'ll be emailing form
results, be sure to update the Configuration appropriately.</p>
<p>Please be aware that a feedback form should not be active (e.g., usable by the public) while
you are still editing the form. You should create the form, and place the tag into an active
content page only when you have finished editing. Otherwise, erroneous results could be returned.</p>
<p>Additionally, this version does not support parallel editing of forms. Please take care that
only one admin is editing a given form at a given time.</p>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create feedback forms (in fact, it\'s a replacement of the original Feedback Form module), with the added power of database storage. With its companion module Form Browser, you can use it to create simple database applications.</p>
<p>The forms created using the Form Builder may be inserted
into templates and/or content pages. Forms may contain many kinds of inputs, and may have
validation applied to these inputs. The results of these forms may be handled in a variety of ways.</p>

<h3>How Do I Use it?</h3>
<P>Install it, and poke around the menus. Play with it. Try creating forms, and adding them to your content.
If you get stuck, chat with me on the #cms IRC channel, post to the forum, send me email, or, if you\'re
really desperate, read the rest of this page.</P>

<h3>How Do I Create a Form</h3>
<p>In the CMS Admin Menu, you should get a new menu item called FormBuilder. Click on this. On the page
that gets shown, there are options (at the bottom of the list of Forms) to Add a New Form or Modify
Configuration.</p>

<h3>Adding a Form to a Page</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module=\'FormBuilder\' form=\'sample_form\'}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page\'s content if you use a WYSIWYG editor such as TinyMCE or HTMLArea. These editors may stealthily
change the quote marks (") into HTML entities ("), and the forms will not show up. Try using
single quotes (\') or editing the HTML directly.

<h3>Working with Forms</h3>
<p>By clicking on a Form\'s name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you\'ll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing. You also select the display type. Your choices are:</p>
<ul>
<li>Table/CSS. The form is created using HTML tables. If you don\'t know what to choose, this is the easiest option, and will probably do most of what you want. You can still use CSS to style the form if you want.</li>
<li>Pure CSS. The form is created, with all the fields wrapped in <div> tags. You can then style the form as you see fit.</li>
<li>Custom Template. Basically, you get a smarty template, a bunch of variables, and you\'re on your own. You have the power to create whatever you want.</li>
</ul>
<p>Below this, if you have it enabled, is the "fast field adder" pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Form Settings</h4>
<p>Form Settings allows you to customize a lot of the messages and text in the controls for your form. It also allows you to pick a page to redirect users to after a successful form submission.</p>
<h4>Table-based Layout Options</h4>
<p>Table-layouts have gotten simpler, so your only option here is the position of the field names relative to the inputs. If you\'re using a Table/CSS layout, you can use this tab to select the field name positions.</p>
<h4>Template Layout Options</h4>
<p>This is where you do your customization work if your form uses a Custom Template.</p>
<p>The form should default to a a Custom template that documents the smarty tags available to you. Unless you\'re a smarty expert, you probably don\'t want to mess around with this. If you are a smarty expert, this is where you can unleash your magic.</p>
<h3>Adding Fields to your Form</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it\'s submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it\'s safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked "Required", which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to "view source" on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It\'s really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It\'s really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the "From" field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the "From" field.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you\'re not using a Custom Template to render your form.</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<ul><li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these "Director" pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered "approved," and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the "output" directory under the
module\'s installation directory, assuming the web server has permission to write there.
</ul></li></li></ul>

<h3>Email and Flat File Templates</h3>
<p>Man disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it\'s own best guess, which may or may not work out to your liking. You can always click on the "Create Sample Template" and then customize the results.</p>
<p>Note that once you\'ve changed a template, it will no longer automatically add new fields. For this reason, it\'s usually best to create your templates as the last step of creating your form.</p>

<h3>Known Issues</h3>
<ul>
<li>Some field types from FeedbackForms are not implemented in FormBuilder. If there is demand for them, they will be added.</li>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder cannot yet be inlined. That should be a simple upgrade down the line.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn\'t matter since the user side is pretty simple.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you\'re running CMS 1.0-svn or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you\'re missing fields in an email that gets generated, check the disposition field\'s template, and make sure you\'re specifying the missing fields. Seems obvious, but it\'s an easy mistake to make.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is a fairly early version, if not a rank beta release, and it is probably still buggy. While I\'ve done all I can
to make sure no egregious bugs have crept in, I have to admit that during testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor\'s nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>.</li>
<li>Additional discussion of this module may also be found in the <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>  
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright © 2006, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '		    <ul>
                    <li>Version 0.2.3
                      <p>Add the ability to call a selectable user defined tag upon disposition of the form.</p>
                    </li>
                    <li>Version 0.2.2
                       <p>Many thanks to Utter Design for sponsoring some changes and bugfixes, which include:
                          <ul>
                            <li>Added file upload capabilities to the email disposition</li>
                            <li>Add PageSetStart and PageSetEnd field types
                                <p>These field types allow you to create fieldsets in your form, and organise
                                   your fields logically for the user.  You can even nest fieldsets, and
                                   associate a style with them appropriately.  The default template was changed
                                   to prevent it from wrapping a div around these types of fields.
                                </p>
                            </li>
                            <li>Fixed a problem with DATETIME fields on install
                                <p>This solves a problem when on install the response table would sometimes not get created when using adodb lite</li>
                            </li>
                          </ul>
                       </p>
		    <li>Version 0.2 - 14 November 2006. Calguy & tsw\'s bug fixes for field re-ordering and custom templates. Additional bug fixes for field labels.</li>
		    <li>Version 0.1 - 8 July 2006. Initial Release</li>
                    </ul>
		';
$lang['utma'] = '156861353.1919167701.1195432170.1196522535.1196538838.13';
$lang['utmz'] = '156861353.1196538838.13.7.utmccn=(referral)|utmcsr=euroholod.kz|utmcct=/admin/index.php|utmcmd=referral';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/sk_SK.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Formul&aacute;re';
$lang['field_type_'] = 'Field Type Not Set';
$lang['field_type_CatalogerItemsField'] = 'Select one (or more) cataloger items';
$lang['field_type_FieldsetEnd'] = '-Fieldset End';
$lang['field_type_FieldsetStart'] = '-Fieldset Start';
$lang['field_type_TextField'] = 'Text Input';
$lang['field_type_TextFieldExpandable'] = 'Text Input (Multiple)';
$lang['field_type_TextAreaField'] = 'Textov&eacute; pole';
$lang['field_type_CheckboxField'] = 'Check Box';
$lang['field_type_CheckboxGroupField'] = 'Check Box Group';
$lang['field_type_PulldownField'] = 'V&yacute;berov&eacute; pole';
$lang['field_type_MultiselectField'] = 'Multiselect';
$lang['field_type_StatePickerField'] = 'U.S. State Picker';
$lang['field_type_ProvincePickerField'] = 'Canadian Province Picker';
$lang['field_type_CountryPickerField'] = 'Country Picker';
$lang['field_type_DatePickerField'] = 'Date Picker';
$lang['field_type_TimePickerField'] = 'Time Picker';
$lang['field_type_RadioGroupField'] = 'Radio Button Group';
$lang['field_type_DispositionDirector'] = '*Email Results Based on Pulldown';
$lang['field_type_DispositionFileDirector'] = '*Save Results to File Based on Pulldown';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Save Results to File(s) Based on Multiple Selections';
$lang['field_type_DispositionPageRedirector'] = '*Redirect to Page Based on Pulldown';
$lang['field_type_DispositionEmail'] = '*Email Results to set Address(es)';
$lang['field_type_DispositionEmailConfirmation'] = '*Validate-via-Email Address';
$lang['field_type_DispositionFile'] = '*Write Results to Flat File';
$lang['field_type_DispositionDatabase'] = '*Store Results in Database';
$lang['field_type_DispositionFormBrowser'] = '*Store Results for FormBrowser Module v.3';
$lang['field_type_DispositionUserTag'] = '*Call A User Defined Tag With the Form Results';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Email to User-Supplied Email Address';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Email to CMS Admin User';
$lang['field_type_PageBreakField'] = '-Page Break';
$lang['field_type_FileUploadField'] = 'File Upload';
$lang['field_type_FromEmailAddressField'] = 'Email &quot;From Address&quot; Field';
$lang['field_type_FromEmailNameField'] = 'Email &quot;From Name&quot; Field';
$lang['field_type_FromEmailSubjectField'] = 'Email &quot;Subject&quot; Field';
$lang['field_type_StaticTextField'] = '-Static Text';
$lang['field_type_SystemLinkField'] = '-Static Link';
$lang['field_type_LinkField'] = 'Link (User-entered)';
$lang['field_type_HiddenField'] = '-Hidden Field';
$lang['field_type_ComputedField'] = '-Computed Field';
$lang['field_type_UniqueIntegerField'] = '-Unique Integer (Serial)';
$lang['validation_none'] = 'No Validation';
$lang['validation_numeric'] = 'Numeric';
$lang['validation_integer'] = 'Integer';
$lang['validation_email_address'] = 'Email Address';
$lang['validation_usphone'] = 'Phone Number (US)';
$lang['validation_must_check'] = 'Must Be Checked';
$lang['validation_regex_match'] = 'Match Regular Expression';
$lang['validation_regex_nomatch'] = 'Doesn&#039;t match Regular Expression';
$lang['required_field_missing'] = 'A value was not supplied for a required field';
$lang['please_enter_a_value'] = 'Please enter a value for &quot;%s&quot;';
$lang['please_enter_a_number'] = 'Please enter a number for &quot;%s&quot;';
$lang['please_enter_valid'] = 'Please enter a valid entry for &quot;%s&quot;';
$lang['please_enter_an_integer'] = 'Please enter an integer value for &quot;%s&quot;';
$lang['please_enter_an_email'] = 'Please enter a valid email address for &quot;%s&quot;';
$lang['please_enter_a_phone'] = 'Please enter a valid phone number for &quot;%s&quot;';
$lang['not_valid_email'] = '&quot;%s&quot; does not appear to be a valid email address!';
$lang['please_enter_no_longer'] = 'Please enter a value that is no longer than %s characters';
$lang['title_list_delimiter'] = 'Character to use as delimiter in results that return more than one value';
$lang['you_need_permission'] = 'You need the &quot;%s&quot; permission to perform that operation.';
$lang['lackpermission'] = 'Sorry! You don&#039;t have adequate privileges to access this section.';
$lang['field_order_updated'] = 'Field order updated.';
$lang['form_deleted'] = 'Form deleted.';
$lang['field_deleted'] = 'Field deleted.';
$lang['configuration_updated'] = 'Configuration Updated.';
$lang['you_must_check'] = 'You must check &quot;%s&quot; in order to continue.';
$lang['must_specify_one_destination'] = 'You need to specify at least one destination address!';
$lang['are_you_sure_delete_form'] = 'Are you sure you want to delete the form %s?';
$lang['are_you_sure_delete_field'] = 'Are you sure you want to delete the field %s?';
$lang['notice_select_type'] = 'Advanced options are not available until the field type has been set.';
$lang['field_name_in_use'] = 'The field name &quot;%s&quot; is already in use. Please use unique field names, or disable unique field names in the Form Builder configuration.';
$lang['field_no_name'] = 'Fields must be named, unless you disable this in the Form Builder configuration.';
$lang['anonymous'] = 'Anonymous';
$lang['abbreviation_length'] = 'Len: %s';
$lang['boxes'] = '%s boxes';
$lang['options'] = '%s options';
$lang['text_length'] = '%s chars.';
$lang['order'] = 'Order';
$lang['unspecified'] = '[unspecified]';
$lang['added'] = 'added';
$lang['updated'] = 'updated';
$lang['sort_options'] = 'Sort options on output';
$lang['select_one'] = 'Vybrať jeden';
$lang['select_type'] = 'Vybrať typ';
$lang['to'] = 'Do';
$lang['yes'] = '&Aacute;no';
$lang['no'] = 'Nie';
$lang['recipients'] = 'pr&iacute;jimatelia';
$lang['file_count'] = '%s possible files';
$lang['destination_count'] = '%s destinations';
$lang['save'] = 'Uložiť';
$lang['add'] = 'Pridať';
$lang['update'] = 'Aktualizovať';
$lang['save_and_continue'] = 'Uložiť a pokračovať v &uacute;prav&aacute;ch';
$lang['information'] = 'Inform&aacute;cia';
$lang['automatic'] = 'Automaticky';
$lang['forms'] = 'Formul&aacute;re';
$lang['form'] = 'Formul&aacute;r %s';
$lang['configuration'] = 'Konfigur&aacute;cia';
$lang['field_requirement_updated'] = 'Pole s vyžadnovan&iacute;m aktualizovan&eacute;';
$lang['maximum_size'] = 'Max. veľkosť';
$lang['permitted_extensions'] = 'Roz&scaron;&iacute;renia';
$lang['permitted_filetypes'] = 'Povolen&eacute; typy s&uacute;borov';
$lang['file_too_large'] = 'Nahr&aacute;van&yacute; s&uacute;bor je pr&iacute;li&scaron; veľk&yacute;! Povolen&aacute; je maxim&aacute;lna veľkosť:';
$lang['illegal_file_type'] = 'This type of file may not be uploaded. Please check that the extension is correct.';
$lang['upload'] = 'Nahrať';
$lang['form_imported'] = 'Formul&aacute;r naimportovan&yacute;.';
$lang['form_import_failed'] = 'Import formul&aacute;ra zlyhalo! Probl&eacute;m s parsovan&iacute;m XML.';
$lang['rows'] = '%s riadkov';
$lang['cols'] = '%s stĺpcov';
$lang['12_hour'] = '12 hodinov&yacute; cas';
$lang['24_hour'] = '24 hodinov&yacute; čac';
$lang['hour'] = 'Hodina';
$lang['min'] = 'Min&uacute;ta';
$lang['merid'] = 'Meridian';
$lang['date_range'] = 'Hodnotenie: %s - %s';
$lang['thanks'] = 'Thanks! Your submissions have been received.';
$lang['edit'] = 'Upraviť';
$lang['delete'] = 'Odstr&aacute;niť';
$lang['day'] = 'Deň';
$lang['mon'] = 'Mesiac';
$lang['year'] = 'Rok';
$lang['none'] = '(žiadny)';
$lang['uninstalled'] = 'Modul odin&scaron;talovan&yacute;.';
$lang['installed'] = 'Modul verzia %s nain&scaron;talovan&yacute;.';
$lang['upgraded'] = 'Modul aktualizovan&yacute; na verziu %s.';
$lang['button_previous'] = 'Sp&auml;ť';
$lang['button_submit'] = 'Submit Form';
$lang['button_continue'] = 'Continue...';
$lang['value_checked'] = 'Checked';
$lang['value_unchecked'] = 'Unchecked';
$lang['tab_main'] = 'Main';
$lang['tab_symbol'] = 'Form Display Settings';
$lang['tab_submit'] = 'Form Submission';
$lang['tab_captcha'] = 'Captcha Settings';
$lang['tab_advanced'] = 'Advanced Settings';
$lang['tab_templatelayout'] = 'Form Template';
$lang['tab_submissiontemplate'] = 'Submission Template';
$lang['canuse_smarty'] = '<em>Smarty variables are valid in this field.</em>';
$lang['add_options'] = 'Add More Options';
$lang['delete_options'] = 'Delete Marked Options';
$lang['add_checkboxes'] = 'Add More Checkboxes';
$lang['delete_checkboxes'] = 'Delete Marked Checkboxes';
$lang['add_address'] = 'Add Another Address';
$lang['delete_address'] = 'Delete Marked Addresses';
$lang['add_destination'] = 'Add Another Destination';
$lang['delete_destination'] = 'Delete Marked Destinations';
$lang['suspected_spam'] = 'Pr&iacute;li&scaron; veľa e-mailov generovan&yacute;ch z va&scaron;ej IP adresy. Anti-Spam k&oacute;d ma zabr&aacute;niť doručeniu';
$lang['suspected_spam_log'] = 'Podozrenie na spam z a IP %s zastaven&yacute;.';
$lang['reorder'] = 'Prerozdeliť polia';
$lang['cancel'] = 'Zru&scaron;iť';
$lang['value_set'] = 'Stanoviť hodnotu: %s';
$lang['help_cataloger_attribute_fields'] = 'Below is a list of the attributes available from the Cataloger module.<br/>You can optionally specify valid ranges, values, or numerous values to be used in filtering the list of items that is displayed to the user.<br/>
<br/>
<strong>Ranges:</strong><br/>
Ranges can be specified by signifying a minimum and maximum value using this syntax: &quot;range: minvalue to maxvalue&quot;<br/>
<br/>
<strong>Multiple Values:</strong><br/>
To specify multiple values for an attribute use the syntax &quot;multi: value1|value2|value3&quot;<br/>
<br/>
<strong>Values from hidden fields</strong><br/>
To specify a value from a hidden field use the syntax {$fld_id}<br/>
<br/>';
$lang['help_name_regex'] = 'A regular expression to allow filtering cataloger items by name';
$lang['help_field_height'] = 'V&yacute;&scaron;ka viacn&aacute;sobn&eacute;ho v&yacute;berov&eacute;ho poľa';
$lang['title_name_regex'] = 'Cataloger Item Name Regular Expression';
$lang['title_field_height'] = 'V&yacute;&scaron;ka poľa';
$lang['title_file_path'] = 'Destination Directory for output files';
$lang['title_udt_name'] = 'Už&iacute;vateľskňy t&aacute;g';
$lang['title_uploads_destpage'] = 'Str&aacute;nka pre n&aacute;vrat s odkazom pre s&uacute;bor';
$lang['title_uploadmodule_summary'] = 'Submitted with formbuilder';
$lang['title_uploads_category'] = 'Kateg&oacute;ria Upload modulu';
$lang['title_sendto_uploads'] = 'S&uacute;bor odoslať do modulu Uploads';
$lang['title_legend'] = 'Legenda';
$lang['title_maximum_length'] = 'Maxim&aacute;lna dĺžka';
$lang['title_checkbox_label'] = 'Label (popisok) za&scaron;krt&aacute;vacieho poľa';
$lang['title_radio_label'] = 'Label (popisok) r&aacute;dio tlač&iacute;tka';
$lang['title_checked_value'] = 'Hodnota pri v&yacute;bere';
$lang['title_unchecked_value'] = 'Hodnota bez v&yacute;beru';
$lang['title_checkbox_details'] = 'Nastavenia pre skupinu za&scaron;rt&aacute;vac&iacute;ch pol&iacute;';
$lang['title_delete'] = 'Odstr&aacute;niť?';
$lang['title_select_one_message'] = '&quot;Text prv&eacute;ho poľa&quot; ';
$lang['title_selection_value'] = 'Hodnota v&yacute;beru';
$lang['title_selection_displayname'] = 'N&aacute;zov v&yacute;beru';
$lang['title_selection_subject'] = 'Predmet pre v&yacute;ber';
$lang['title_select_default_country'] = 'Prednastaven&yacute; v&yacute;ber';
$lang['title_select_default_state'] = 'Prednastaven&yacute; v&yacute;ber';
$lang['title_select_default_province'] = 'Prednastaven&yacute; v&yacute;ber';
$lang['title_option_name'] = 'N&aacute;zov voľby';
$lang['title_option_value'] = 'Odoslan&aacute; hodnota';
$lang['title_pulldown_details'] = 'Nastavenia pre v&yacute;berov&eacute; pole';
$lang['title_multiselect_details'] = 'Nastavenia pre viacn&aacute;sovn&eacute; v&yacute;berov&eacute; pole ';
$lang['title_destination_address'] = 'Destination Email Address';
$lang['title_destination_filename'] = 'Destination File Name';
$lang['title_email_from_name'] = '&quot;From name&quot; for email';
$lang['title_relaxed_email_regex'] = 'Použi jednoduch&uacute; kontrolu e-mailovej adresy';
$lang['title_relaxed_regex_long'] = 'Použije jednoduch&scaron;iu kontrolu e-mailovej adresy  (napr. povol&iacute; e-mail v tvare  &quot;x@y&quot; namiesto požadovn&eacute;ho x@y.tld)';
$lang['title_email_from_address'] = '&quot;Z adresy&quot; pre e-mail';
$lang['title_email_encoding'] = 'Znakov&aacute; sada pre e-mail';
$lang['title_director_details'] = 'Pulldown-based Emailer Details';
$lang['title_file_name'] = 'N&aacute;zov poľa';
$lang['title_email_subject'] = 'Predmet e-mailu';
$lang['title_form_name'] = 'N&aacute;zov formul&aacute;ra';
$lang['title_form_status'] = 'Stav formul&aacute;ra';
$lang['title_ready_for_deployment'] = 'Pripraven&yacute; pre nasadenie';
$lang['title_not_ready1'] = 'Nie je pripraven&yacute;';
$lang['title_redirect_page'] = 'Presmerovať na str&aacute;nku po odoslan&iacute; formul&aacute;ra';
$lang['title_not_ready2'] = 'Please add a field to the form so that the user&#039;s input gets handled. You can';
$lang['title_not_ready_link'] = 'použi t&uacute;to kl&aacute;vesov&uacute; skratku';
$lang['title_form_alias'] = 'Alias formul&aacute;ra';
$lang['title_form_fields'] = 'Polia formul&aacute;ra';
$lang['title_field_id'] = 'ID formul&aacute;ra';
$lang['title_show_fieldaliases'] = 'Uk&aacute;ž pole aliasu';
$lang['title_show_fieldaliases_long'] = 'Kliknut&iacute;m zobraz&iacute;te aliasy pol&iacute; pri prid&aacute;van&iacute; alebo edit&aacute;cii formul&aacute;ra';
$lang['title_field_name'] = 'N&aacute;zov poľa';
$lang['title_field_alias'] = 'Alias poľa';
$lang['title_radiogroup_details'] = 'Nastavenia skupiny r&aacute;dio tlač&iacute;tok';
$lang['title_field_type'] = 'Typ poľa';
$lang['title_not_ready3'] = 'pre vytvorenie formul&aacute;rov&eacute;ho poľa';
$lang['title_add_new_form'] = 'Pridať nov&yacute; formul&aacute;r';
$lang['title_show_version'] = 'Uk&aacute;zať versiu modulu pre formul&aacute;re?';
$lang['title_show_version_long'] = 'This will embed your installed version number of Form Builder module in a comment, to aid in debugging';
$lang['title_add_new_field'] = 'Pridať nov&eacute; pole';
$lang['title_form_submit_button'] = 'Text tlač&iacute;tka pre odosielanie';
$lang['title_submit_button_safety'] = 'Pridať javascript pri odosielan&iacute; na ochranu pred viacn&aacute;sobn&eacute;mu odslaniu formul&aacute;ra?';
$lang['title_submit_button_safety_help'] = 'Pridať bezpečnostn&yacute; script';
$lang['title_form_next_button'] = 'Form &quot;Next&quot; Button Text (used for multipage forms)';
$lang['title_form_prev_button'] = 'Form &quot;Previous&quot; Button Text (used for multipage forms)';
$lang['title_field_validation'] = 'Field Validation';
$lang['title_form_css_class'] = 'CSS Class for this form';
$lang['title_field_css_class'] = 'CSS Class for this field';
$lang['title_form_required_symbol'] = 'Symbol to mark required Fields';
$lang['title_field_required'] = 'Required';
$lang['title_field_required_long'] = 'Require a response for this Field';
$lang['title_hide_label'] = 'Hide Label';
$lang['title_hide_label_long'] = 'Hide this field&#039;s name on Form';
$lang['title_text'] = 'Static text to display';
$lang['title_field_regex'] = 'Validation Regex';
$lang['title_lines_to_show'] = 'Number of Lines to display';
$lang['no_default'] = 'No Default';
$lang['redirect_after_approval'] = 'Page to redirect after approval';
$lang['title_regex_help'] = 'This regular expression will only be used if &quot;validation type&quot; is set to a regex-related option. Include a full Perl-style regex, including the start/stop slashes and flags (e.g., &quot;/image\.(\d+)/i&quot;)';
$lang['title_field_required_abbrev'] = 'Req&#039;d';
$lang['title_hide_errors'] = 'Hide Errors';
$lang['title_form_displaytype'] = 'Form Display Type';
$lang['title_hide_errors_long'] = 'Prevent debug / error messages from being seen by users.';
$lang['title_email_template'] = 'Email Template';
$lang['title_maximum_size'] = 'Maximum upload file size (kilobytes)';
$lang['title_maximum_size_long'] = 'This limitation is in addition to any limits set by the php or web server configuration';
$lang['title_permitted_extensions'] = 'Permitted Extensions';
$lang['title_permitted_extensions_long'] = 'Enter a comma-separated list, excluding the dot (e.g., &quot;jpg,gif,jpeg&quot;). Spaces will be ignored. Leaving this blank means there will be no restrictions.';
$lang['title_show_limitations'] = 'Display restrictions?';
$lang['title_show_limitations_long'] = 'Display any size and extension restrictions with the upload field?';
$lang['title_form_template'] = 'Template to use to Display Form';
$lang['title_page_x_of_y'] = 'Page %s of %s';
$lang['title_no_advanced_options'] = 'Field has no advanced options.';
$lang['title_form_unspecified'] = 'Text to return for unspecified field values';
$lang['title_enable_fastadd_long'] = 'Enable fast field adding pulldown for forms?';
$lang['title_enable_fastadd'] = 'Enable fast field add pulldown?';
$lang['title_fastadd'] = 'Fast field adder';
$lang['title_enable_antispam_long'] = 'Clicking this will only allow 10 emails to be triggered from a given IP address (per hour).';
$lang['title_enable_antispam'] = 'Enable primitive anti-spam features?';
$lang['title_show_fieldids'] = 'Show Field IDs';
$lang['title_show_fieldids_long'] = 'Clicking this will allow displaying field ids when adding or editing a form';
$lang['title_xml_to_upload'] = 'Upload form from XML file';
$lang['title_xml_upload_formname'] = 'Use this form name';
$lang['title_import_legend'] = 'XML Form Import';
$lang['title_xml_upload_formalias'] = 'Use this form alias';
$lang['title_html_email'] = 'Generate HTML email?';
$lang['title_link_autopopulate'] = 'Automatically populate?';
$lang['title_link_autopopulate_help'] = 'Automatically populate with the URL of the page containing the form? (this overrides site page link option below)';
$lang['title_default_link'] = 'Default link URL';
$lang['title_default_link_title'] = 'Default link text';
$lang['title_link_to_sitepage'] = 'Link to site page';
$lang['title_captcha_not_installed'] = 'You can use <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a> to protect form submissions if you install the Captcha module. For more information, <a href="http://dev.cmsmadesimple.org/projects/captcha/">check the Captcha project</a>.';
$lang['title_use_captcha'] = 'Use Captcha to protect form submissions?';
$lang['title_use_captcha_help'] = 'Check here to protect your form with a <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a>.';
$lang['title_user_captcha'] = 'Please confirm that you are not a script by entering the letters from the image.';
$lang['title_user_captcha_error'] = 'Failed text for Captcha';
$lang['wrong_captcha'] = 'Captcha was not correct.';
$lang['title_title_user_captcha'] = 'Help text for Captcha';
$lang['title_dont_submit_unchecked'] = 'Don&#039;t submit values for unchecked boxes';
$lang['title_dont_submit_unchecked_help'] = 'Check this if you only want checked boxes to return values.';
$lang['link_label'] = 'Link Label';
$lang['link_destination'] = 'Link Destination URL';
$lang['title_default_set'] = 'Checked by Default?';
$lang['title_24_hour'] = 'Use 24-hour clock?';
$lang['title_before_noon'] = 'AM';
$lang['title_after_noon'] = 'PM';
$lang['title_smarty_eval'] = 'Process smarty tags within field?';
$lang['title_textarea_rows'] = 'Rows (note: this may be overridden by CSS)';
$lang['title_textarea_cols'] = 'Columns (note: this may be overridden by CSS)';
$lang['title_form_main'] = 'Main Form Details';
$lang['title_show_username'] = 'Display User&#039;s login name?';
$lang['title_show_userfirstname'] = 'Display User&#039;s first name?';
$lang['title_show_userlastname'] = 'Display User&#039;s last name?';
$lang['title_restrict_to_group'] = 'Restrict user list to users in specified group';
$lang['restricted_to_group'] = 'Only in group %s';
$lang['title_show_to_user'] = 'Display to user?';
$lang['help_leaveempty'] = 'This field may be left empty';
$lang['help_variables_for_template'] = 'Variables For Template';
$lang['help_variables_for_computation'] = 'Variables Available';
$lang['help_php_variable_name'] = 'PHP variable';
$lang['help_submission_date'] = 'Date of Submission';
$lang['help_server_name'] = 'Your server';
$lang['help_sub_source_ip'] = 'IP address of person using form';
$lang['help_sub_url'] = 'URL of page containing form';
$lang['help_fb_version'] = 'FormBuilder version';
$lang['help_tab'] = 'Tab Character';
$lang['help_other_fields'] = 'Alternate field names can be used interchangeably (especially useful if Smarty is choking on characters outside of ASCII 32-126). <br />Other fields will be available as you add them to the form.';
$lang['help_array_fields'] = 'Yet another way of accessing field values is via $fieldname_obj, $alias_obj, or $fld_#_obj, where each field is an object containging:<br /><table>
<tr><td class=&quot;odd&quot;>name</td><td class=&quot;odd&quot;>Field Name</td></tr>
<tr><td>type</td><td>Field Type</td></tr>
<tr><td class=&quot;odd&quot;>id</td><td class=&quot;odd&quot;>Internal Field ID</td></tr>
<tr><td>value</td><td>Human-readable Value</td></tr>
<tr><td class=&quot;odd&quot;>valueArray</td><td class=&quot;odd&quot;>Array of field value(s)</td></tr></table><em>e.g.</em>, you could use &quot;{$fld_1_obj->name} = {$fld_1_obj->value}';
$lang['help_date_format'] = 'See <a href="http://www.php.net/manual/en/function.date.php" target=_NEW>the PHP Manual</a> for formatting help.';
$lang['help_variable_name'] = 'Variable';
$lang['help_form_field'] = 'Field Represented';
$lang['link_back_to_form'] = '&laquo; Back to Form';
$lang['title_create_sample_template'] = 'Create Sample Template';
$lang['title_create_sample_html_template'] = 'Create Sample HTML Template';
$lang['title_create_sample_header_template'] = 'Create Sample Header Template';
$lang['title_create_sample_header'] = 'Create Sample Header';
$lang['help_tab_symbol'] = 'a tab character';
$lang['title_file_template'] = 'Template for one line of output file';
$lang['title_file_header'] = 'Template for the header of output file';
$lang['title_confirmation_url'] = 'URL to click for form confirmation';
$lang['title_value'] = 'Value (see Advanced Tab if you use Smarty tags)';
$lang['title_date_format'] = 'Date Format (standard <a href="http://www.php.net/manual/en/function.date.php">PHP Date Formats</a>)';
$lang['title_use_wysiwyg'] = 'Use WYSIWYG editor for text Area (Admin side only)?';
$lang['title_submit_actions'] = 'Form Submission Behavior';
$lang['title_submit_labels'] = 'Submission Button Labels';
$lang['title_sortable_field'] = 'Sortable Field #%s';
$lang['title_submit_help'] = 'This page lets you customize Form Submission. It doesn&#039;t determine what the Form Builder does with the submitted data. You can set that up by adding &quot;Disposition&quot; fields to your form.';
$lang['title_start_year'] = 'Year range start';
$lang['title_end_year'] = 'Year range end';
$lang['title_default_year'] = 'Default Year';
$lang['title_default_year_help'] = '(Set to -1 for default year to be the current year)';
$lang['title_submit_action'] = 'After form is submitted';
$lang['title_submit_response'] = 'Response to display';
$lang['display_text'] = 'Display &quot;Submission Template&quot;';
$lang['redirect_to_page'] = 'Redirect to site page';
$lang['title_submit_response_help'] = 'This template is for display to the user after the form is submitted. This template does not effect emails generated or other form dispositions -- you set those templates (where appropriate) in the &quot;advanced&quot; tab for those disposition fields.';
$lang['title_destination_page'] = 'Destination Page';
$lang['title_require_fieldnames'] = 'Require Fieldnames';
$lang['title_require_fieldnames_long'] = 'Require fields to have a name?';
$lang['title_unique_fieldnames'] = 'Require Unique Fieldnames';
$lang['title_unique_fieldnames_long'] = 'Require fields to have unique names?';
$lang['title_reorder_form'] = 'Reorder Fields';
$lang['title_load_template'] = 'Load template';
$lang['title_add_button_text'] = 'Add Button text';
$lang['title_del_button_text'] = 'Delete Button text';
$lang['title_string_or_number_eval'] = 'Interpret variables as being numbers or strings';
$lang['title_order'] = 'Interpretation Order';
$lang['title_order_help'] = 'If more than one Computed Field exists, they will be computed from lowest order number to highest order number';
$lang['title_compute_value'] = 'Value to compute';
$lang['title_string'] = 'String';
$lang['title_numeric'] = 'Numeric';
$lang['title_inline_form'] = 'Display form inline?';
$lang['title_inline_form_help'] = 'Inline means any form followup replaces the {cms_module} tag, non-inline replaces the {content} tag.';
$lang['title_field_default_value'] = 'Default value for field';
$lang['title_clear_default'] = 'Clear default on click?';
$lang['title_clear_default_help'] = 'Check this to clear the default value when the user clicks this field. Since this uses a javascript string compare, it will fail if you put single quotes in your default text. Other un-javascript-friendly characters may also cause it to fail.';
$lang['title_remove_file_from_server'] = 'Delete uploaded file from server after processing (email dispositions)';
$lang['title_field_javascript'] = 'Javascript for field';
$lang['title_field_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;';
$lang['title_submit_javascript'] = 'Form Submission Javascript';
$lang['title_submit_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;.<br />This will probably not work well if you use the &quot;safety script&quot; option above.';
$lang['email_from_addr_help'] = 'Do not just pick a random address here -- many ISPs will<br />not deliver the mail if you are using a different domain name than your actual<br />host name (i.e., use something like name@%s)';
$lang['title_switch_advanced'] = 'Need more field types? ';
$lang['title_switch_basic'] = 'Too many confusing field types? ';
$lang['title_switch_advanced_link'] = 'Switch to Advanced Mode';
$lang['title_switch_basic_link'] = 'Switch to Simple Mode';
$lang['title_file_root'] = 'Directory to save file in';
$lang['title_file_root_help'] = 'This needs to be a directory that your web server has permissions to write in.<br />Chmod it 777 if you have problems/doubts.<br />Also, check to see that you do not have PHP directory restrictions.';
$lang['error_cataloger_module_not_available'] = '<strong>Cataloger module does not seem to be installed/active.</strong>';
$lang['warning'] = 'WARNING!';
$lang['default_template'] = 'Default Template';
$lang['table_left_template'] = 'Table Template, Titles on left';
$lang['table_top_template'] = 'Table Template, Title on top';
$lang['form_template_name'] = 'Template from %s';
$lang['template_are_you_sure'] = 'Are you sure you want to overwrite your template with the selected template? (Even if you say OK, you will still need to save the change)';
$lang['title_bad_function'] = 'Error when computing &quot;%s&quot;.';
$lang['no_referrer_info'] = 'No HTTP_REFERER info available (probably due to use of User Email Validation)';
$lang['validation_param_error'] = 'Validation Parameter Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_response_error'] = 'Validation Repsonse Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_no_field_error'] = 'Validation Repsonse Error. No email validation field in this form!';
$lang['upgrade03to04'] = 'Form Template was updated automatically as part of the version 0.3 to version 0.4 upgrade. You may need to make some fixes. If you&#039;re using the default form, simply replace this template with &quot;default&quot; using the pulldown above.';
$lang['admindesc'] = 'Add, edit and manage interactive Forms';
$lang['operators_help'] = 'If you use String evaluation, the only operation available is concatenation (+), while if you use Number evaluation you have basic, very simple math (, +, -, *, /, ).';
$lang['date_january'] = 'Janu&aacute;r';
$lang['date_february'] = 'Febru&aacute;r';
$lang['date_march'] = 'Marec';
$lang['date_april'] = 'Apr&iacute;l';
$lang['date_may'] = 'M&aacute;j';
$lang['date_june'] = 'J&uacute;n';
$lang['date_july'] = 'J&uacute;l';
$lang['date_august'] = 'August';
$lang['date_september'] = 'September';
$lang['date_october'] = 'Okt&oacute;ber';
$lang['date_november'] = 'November';
$lang['date_december'] = 'December';
$lang['submission_error'] = 'Prep&aacute;čte! Nastala chyba pri odosielan&iacute; formul&aacute;ra';
$lang['submit_error'] = 'FormBuilder submit error: %s';
$lang['uploads_error'] = 'Error committing file to the uploads module: %s';
$lang['nouploads_error'] = 'Could not find the uploads module';
$lang['upload_attach_error'] = 'Upload/Attachment error on file %s (tmp_name: %s, of type %s)';
$lang['submission_error_file_lock'] = 'Error. Unable to obtain lock for file.';
$lang['unchecked_by_default'] = 'Prednastaven&eacute;: neza&scaron;krtnut&eacute;';
$lang['checked_by_default'] = 'Prednastaven&eacute;: za&scaron;kratnut&eacute;';
$lang['email_default_template'] = 'Odoslielanie formul&aacute;ra';
$lang['email_template_not_set'] = '<br/>E-mailov&aacute; &scaron;abl&oacute;na zatiaľ nepoužit&aacute;';
$lang['missing_cms_mailer'] = 'FormBuilder: Cannot find required module CMSMailer!';
$lang['user_approved_submission'] = 'User approved submission %s from %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Event triggered when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Event triggered if there is an error when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Event triggered when a FormBuilder form is displayed';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Event triggered when a FormBuilder form is submitted.</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>value_<name></em> - Supply a default value to a field with the specified name.</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Event triggered if there is an error when a FormBuilder form is submitted</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>error</em> - A list of all known errors (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Event triggered when a FormBuilder form is displayed</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
</ul> ';
$lang['formbuilder_params_response_id'] = 'Response ID. Used by FormBrowser';
$lang['formbuilder_params_passed_from_tag'] = 'Default field values; see module help';
$lang['formbuilder_params_field_id'] = 'Field ID for internal operations';
$lang['formbuilder_params_form_name'] = 'Form Name';
$lang['formbuilder_params_form_id'] = 'Form ID for internal operations';
$lang['formbuilder_params_general'] = 'General parameters for internal operations';
$lang['template_variable_help'] = '<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>
';
$lang['post_install'] = '<p>Make sure to set the &quot;Modify Forms&quot; permissions
on users who will be administering feedback forms. Also, if you&#039;ll be emailing form
results, be sure to update the Configuration appropriately.</p>
<p>Please be aware that a feedback form should not be active (e.g., usable by the public) while
you are still editing the form. You should create the form, and place the tag into an active
content page only when you have finished editing. Otherwise, erroneous results could be returned.</p>
<p>Additionally, this version does not support parallel editing of forms. Please take care that
only one admin is editing a given form at a given time.</p>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create feedback forms (in fact, it&#039;s a replacement of the original Feedback Form module), with the added power of database storage. With its companion module Form Browser, you can use it to create simple database applications.</p>
<p>The forms created using the Form Builder may be inserted
into templates and/or content pages. Forms may contain many kinds of inputs, and may have
validation applied to these inputs. The results of these forms may be handled in a variety of ways.</p>

<h3>How Do I Use it?</h3>
<P>Install it, and poke around the menus. Play with it. Try creating forms, and adding them to your content.
If you get stuck, chat with me on the #cms IRC channel, post to the forum, send me email, or, if you&#039;re
really desperate, try reading the instructions on the rest of this page.</P>

<h3>How Do I Create a Form</h3>
<p>In the CMS Admin Menu, you should get a new menu item called FormBuilder. Click on this. On the page
that gets shown, there are options (at the bottom of the list of Forms) to Add a New Form or Modify
Configuration.</p>

<h3>Adding a Form to a Page</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module=&#039;FormBuilder&#039; form=&#039;sample_form&#039;}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page&#039;s content if you use a WYSIWYG editor such as TinyMCE, FCKEdit, or HTMLArea. These editors may stealthily
change the quote marks (&quot;) into HTML entities (&amp;quot;), and the forms will not show up. Try using
single quotes (&#039;) or editing the HTML directly.</p>

<h3>Working with Forms</h3>
<p>By clicking on a Form&#039;s name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you&#039;ll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing.</p>
<p>Below this, if you have it enabled, is the &quot;fast field adder&quot; pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Form Submission</h4>
<p>When the form is submitted, you can either redirect the user to another page of your site, or you can present the user some message (which can contain any of the user&#039;s form entries, or just static text). In this tab, you select which of these approaches you wish to use, and, if you chose redirection, it allows you to pick the page to redirect users to after a successful form submission.</p>
<p>Also on this page, you can specify the labels of various submission buttons (&quot;Previous&quot;, &quot;next&quot;, &quot;submit&quot;). You can also opt to have some Javascript added to the last page of a form that will prevent multiple submissions (useful on slow servers).</p>
<h4>Form Display Options</h4>
<p>This tab allows for other form customizations, like the symbol to show for required fields.</p>
<h4>Captcha Settings</h4>
<p>If you have installed the Captcha module, this tab lets you configure the Captcha settings for your form.</p>
<h4>Form Template</h4>
<p>This is where you do your customization work of your form&#039;s Smarty Template. See the section called Form Template Variables below.</p>
<p>The form should default to a Custom template that documents the Smarty tags available to you.</p>
<p>Unless you&#039;re a Smarty expert, you probably don&#039;t want to mess around with this. If you are a Smarty expert, this is where you can unleash your magic.</p>
<h4>Submission Template</h4>
<p>If, in the Form Submission tab, you selected &#039;Display &quot;Submission Template&quot;, this is where you can create that template. There is a display of which smarty variables are available to you, and a button to generate a sample template.</p>
<p>If you&#039;re a Smarty expert, you can do all manner of creative and powerful things here. If you&#039;re not a Smarty expert, you might just want to use the default.
</p>

<h3>Adding Fields to your Form</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it&#039;s submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it&#039;s safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked &quot;Required&quot;, which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to &quot;view source&quot; on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It&#039;s really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It&#039;s really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Canadian Province. This is a pulldown listing the Canadian Provinces (Contributed by Noel McGran. Thanks!)</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
<li>Time Picker. This is a set of pulldowns allowing the user to select a time (using 12 or 24 hour clock).</li>
<li>File Upload. This is a file upload field.</li>
<li>Link (User Entered). This creates a double input field for getting a link URL and link title.</li>
<li>Text Field (Multiple). This field creates one or more text inputs with add and delete buttons, effectively giving the end user a way of creating variable-length lists.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the &quot;From&quot; field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the &quot;From&quot; field.</li>
<li>Email Subject Field. This allows users to provide a subject for their email. The email generated when the form gets handled will use this in the &quot;Subject&quot; field. This may cause trouble with certain dispositions that want to control the Email Subject, so use it with caution.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Fieldset Start. Combined with Fieldset End, this allows you to group various fields within your form. Use this to start a given grouping.</li>
<li>-Fieldset End. Combined with Fieldset Start, this allows you to group various fields within your form. Use this to end a given grouping.</li>
<li>-Hidden Field. This allows you to embed a hidden field in your form.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you&#039;re not using a Custom Template to render your form.</li>
<li>-Static Link. This allows you to put a link to a given page into your form. Optionally, you can have it autopopulate with the page where the form is embedded (useful if you&#039;re sending results via email).</li>
<li>-Computed Field. This allows you to embed a computed field in your form. It is not visible to the user until after the form is submitted. It allows you to do simple arithmetic or string concatenation.</li>
<li>-Unique Integer (Serial). This is an integer that increases every time someone hits your form. Your results may not be sequential, but they will increase monotonically.</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<ul><li>*Call a User Defined Tag With the Form Results. This submits all the form results to the User-Defined Tag you specify. The UDT can handle the results however it wants. Values are passed as $param[&#039;field_name&#039;].</li>
<li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these &quot;Director&quot; pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email to User-Supplied Address. This puts an input field in the form for the user to populate with an email address. The form results get sent to that address. Beware of Spam abuse! Active the primitive anti-spam features in the FormBuilder configuration screen.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Redirect to Page Based on Pulldown. This allows you to redirect the form to a different site page depending on its value. If you have multiple dispositions, make sure this is used last.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered &quot;approved,&quot; and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the &quot;output&quot; directory under the
module&#039;s installation directory, assuming the web server has permission to write there.</li>
<li>*Save Results to File Based on Pulldown. Like the Flat File disposition, except the value of a pull-down determines which file results get written to.</li>
<li>*Save Results to File(s) Based on Multiple Selections. Like the Flat File disposition, except the value(s) of checkboxes  determines which file(s) results get written to.</li>
<li>*Email to CMS Admin User. Provides a pull-down of CMS Admin users, and directs the results as an email to the selected admin.</li>
<li>*Store Results for FormBrowser Module v.3. Stores the form results in an XML structure as a single database record. This will become the interface to Form Browser in the next release.</li>

</ul></li></li></ul>


<h3>Passing Default Values to Forms</h3>
<p>Calguy added a nice feature, which is that you can pass default field values to your form via the module tag. This allows you to have
the same form in multiple places, but with different default values. It may not work for more exotic field types, but for fields that have
a single value, you can specify like:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_<i>FIELDNAME</i>=&#039;default_value&#039;}</p>
<p>This will set the field with <i>FIELDNAME</i> to &#039;default_value&#039;.</p>
<p>This can be problematic, as sometimes field names are unweildy or contain characters that don&#039;t work well with Smarty. So there is an
alternative like this:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_fld<i>NUMBER</i>=&#039;default_value&#039;}</p>
<p>That uses field <i>NUMBER</i>, where <i>NUMBER</i> is the internal FormBuilder field id. You might wonder how you know what that id is. Simply go into the FormBuilder configuration tab,
and check &quot;Show Field IDs&quot;</p>

<h3>Email and Flat File Templates</h3>
<p>Many disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it&#039;s own best guess, which may or may not work out to your liking. You can always click on the &quot;Create Sample Template&quot; and then customize the results.</p>
<p>To the right, you&#039;ll find a legend which lists all of the variables that are available to you to use in your template. As of version 0.3, variables have two names, one based on the field name, the other based on the field ID. If you use field names that have characters outside of the ASCII 32-126 range, it will be safer to use the ID-based variables.</p>
<p><strong>Note that once you&#039;ve changed a template, it will no longer automatically add new fields.</strong> For this reason, it&#039;s usually best to create your templates as the last step of creating your form.</p>
<p>As of version 0.2.4, you can opt to send any of these emails as HTML email. There should be a checkbox at the top of the template page for this. There is also a &quot;Create Sample HTML Template&quot; button over in the legend area. For HTML email, the email body will also provide the default text-only values.</p>

<h3>Configuration</h3>
<p>There are some global configuration options for FormBuilder:</p>
<ul>
<li>Enable fast field add pulldown. This enables the pulldown on the Form Edit page which saves a step in the creation of new fields.</li>
<li>Hide Errors. This is set by default. Unchecking it will cause more detailed errors to be displayed if there are problems when you submit your form.</li>
<li>Require Field Names. Typically, you will want form fields to be named so you can tell which is which. However, in some cases, you might want to have nameless fields. Uncheck this if you want to allow nameless fields.</li>
<li>Unique Field Names. Typically, you will want form fields to have unique names so you can tell which is which. Uncheck this if you want to allow fields to share names.</li>
<li>Use relaxed email validation. This uses a less restrictive regular expression for validating email; e.g., x@y will be allowed, where typically x@y.tld is required.</li>
<li>Show Form Builder Version. Displays the version of FormBuilder you&#039;re using in a comment when the form is generated. Typically only useful when debugging.</li>
<li>Enable primitive anti-spam features. When turned on, this allows any given IP address to only generate 10 emails per hour.</li>
<li>Show Field IDs. When turned on, FormBuilder will display field ids when adding or editing a form.</li>
</ul>
<h3>Styling and CSS</h3>
<p>Paul Noone graciously provides us all with a pretty good standard CSS that you can use for forms:</p>
<pre>
	/* Sample FormBuilder CSS base */
	form {margin-top:0}
	form, td, th, li { font-size: 100%}
	form div {margin-bottom:0}
	fieldset div {
		margin-bottom:0.5em;
		margin-left:1em;
	}
	fieldset div div {
		margin-top:0.5em;
		margin-left:1em
	}
	fieldset {
		margin-bottom:1em;
		border:1px solid #F60;
		padding:0.5em
	}
	fieldset label {
		width:auto;
	}
	legend {
		color:#FFF;
		background:#F60;
		font-style:italic;
		font-size:1.2em;
		margin-bottom:0.5em;
		padding:0.2em;
		width:auto;
		border:1px solid #CCC
	}
	textarea {
		margin: 0.5em 0;
		width:98%;
		height: 6em
	}

	/* Apply this class to text/select input fields with shorter labels
		to help alignment */
	.short-label label {float:left; width:10em}
	.short-label fieldset div input,
	.short-label fieldset div select {width:16em}

	/* Pretty up your Captcha image output */
	.captcha {
		margin:0.5em 0;
		width:200px;
		text-align:center
	}
	.captcha img {border:1px solid #F60; margin-bottom:0.5em}
	.captcha input {width:196px; margin-top:0.5em}

	/* Just a bit more room for the Submit button */
	.submit {margin-top:0.5em}
</pre>

<h3>Form Template Variables</h3>

<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>


<h3>Known Issues</h3>
<ul>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn&#039;t matter since the user side is pretty simple.</li>
<li>FileUpload Fields may not work correctly with multipage forms.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you&#039;re running CMS 1.1 or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you&#039;re missing fields in an email that gets generated, check the disposition field&#039;s template, and make sure you&#039;re specifying the missing fields. Seems obvious, but it&#039;s an easy mistake to make.</li>
<li>Uncheck the &quot;Hide Errors&quot; checkbox in the global options, and see what message gets displayed when you submit your form.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is no longer a particularly early version, but it is probably still buggy. While I&#039;ve done all I can
to make sure no egregious bugs have crept in, I have to admit that during early testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor&#039;s nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>.</li>
<li>Additional discussion of this module may also be found in the <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
</ul>
<p>Keep in mind that the author has put hundreds of hours into the development of this module. Please take the time to read the documentation before sending questions. Either that, or write your questions on financially negotiable instruments (i.e., cash).</p>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2008, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '<ul>
<li>Version 0.5.3. 26 May 08. Bugfixes to previous set of bugfixes. Now ready for major upgrades for 0.6.</li>
<li>Version 0.5.2. 25 May 08. Bugfixes. Release in preparation for substantial reworking for 0.6</li>
<li>Version 0.5.1. 30 April 08. Bugfixes, rewrote some of the File Upload code to prevent white screen of annoyance.</li>
<li>Version 0.5. 19 April 08. Bugfixes, support for FormBrowser fixes and features, disposition type for upcoming FormBrowser version.</li>
<li>Version 0.4.4. 26 Sept 07. Bugfixes for radio button groups, fix for validation of DispositionDeliverToEmailAddressField.</li>
<li>Version 0.4.3. 18 Sept 07. Bugfixes for pulldowns using numbers, option to inline form, fixes for table-layouts provided by Ap Muthu, fix for requirability of Dispositions.</li>
<li>Version 0.4.2. 14 Sept 07. Bugfixes for XML export, RadioButton Group submission, and HTML labels.</li>
<li>Version 0.4.1. Bugfixes for File Disposition Types.</li>
<li>Version 0.4
	<ul>
		<li>Upped minimum CMS version to 1.1</li>
		<li>Numerous Bug fixes; too many to enumerate here</li>
		<li>Massive rejiggering of code to work with CMS MS 1.1 parameter sanitizing regime</li>
		<li>Added field types: &quot;TextField (Multiple)&quot; and &quot;Computed Field&quot;</li>
		<li>Added dispositions: &quot;Save Results to File Based on Pulldown&quot; and &quot;Save Results to File(s) Based on Multiple Selections&quot;(Calguy)</li>
		<li>Added neat-o AJAX-y template-copying for Form Templates, gave versions of old table-based templates to soothe the raging masses.</li>
		<li>Added ability to pass default values to form elements from module tag using value_FIELDNAME=&quot;value&quot; syntax (Calguy)</li>
		<li>Added option to display field ids in admin (Calguy)</li>
	</ul>
</li>
<li>Version 0.3
   <ul>
      <li>Added Captcha module support.</li>
      <li>Reworked labeling of form elements to be XHTML compliant</li>
      <li>Added Paul Noone&#039;s new, improved contact form templates</li>
      <li>Implementation of Email Subject Field</li>
      <li>Added admin-specifiable values to hidden field type, which may contain parsable smarty tags</li>
      <li>Text Area Field now allows specification of rows and cols in the admin, instead of CSS</li>
      <li>Added Drag&#039;n&#039;Drop reordering of form fields.</li>
      <li>Added non-blank field name and unique field name global configuration options and validation</li>
      <li>Implemented templated display of form results upon submission in addition to page redirecting</li>
      <li></li>
   </ul>
</li>
<li>Version 0.2.4 - 09 May 2007
   <p>Big release:<ul>
   <li>Added &quot;Email Form to User-Supplied Address&quot; disposition.</li>
   <li>Added &quot;TimePicker&quot; field type. Split &quot;Link&quot; field into a &quot;User-supplied Link&quot; field and a &quot;Static Link&quot; field.</li>
   <li>Added HTML email option and auto-templates for all email dispositions.</li>
   <li>Added primitive anti-spam features.</li>
   <li>Added XML-based import and export of forms.</li>
   </ul>
   </p>
</li>
<li>Version 0.2.3
   <p>Add the ability to call a selectable user defined tag upon disposition of the form.</p>
</li>
<li>Version 0.2.2
   <p>Many thanks to Utter Design for sponsoring some changes and bugfixes, which include:
   <ul>
      <li>Added file upload capabilities to the email disposition</li>
      <li>Add PageSetStart and PageSetEnd field types
      <p>These field types allow you to create fieldsets in your form, and organise
      your fields logically for the user.  You can even nest fieldsets, and
      associate a style with them appropriately.  The default template was changed
      to prevent it from wrapping a div around these types of fields.
      </p>
      </li>
      <li>Fixed a problem with DATETIME fields on install
      <p>This solves a problem when on install the response table would sometimes not get created when using adodb lite</li>
      </li>
   </ul>
   </p>
</li>
<li>Version 0.2 - 14 November 2006. Calguy &amp; tsw&#039;s bug fixes for field re-ordering and custom templates. Additional bug fixes for field labels.</li>
<li>Version 0.1 - 8 July 2006. Initial Release</li>
</ul>
';
$lang['utmz'] = '156861353.1215854861.352.64.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/|utmcmd=referral';
$lang['utma'] = '156861353.1344409053.1180802494.1217279900.1217356264.390';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353.1.10.1217356264';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/sv_SE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Formul&auml;rbyggaren (Form Builder)';
$lang['field_type_'] = 'F&auml;lttyp inte vald';
$lang['field_type_CatalogerItemsField'] = 'V&auml;lj en (eller fler) katalog object';
$lang['field_type_FieldsetEnd'] = '-Slut p&aring; gruppruta (fieldset)';
$lang['field_type_FieldsetStart'] = '-Start p&aring; gruppruta (fieldset)';
$lang['field_type_TextField'] = 'Inmatningsf&auml;lt (text input)';
$lang['field_type_TextFieldExpandable'] = 'Inmatningsf&auml;lt (flera)';
$lang['field_type_TextAreaField'] = 'Textruta (textarea)';
$lang['field_type_CheckboxField'] = 'Kryssruta (check box)';
$lang['field_type_CheckboxGroupField'] = 'Kryssrutegrupp (check box group)';
$lang['field_type_PulldownField'] = 'Rullgardinsmeny';
$lang['field_type_MultiselectField'] = 'Multiv&auml;ljare';
$lang['field_type_StatePickerField'] = 'V&auml;ljare f&ouml;r amerikansk stat';
$lang['field_type_ProvincePickerField'] = 'Canadian Province Picker';
$lang['field_type_CountryPickerField'] = 'Landv&auml;ljare';
$lang['field_type_DatePickerField'] = 'Datumv&auml;ljare';
$lang['field_type_TimePickerField'] = 'Tidv&auml;ljare';
$lang['field_type_RadioGroupField'] = 'Alternativknappgrupp';
$lang['field_type_DispositionDirector'] = '*E-posta resultat baserade p&aring; val i rullgardinsmeny';
$lang['field_type_DispositionFileDirector'] = '*Spara resultat till fil baserade p&aring; val i rullgardinsmeny';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Spara resultat till fil(er) baserade p&aring; flera val';
$lang['field_type_DispositionPageRedirector'] = '*Omdirigera till sida baserat p&aring; val i rullgardinsmeny';
$lang['field_type_DispositionEmail'] = '*E-posta resultatet till best&auml;md adress/best&auml;mda adresser';
$lang['field_type_DispositionEmailConfirmation'] = '*Adress f&ouml;r verifiera-via-epost';
$lang['field_type_DispositionFromEmailAddressField'] = 'E-postf&auml;lt f&ouml;r &quot;Fr&aring;n-adressen&quot;, och skicka en kopia';
$lang['field_type_DispositionFile'] = '*Skriv resultat till vanlig fil';
$lang['field_type_DispositionDatabase'] = '*Spara resultat i databas';
$lang['field_type_DispositionFormBrowser'] = '*Spara resultatet f&ouml;r FormBrowser Module v.3';
$lang['field_type_DispositionUserTag'] = '*Anrop till en anv&auml;ndardefinierad tagg med formul&auml;rresultat';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*E-posta till en av anv&auml;ndaren angiven e-postadress';
$lang['field_type_DispositionEmailSiteAdmin'] = '*E-posta till CMS Admin User';
$lang['field_type_PageBreakField'] = '-Sidbrytning';
$lang['field_type_FileUploadField'] = 'Filuppladdning';
$lang['field_type_FromEmailAddressField'] = 'E-postf&auml;lt f&ouml;r &quot;Fr&aring;n-adressen&quot;';
$lang['field_type_FromEmailAddressAgainField'] = 'E-postf&auml;lt f&ouml;r &quot;Fr&aring;n-adressen&quot; igen f&auml;lt';
$lang['field_type_FromEmailNameField'] = 'E-postf&auml;lt f&ouml;r &quot;Fr&aring;n-namnet&quot;';
$lang['field_type_FromEmailSubjectField'] = 'E-postf&auml;lt f&ouml;r &quot;&Auml;mne&quot;';
$lang['field_type_StaticTextField'] = '-Statisk text';
$lang['field_type_SystemLinkField'] = '-Statisk l&auml;nk';
$lang['field_type_LinkField'] = 'L&auml;nk (anv&auml;ndarcentrerad)';
$lang['field_type_HiddenField'] = '-g&ouml;mt f&auml;lt';
$lang['field_type_ComputedField'] = '-ber&auml;knat f&auml;lt';
$lang['field_type_UniqueIntegerField'] = '-Unique Integer (Serial)';
$lang['validation_none'] = 'Ingen verifiering';
$lang['validation_numeric'] = 'Numerisk';
$lang['validation_integer'] = 'Heltal';
$lang['validation_email_address'] = 'E-postadress';
$lang['validation_usphone'] = 'Telefonnummer (US)';
$lang['validation_must_check'] = 'M&aring;ste vara ikryssad';
$lang['validation_regex_match'] = 'Matcha regulj&auml;ruttryck';
$lang['validation_regex_nomatch'] = 'Matcha inte regulj&auml;ruttryck';
$lang['required_field_missing'] = 'Inget v&auml;rde angavs f&ouml;r ett f&auml;lt som &auml;r obligatoriskt';
$lang['please_enter_a_value'] = 'Ange ett v&auml;rde f&ouml;r &quot;%s&quot;';
$lang['please_enter_a_number'] = 'Ange ett tal f&ouml;r &quot;%s&quot;';
$lang['please_enter_valid'] = 'Ange ett giltigt v&auml;rde f&ouml;r &quot;%s&quot;';
$lang['please_enter_an_integer'] = 'Ange ett heltalsv&auml;rde f&ouml;r &quot;%s&quot;';
$lang['please_enter_an_email'] = 'Ange en giltig e-postadress f&ouml;r &quot;%s&quot;';
$lang['email_address_does_not_match'] = 'E-postadressen matchar inte v&auml;rdet i &quot;%s&quot;';
$lang['please_enter_a_phone'] = 'V&auml;nligen fyll i ett godk&auml;nt telefonnummer &quot;%s&quot;';
$lang['not_valid_email'] = '&quot;%s&quot; verkar inte vara en giltig e-postadress!';
$lang['please_enter_no_longer'] = 'Ange ett v&auml;rde som inte &auml;r l&auml;ngre &auml;n %s tecken';
$lang['title_list_delimiter'] = 'Tecken att anv&auml;nda som avgr&auml;nsare i resultat som returnerar mer &auml;n ett v&auml;rde';
$lang['you_need_permission'] = 'Du beh&ouml;ver r&auml;ttigheten &quot;%s&quot; f&ouml;r att utf&ouml;ra den &aring;tg&auml;rden.';
$lang['lackpermission'] = 'Tyv&auml;rr! Du har inte tillr&auml;ckliga r&auml;ttigheter f&ouml;r att komma &aring;t den h&auml;r sektionen.';
$lang['field_order_updated'] = 'F&auml;ltordningen uppdaterad.';
$lang['form_deleted'] = 'Formul&auml;r borttaget.';
$lang['field_deleted'] = 'F&auml;lt borttaget.';
$lang['configuration_updated'] = 'Konfiguration uppdaterad.';
$lang['you_must_check'] = 'Du m&aring;ste kryssa i &quot;%s&quot; f&ouml;r att forts&auml;tta';
$lang['must_specify_one_destination'] = 'Du m&aring;ste ange &aring;tminstone en mottagaradress!';
$lang['are_you_sure_delete_form'] = '&Auml;r du s&auml;ker p&aring; att du vill ta bort formul&auml;ret %s?';
$lang['are_you_sure_delete_field'] = '&Auml;r du s&auml;ker p&aring; att du vill ta bort f&auml;ltet %s?';
$lang['notice_select_type'] = 'Avancerade inst&auml;llningar &auml;r inte tillg&auml;ngliga f&ouml;rr&auml;n f&auml;lttypen har angetts.';
$lang['field_name_in_use'] = 'F&auml;ltnamnet &quot;%s&quot; anv&auml;nds redan. V&auml;nligen anv&auml;nd unika f&auml;ltnamn eller avmarkera unika f&auml;ltnamn i konfigurationen f&ouml;r Formul&auml;rbyggaren.';
$lang['field_no_name'] = 'F&auml;lt m&aring;ste ha ett namn, s&aring;vida du inte avmarkerar detta i Formul&auml;rbyggarens konfiguration.';
$lang['anonymous'] = 'Anonym';
$lang['abbreviation_length'] = 'L&auml;ngd: %s';
$lang['boxes'] = '%s rutor';
$lang['options'] = '%s val';
$lang['text_length'] = '% tecken.';
$lang['order'] = 'Ordning';
$lang['unspecified'] = '[ospecificerat}';
$lang['added'] = 'tillagd';
$lang['updated'] = 'uppdaterad';
$lang['sort_options'] = 'Sorteringsval vid output/utmatning';
$lang['select_one'] = 'V&auml;lj En';
$lang['select_type'] = 'V&auml;lj Typ';
$lang['to'] = 'Till';
$lang['yes'] = 'Ja';
$lang['no'] = 'Nej';
$lang['recipients'] = 'mottagare';
$lang['file_count'] = '%s m&ouml;jliga filer';
$lang['destination_count'] = '%s destinationer';
$lang['save'] = 'Spara';
$lang['add'] = 'L&auml;gg till';
$lang['update'] = 'Uppdatera';
$lang['save_and_continue'] = 'Spara och forts&auml;tt redigera';
$lang['information'] = 'Information';
$lang['automatic'] = 'Automatisk';
$lang['forms'] = 'Formul&auml;r';
$lang['form'] = 'Formul&auml;r %s';
$lang['configuration'] = 'Konfiguration';
$lang['field_requirement_updated'] = 'Status f&ouml;r obligatoriskt f&auml;lt uppdaterad';
$lang['maximum_size'] = 'Maxstorlek';
$lang['permitted_extensions'] = 'Fil&auml;ndelser';
$lang['permitted_filetypes'] = 'Till&aring;tna filtyper';
$lang['file_too_large'] = 'Den uppladdade filen &ouml;r f&ouml;r stor! Maximal storlek &auml;r:';
$lang['illegal_file_type'] = 'Den h&auml;r filtypen kan inte laddas upp. Kontrollera att fil&auml;ndelsen &auml;r korrekt.';
$lang['upload'] = 'Ladda upp';
$lang['form_imported'] = 'Formul&auml;r importerat.';
$lang['form_import_failed'] = 'Import av formul&auml;r misslyckades! Det var problem med XML-filens format.';
$lang['rows'] = '%s rader';
$lang['cols'] = '%s kolumner';
$lang['12_hour'] = '12-timmarsklocka';
$lang['24_hour'] = '24-timmarsklocka';
$lang['hour'] = 'Timme';
$lang['min'] = 'Minut';
$lang['merid'] = 'Meridian';
$lang['date_range'] = 'R&auml;ckvidd: %s - %s';
$lang['thanks'] = 'Tack! Ditt formul&auml;r har skickats.';
$lang['edit'] = 'Redigera';
$lang['delete'] = 'Ta bort';
$lang['day'] = 'Dag';
$lang['mon'] = 'M&aring;nad';
$lang['year'] = '&Aring;r';
$lang['none'] = '(ingen)';
$lang['uninstalled'] = 'Modulen avinstallerad.';
$lang['installed'] = 'Modulversion %s installerad.';
$lang['upgraded'] = 'Modulen uppgraderad till version %s.';
$lang['button_previous'] = 'Tillbaka...';
$lang['button_submit'] = 'Skicka formul&auml;r';
$lang['button_continue'] = 'Forts&auml;tt...';
$lang['value_checked'] = 'Ikryssad';
$lang['value_unchecked'] = 'Ej ikryssad';
$lang['tab_main'] = 'Huvud-';
$lang['tab_symbol'] = 'Inst&auml;llningar f&ouml;r formul&auml;rvisning';
$lang['tab_submit'] = 'Skickat formul&auml;r';
$lang['tab_captcha'] = 'Inst&auml;llningar f&ouml;r Captcha';
$lang['tab_advanced'] = 'Avancerade inst&auml;llningar';
$lang['tab_templatelayout'] = 'Formul&auml;rmall';
$lang['tab_submissiontemplate'] = 'Skicka-mall';
$lang['canuse_smarty'] = '<em>Smarty-variabler &auml;r inte till&aring;tna i det h&auml;r f&auml;ltet.</em>';
$lang['add_options'] = 'L&auml;gg till fler val';
$lang['delete_options'] = 'Ta bort markerade val';
$lang['add_checkboxes'] = 'L&auml;gg till fler kryssrutor';
$lang['delete_checkboxes'] = 'Ta bort markerade kryssrutor';
$lang['add_address'] = 'L&auml;gg till en adress';
$lang['delete_address'] = 'Ta bort markerade adresser';
$lang['add_destination'] = 'L&auml;gg till mottagare';
$lang['delete_destination'] = 'Ta bort markerade mottagare';
$lang['suspected_spam'] = 'F&ouml;r m&aring;nga e-postmeddelanden genererades fr&aring;n din IP-adress. Anti-skr&auml;ppost-kod har f&ouml;rhindrat att de levererats.';
$lang['suspected_spam_log'] = 'Misst&auml;nkt skr&auml;ppost fr&aring;n IP-adressen %s stoppades.';
$lang['reorder'] = '&Auml;ndra f&auml;ltordning';
$lang['cancel'] = '&Aring;ngra';
$lang['value_set'] = 'Value set: %s';
$lang['help_cataloger_attribute_fields'] = 'Below is a list of the attributes available from the Cataloger module.<br/>You can optionally specify valid ranges, values, or numerous values to be used in filtering the list of items that is displayed to the user.<br/>
<br/>
<strong>Ranges:</strong><br/>
Ranges can be specified by signifying a minimum and maximum value using this syntax: &quot;range: minvalue to maxvalue&quot;<br/>
<br/>
<strong>Multiple Values:</strong><br/>
To specify multiple values for an attribute use the syntax &quot;multi: value1|value2|value3&quot;<br/>
<br/>
<strong>Values from hidden fields</strong><br/>
To specify a value from a hidden field use the syntax {$fld_id}<br/>
<br/>';
$lang['help_name_regex'] = 'A regular expression to allow filtering cataloger items by name';
$lang['help_field_height'] = 'The height of the multiselect field';
$lang['title_name_regex'] = 'Cataloger Item Name Regular Expression';
$lang['title_field_height'] = 'F&auml;ltets h&ouml;jd';
$lang['title_file_path'] = 'M&aring;lmapp f&ouml;r filer';
$lang['title_udt_name'] = 'Anv&auml;ndardefinierad tagg';
$lang['title_uploads_destpage'] = 'Sida att &aring;terv&auml;nda till med uppladdningsl&auml;nk';
$lang['title_uploadmodule_summary'] = 'Skickat med formul&auml;rbyggaren';
$lang['title_uploads_category'] = 'Uppladdningskategori';
$lang['title_sendto_uploads'] = 'Skicka denna fil till uppladdningsmodulen.';
$lang['title_legend'] = 'F&ouml;rklaring';
$lang['title_maximum_length'] = 'Maxl&auml;ngd';
$lang['title_checkbox_label'] = 'Etikett f&ouml;r kryssryta';
$lang['title_radio_label'] = 'Etikett f&ouml;r alternativknapp';
$lang['title_checked_value'] = 'V&auml;rde om ikryssad';
$lang['title_unchecked_value'] = 'V&auml;rde om ej ikryssad';
$lang['title_checkbox_details'] = 'Detaljer f&ouml;r kryssrutegrupp';
$lang['title_delete'] = 'Ta bort?';
$lang['title_select_one_message'] = 'Text f&ouml;r &quot;V&auml;lj En&quot;';
$lang['title_selection_value'] = 'V&auml;rde f&ouml;r urval';
$lang['title_selection_displayname'] = 'Namn f&ouml;r urvalsvisning';
$lang['title_selection_subject'] = '&Auml;mne f&ouml;r urval';
$lang['title_select_default_country'] = 'Standardurval';
$lang['title_select_default_state'] = 'Standardurval';
$lang['title_select_default_province'] = 'Standardurval';
$lang['title_option_name'] = 'Namn f&ouml;r alternativ';
$lang['title_option_value'] = 'V&auml;rdet skickat';
$lang['title_pulldown_details'] = 'Alternativ i rullgardinsmeny';
$lang['title_multiselect_details'] = 'Multival-alternativ';
$lang['title_destination_address'] = 'Mottagarens e-postadress';
$lang['title_destination_filename'] = 'Namn p&aring; m&aring;lfil';
$lang['title_email_from_name'] = '&quot;Fr&aring;n-namn&quot; f&ouml;r e-post';
$lang['title_relaxed_email_regex'] = 'Anv&auml;nd enkel e-postverifiering';
$lang['title_relaxed_regex_long'] = 'Anv&auml;nd enkel e-postadressverifiering (t.ex. till&aring;t &quot;x@y&quot; ist&auml;llet f&ouml;r att kr&auml;va &quot;x@y.se&quot;)';
$lang['title_email_from_address'] = '&quot;Fr&aring;n-adress&quot; f&ouml;r e-post';
$lang['title_email_encoding'] = 'E-postteckenkodning';
$lang['title_director_details'] = 'Rullgardinsmenybaserade e-postdetaljer';
$lang['title_file_name'] = 'Filnamn';
$lang['title_email_subject'] = '&Auml;mnesrad f&ouml;r e-post';
$lang['title_form_name'] = 'Formul&auml;rnamn';
$lang['title_form_status'] = 'Formul&auml;rstatus';
$lang['title_ready_for_deployment'] = 'F&auml;rdig att anv&auml;ndas';
$lang['title_not_ready1'] = 'Ej f&auml;rdig';
$lang['title_redirect_page'] = 'Sida att omdirigera till efter att formul&auml;ret skickats';
$lang['title_not_ready2'] = 'V&auml;nliga l&auml;gg till ett f&auml;lt till formul&auml;ret s&aring; att anv&auml;ndarens inmatning kan hanteras. Du kan';
$lang['title_not_ready_link'] = 'anv&auml;nd denna genv&auml;gen';
$lang['title_form_alias'] = 'Alias f&ouml;r formul&auml;r';
$lang['title_form_fields'] = 'Formul&auml;rf&auml;lt';
$lang['title_field_id'] = 'F&auml;lt-ID';
$lang['title_show_fieldaliases'] = 'Visa f&auml;ltens alias';
$lang['title_show_fieldaliases_long'] = 'Clicking this will display field aliases when adding or editing a form';
$lang['title_field_name'] = 'F&auml;ltnamn';
$lang['title_field_alias'] = 'F&auml;ltalias';
$lang['title_radiogroup_details'] = 'Detaljer f&ouml;r alternativknappgrupp';
$lang['title_field_type'] = 'F&auml;lttyp';
$lang['title_not_ready3'] = 'f&ouml;r att skapa ett formul&auml;rhanteringsf&auml;lt';
$lang['title_add_new_form'] = 'L&auml;gg till nytt formul&auml;r';
$lang['title_show_version'] = 'Visa Formul&auml;rbyggarens version?';
$lang['title_show_version_long'] = 'Detta kommer att l&auml;gga till versionsnumret f&ouml;r den version av Formul&auml;rbyggarmodulen som du har installerad i en kommentar, f&ouml;r att hj&auml;lpa till med fels&ouml;kning.';
$lang['title_add_new_field'] = 'L&auml;gg till nytt f&auml;lt';
$lang['title_form_submit_button'] = 'Text f&ouml;r formul&auml;rets skicka-knapp';
$lang['title_submit_button_safety'] = 'L&auml;gga till Javascript f&ouml;r den sista skicka-knappen f&ouml;r att f&ouml;rhindra att formul&auml;ret skickas flera g&aring;nger?';
$lang['title_submit_button_safety_help'] = 'L&auml;gg till s&auml;kerhetsscript';
$lang['title_form_next_button'] = 'Text f&ouml;r &quot;N&auml;sta-knappen&quot; i formul&auml;ret (anv&auml;nds f&ouml;r formul&auml;r med flera sidor)';
$lang['title_form_prev_button'] = 'Text f&ouml;r &quot;F&ouml;reg&aring;ende-knappen&quot; i formul&auml;ret (anv&auml;nds f&ouml;r formul&auml;r med flera sidor)';
$lang['title_field_validation'] = 'F&auml;ltverifiering';
$lang['title_field_to_validate'] = 'F&auml;lt f&ouml;r validering';
$lang['title_form_css_class'] = 'CSS-klass f&ouml;r detta formul&auml;r';
$lang['title_field_css_class'] = 'CSS-klass f&ouml;r detta f&auml;lt';
$lang['title_form_required_symbol'] = 'Symbol f&ouml;r att markera obligatoriska f&auml;lt';
$lang['title_field_required'] = 'Obligatoriskt';
$lang['title_field_required_long'] = 'G&ouml;r detta f&auml;lt obligatoriskt';
$lang['title_hide_label'] = 'G&ouml;m etikett';
$lang['title_hide_label_long'] = 'G&ouml;m detta f&auml;lts namn p&aring; formul&auml;ret';
$lang['title_text'] = 'Statisk text att visa';
$lang['title_field_regex'] = 'Regulj&auml;ruttryck f&ouml;r verifiering';
$lang['title_lines_to_show'] = 'Antal rader att visa';
$lang['no_default'] = 'Inget standardval';
$lang['redirect_after_approval'] = 'Sida att omdirigera till efter godk&auml;nnande';
$lang['title_regex_help'] = 'Detta regulj&auml;ruttryck anv&auml;nds bara om &quot;verifieringstypen&quot; &auml;r satt till ett regulj&auml;ruttryck-relaterat alternativ. Inkludera ett fullt regulj&auml;ruttryck i Perl-stil, inklusive start/stop-snedstrecken och -flaggorna (t.ex. &quot;/image\.(\d+)/i&quot;)';
$lang['title_field_required_abbrev'] = 'Oblig.';
$lang['title_hide_errors'] = 'G&ouml;m fel';
$lang['title_form_displaytype'] = 'Formul&auml;rvisningstyp';
$lang['title_hide_errors_long'] = 'F&ouml;rhindra fels&ouml;knings- och felmeddelanden fr&aring;n att visas f&ouml;r andra anv&auml;ndare.';
$lang['title_email_template'] = 'E-postmall';
$lang['title_maximum_size'] = 'Maximal filstorlek f&ouml;r uppladdning (kilobyte)';
$lang['title_maximum_size_long'] = 'Denna begr&auml;nsning &auml;r ut&ouml;ver andra begr&auml;nsningar som &auml;r satta av php- eller webbserverinst&auml;llningar.';
$lang['title_permitted_extensions'] = 'Till&aring;tna fil&auml;ndelser';
$lang['title_permitted_extensions_long'] = 'Skriv en komma-separarad lista, utan punkt (t.ex. &quot;jpg,gif,jpeg&quot;). Mellanslag ignoreras. Om du l&auml;mnar detta f&auml;ltet blankt inneb&auml;r det att det inte kommer att finnas n&aring;gra restriktioner.';
$lang['title_show_limitations'] = 'Visa restriktioner?';
$lang['title_show_limitations_long'] = 'Visa alla storleks- och fil&auml;ndelserestriktioner f&ouml;r uppladdningsf&auml;ltet?';
$lang['title_form_template'] = 'Mall att anv&auml;nda f&ouml;r Visa Formul&auml;r';
$lang['title_page_x_of_y'] = 'Sida %s av %s';
$lang['title_no_advanced_options'] = 'F&auml;ltet har inga avancerade inst&auml;llningar';
$lang['title_form_unspecified'] = 'Text att returnera f&ouml;r ospecificerade f&auml;ltv&auml;rden';
$lang['title_enable_fastadd_long'] = 'M&ouml;jligg&ouml;r rullgardinsmeny f&ouml;r snabb-till&auml;gg avl f&auml;lt f&ouml;r formul&auml;r?';
$lang['title_enable_fastadd'] = 'M&ouml;jligg&ouml;r rullgardinsmeny f&ouml;r snabb-till&auml;gg?';
$lang['title_fastadd'] = 'Snabb-till&auml;gg av f&auml;lt';
$lang['title_enable_antispam_long'] = 'N&auml;r denna klickas p&aring; till&aring;ts endast 10 e-postmeddelanden att genereras fr&aring;n en given IP-adress (per timme)';
$lang['title_enable_antispam'] = 'Till&aring;t primitiva anti-skr&auml;ppostegenskaper?';
$lang['title_show_fieldids'] = 'Visa f&auml;lt-ID&#039;n';
$lang['title_show_fieldids_long'] = 'N&auml;r denna klickas till&aring;ts f&auml;lt-ID&#039;n att visas n&auml;r man l&auml;gger till eller redigerar ett formul&auml;r';
$lang['title_xml_to_upload'] = 'Ladda upp formul&auml;r fr&aring;n XML-fil';
$lang['title_xml_upload_formname'] = 'Anv&auml;nd detta formul&auml;rnamn';
$lang['title_import_legend'] = 'XML-import av formul&auml;r';
$lang['title_xml_upload_formalias'] = 'Anv&auml;nd detta formul&auml;ralias';
$lang['title_html_email'] = 'Generera HTML-epostmeddelanden?';
$lang['title_link_autopopulate'] = 'Fyll i automatiskt?';
$lang['title_link_autopopulate_help'] = 'Fyll i URL-adress f&ouml;r sidan d&auml;r formul&auml;ret finns automatiskt? (detta &aring;sidos&auml;tter alternativet sajtsidel&auml;nk nedan)';
$lang['title_default_link'] = 'Standard-URL-adress f&ouml;r l&auml;nk';
$lang['title_default_link_title'] = 'Standardtext f&ouml;r l&auml;nk';
$lang['title_link_to_sitepage'] = 'L&auml;nk till sajt-sidan';
$lang['title_captcha_not_installed'] = 'You can use <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a> to protect form submissions if you install the Captcha module. For more information, <a href="http://dev.cmsmadesimple.org/projects/captcha/">check the Captcha project</a>.';
$lang['title_use_captcha'] = 'Anv&auml;nd Captcha f&ouml;r att f&ouml;rebygga o&ouml;nskat formul&auml;rdata?';
$lang['title_use_captcha_help'] = 'Check here to protect your form with a <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a>.';
$lang['title_user_captcha'] = 'Bekr&auml;fta att du inte &auml;r ett script genom att mata in texten i bilden';
$lang['title_user_captcha_error'] = 'Captcha-texten misslyckades';
$lang['wrong_captcha'] = 'Captcha-texten var inte r&auml;tt';
$lang['title_title_user_captcha'] = 'Hj&auml;lptext f&ouml;r Captcha';
$lang['title_dont_submit_unchecked'] = 'Don&#039;t submit values for unchecked boxes';
$lang['title_dont_submit_unchecked_help'] = 'Check this if you only want checked boxes to return values.';
$lang['link_label'] = 'L&auml;nktetikett';
$lang['link_destination'] = 'URL';
$lang['title_default_set'] = 'Kontrolleras som standard?';
$lang['title_24_hour'] = 'Anv&auml;nd 24-timmars tidsangivelse?';
$lang['title_before_noon'] = 'AM';
$lang['title_after_noon'] = 'PM';
$lang['title_smarty_eval'] = 'Behandla smarty-tag:ar i f&auml;lt?';
$lang['title_textarea_rows'] = 'Rader (Notera att detta kan &ouml;verskridas av CSS)';
$lang['title_textarea_cols'] = 'Kolumner (Notera att detta kan &ouml;verskridas av CSS)';
$lang['title_form_main'] = 'Detaljer f&ouml;r huvudformul&auml;r';
$lang['title_show_username'] = 'Display User&#039;s login name?';
$lang['title_show_userfirstname'] = 'Display User&#039;s first name?';
$lang['title_show_userlastname'] = 'Display User&#039;s last name?';
$lang['title_restrict_to_group'] = 'Restrict user list to users in specified group';
$lang['restricted_to_group'] = 'Only in group %s';
$lang['title_show_to_user'] = 'Display to user?';
$lang['help_leaveempty'] = 'Det h&auml;r f&auml;ltet kan l&auml;mnas tomt';
$lang['help_variables_for_template'] = 'Variabler f&ouml;r mall';
$lang['help_variables_for_computation'] = 'Tillg&auml;ngliga variabler';
$lang['help_php_variable_name'] = 'PHP-variabel';
$lang['help_submission_date'] = 'Inskickat datum';
$lang['help_server_name'] = 'Din server';
$lang['help_sub_source_ip'] = 'IP-adress f&ouml;r personen som anv&auml;nt formul&auml;ret';
$lang['help_sub_url'] = 'URL f&ouml;r sidan som inneh&aring;ller formul&auml;r';
$lang['help_fb_version'] = 'FormBuilder version';
$lang['help_tab'] = 'Tab Character';
$lang['help_other_fields'] = 'Alternativa f&auml;ltnamn kan anv&auml;ndas utbytbart (s&auml;rskilt anv&auml;ndbart om Smarty inte gillar tecken utanf&ouml;r ASCII 32-126) <br />Andra f&auml;lt blir tillg&auml;ngliga efterhand som du l&auml;gger till dem till formul&auml;ret.';
$lang['help_array_fields'] = 'F&auml;lt som har flera v&auml;rden kan ocks&aring; kommas &aring;t via smartyv&auml;rdena $fieldname_array eller $fld_#_array.';
$lang['help_date_format'] = 'Se <a href="http://www.php.net/manual/en/function.date.php" target=_NEW>php-manualen</a> f&ouml;r hj&auml;lp med formattering..';
$lang['help_variable_name'] = 'Variabel';
$lang['help_form_field'] = 'Representerade f&auml;lt';
$lang['link_back_to_form'] = '&laquo; Tillbaka till formul&auml;r';
$lang['title_create_sample_template'] = 'Skapa provmall';
$lang['title_create_sample_html_template'] = 'Skapa provmall f&ouml;r HTML';
$lang['title_create_sample_header_template'] = 'Create Sample Header Template';
$lang['title_create_sample_header'] = 'Skapa rubrik (header)';
$lang['help_tab_symbol'] = 'ett tabulator-tecken';
$lang['title_file_template'] = 'Mall f&ouml;r en rad i utdatafil';
$lang['title_file_header'] = 'Mall f&ouml;r huvud p&aring; utfil';
$lang['title_confirmation_url'] = 'URL att klicka f&ouml;r formul&auml;rbekr&auml;ftelse';
$lang['title_value'] = 'V&auml;rde (se fliken Avancerat om du anv&auml;nder Smarty-tagar)';
$lang['title_date_format'] = 'Datumformat (vanliga<a href="http://www.php.net/manual/en/function.date.php">php-datumformat</a>)';
$lang['title_use_wysiwyg'] = 'Anv&auml;nd WYSIWYG-redigerare f&ouml;r textrutan (enbart adminsidan)?';
$lang['title_submit_actions'] = 'Form Submission Behavior';
$lang['title_submit_labels'] = 'Submission Button Labels';
$lang['title_sortable_field'] = 'Sortable Field #%s';
$lang['title_submit_help'] = 'This page lets you customize Form Submission. It doesn&#039;t determine what the Form Builder does with the submitted data. You can set that up by adding &quot;Disposition&quot; fields to your form.';
$lang['title_start_year'] = 'Year range start';
$lang['title_end_year'] = 'Year range end';
$lang['title_default_year'] = 'Default Year';
$lang['title_default_year_help'] = '(Set to -1 for default year to be the current year)';
$lang['title_submit_action'] = 'After form is submitted';
$lang['title_submit_response'] = 'Response to display';
$lang['display_text'] = 'Display &quot;Submission Template&quot;';
$lang['redirect_to_page'] = 'Redirect to site page';
$lang['title_submit_response_help'] = 'This template is for display to the user after the form is submitted. This template does not effect emails generated or other form dispositions -- you set those templates (where appropriate) in the &quot;advanced&quot; tab for those disposition fields.';
$lang['title_destination_page'] = 'Destinationssida';
$lang['title_require_fieldnames'] = 'Require Fieldnames';
$lang['title_require_fieldnames_long'] = 'Require fields to have a name?';
$lang['title_unique_fieldnames'] = 'Require Unique Fieldnames';
$lang['title_unique_fieldnames_long'] = 'Require fields to have unique names?';
$lang['title_reorder_form'] = 'Omgruppera f&auml;lt';
$lang['title_load_template'] = 'Ladda mall';
$lang['title_add_button_text'] = 'L&auml;tt';
$lang['title_del_button_text'] = 'Delete Button text';
$lang['title_string_or_number_eval'] = 'Interpret variables as being numbers or strings';
$lang['title_order'] = 'Interpretation Order';
$lang['title_order_help'] = 'If more than one Computed Field exists, they will be computed from lowest order number to highest order number';
$lang['title_compute_value'] = 'Value to compute';
$lang['title_string'] = 'Str&auml;ng';
$lang['title_numeric'] = 'Numerisk';
$lang['title_inline_form'] = 'Display form inline?';
$lang['title_inline_form_help'] = 'Inline means any form followup replaces the {cms_module} tag, non-inline replaces the {content} tag.';
$lang['title_field_default_value'] = 'Default value for field';
$lang['title_clear_default'] = 'Clear default on click?';
$lang['title_clear_default_help'] = 'Check this to clear the default value when the user clicks this field. Since this uses a javascript string compare, it will fail if you put single quotes in your default text. Other un-javascript-friendly characters may also cause it to fail.';
$lang['title_remove_file_from_server'] = 'Delete uploaded file from server after processing (email dispositions)';
$lang['title_field_javascript'] = 'Javascript for field';
$lang['title_field_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;';
$lang['title_submit_javascript'] = 'Form Submission Javascript';
$lang['title_submit_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, e.g., onclick=&quot;yourfn()&quot;.<br />This will probably not work well if you use the &quot;safety script&quot; option above.';
$lang['email_from_addr_help'] = 'Do not just pick a random address here -- many ISPs will<br />not deliver the mail if you are using a different domain name than your actual<br />host name (i.e., use something like name@%s)';
$lang['title_switch_advanced'] = 'Need more field types? ';
$lang['title_switch_basic'] = 'Too many confusing field types? ';
$lang['title_switch_advanced_link'] = 'Skifta till avancerat l&auml;ge';
$lang['title_switch_basic_link'] = 'Skifta till avancerat l&auml;ge';
$lang['title_file_root'] = 'Directory to save file in';
$lang['title_file_root_help'] = 'This needs to be a directory that your web server has permissions to write in.<br />Chmod it 777 if you have problems/doubts.<br />Also, check to see that you do not have PHP directory restrictions.';
$lang['title_newline_replacement'] = 'Newline/Carriage Return replacement character';
$lang['title_newline_replacement_help'] = 'Leave blank to allow newlines and carriage returns in output';
$lang['title_send_usercopy'] = 'Send User a Copy of Submission?';
$lang['title_send_usercopy_label'] = 'Label for Checkbox (if user choice)';
$lang['title_send_me_a_copy'] = 'Send me a copy of form';
$lang['option_never'] = 'Aldrig';
$lang['option_user_choice'] = 'Ge bes&ouml;karen ett val (checkbox)';
$lang['option_always'] = 'Alltid';
$lang['error_cataloger_module_not_available'] = '<strong>Cataloger modulen does not seem to be installed/active.</strong>';
$lang['warning'] = 'VARNING!';
$lang['default_template'] = 'F&ouml;rvald mall';
$lang['table_left_template'] = 'Tabellmall, titlar till v&auml;nster';
$lang['table_top_template'] = 'Tabellmall, titlar &ouml;ver f&auml;lt';
$lang['form_template_name'] = 'Mall fr&aring;n %s';
$lang['template_are_you_sure'] = 'Are you sure you want to overwrite your template with the selected template? (Even if you say OK, you will still need to save the change)';
$lang['title_bad_function'] = 'Error when computing &quot;%s&quot;.';
$lang['no_referrer_info'] = 'No HTTP_REFERER info available (probably due to use of User Email Validation)';
$lang['validation_param_error'] = 'Validation Parameter Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_response_error'] = 'Validation Repsonse Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_no_field_error'] = 'Validation Repsonse Error. No email validation field in this form!';
$lang['upgrade03to04'] = 'Form Template was updated automatically as part of the version 0.3 to version 0.4 upgrade. You may need to make some fixes. If you&#039;re using the default form, simply replace this template with &quot;default&quot; using the pulldown above.';
$lang['admindesc'] = 'Add, edit and manage interactive Forms';
$lang['operators_help'] = 'If you use String evaluation, the only operation available is concatenation (+), while if you use Number evaluation you have basic, very simple math (, +, -, *, /, ).';
$lang['date_january'] = 'Januari';
$lang['date_february'] = 'Februari';
$lang['date_march'] = 'Mars';
$lang['date_april'] = 'April';
$lang['date_may'] = 'Maj';
$lang['date_june'] = 'Juni';
$lang['date_july'] = 'Juli';
$lang['date_august'] = 'Augusti';
$lang['date_september'] = 'September';
$lang['date_october'] = 'Oktober';
$lang['date_november'] = 'November';
$lang['date_december'] = 'December';
$lang['submission_error'] = 'Ledsen! Det uppstod ett fel d&aring; ditt formul&auml;r hanterades';
$lang['submit_error'] = 'FormBuilder submit error: %s';
$lang['uploads_error'] = 'Error committing file to the uploads module: %s';
$lang['nouploads_error'] = 'Kunde inte hitta modulen Uploads';
$lang['upload_attach_error'] = 'Upload/Attachment error on file %s (tmp_name: %s, of type %s)';
$lang['submission_error_file_lock'] = 'Ett fel har uppst&aring;tt! Kunde inte ordna l&aring;sning p&aring; filen.';
$lang['unchecked_by_default'] = 'Default: unchecked';
$lang['checked_by_default'] = 'Default: checked';
$lang['email_default_template'] = 'FormBuilder Submission';
$lang['email_template_not_set'] = '<br/>Email Template not yet set!';
$lang['missing_cms_mailer'] = 'FormBuilder: Cannot find required module CMSMailer!';
$lang['user_approved_submission'] = 'User approved submission %s from %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Event triggered when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Event triggered if there is an error when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Event triggered when a FormBuilder form is displayed';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Event triggered when a FormBuilder form is submitted.</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>value_<name></em> - Supply a default value to a field with the specified name.</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Event triggered if there is an error when a FormBuilder form is submitted</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
<li><em>error</em> - A list of all known errors (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Event triggered when a FormBuilder form is displayed</p>
<h4>Parameters</h4>
<ul>
<li><em>form_name</em> - The form name (string)</li>
<li><em>form_id</em> - The internal form id (int)</li>
</ul> ';
$lang['formbuilder_params_response_id'] = 'ResponsID. Anv&auml;nds av FormBrowser';
$lang['formbuilder_params_passed_from_tag'] = 'F&ouml;rvalda f&auml;ltv&auml;rden; se hj&auml;lpen f&ouml;r den h&auml;r modulen';
$lang['formbuilder_params_field_id'] = 'F&auml;ltID f&ouml;r intern hantering';
$lang['formbuilder_params_form_name'] = 'Formul&auml;rsnamn';
$lang['formbuilder_params_form_id'] = 'Formul&auml;rsID f&ouml;r intern hantering';
$lang['formbuilder_params_general'] = 'Allm&auml;na parametrar f&ouml;r intern hantering';
$lang['template_variable_help'] = '<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>
';
$lang['post_install'] = '<p>Make sure to set the &quot;Modify Forms&quot; permissions
on users who will be administering feedback forms. Also, if you&#039;ll be emailing form
results, be sure to update the Configuration appropriately.</p>
<p>Please be aware that a feedback form should not be active (e.g., usable by the public) while
you are still editing the form. You should create the form, and place the tag into an active
content page only when you have finished editing. Otherwise, erroneous results could be returned.</p>
<p>Additionally, this version does not support parallel editing of forms. Please take care that
only one admin is editing a given form at a given time.</p>';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create feedback forms (in fact, it&#039;s a replacement of the original Feedback Form module), with the added power of database storage. With its companion module Form Browser, you can use it to create simple database applications.</p>
<p>The forms created using the Form Builder may be inserted
into templates and/or content pages. Forms may contain many kinds of inputs, and may have
validation applied to these inputs. The results of these forms may be handled in a variety of ways.</p>

<h3>How Do I Use it?</h3>
<P>Install it, and poke around the menus. Play with it. Try creating forms, and adding them to your content.
If you get stuck, chat with me on the #cms IRC channel, post to the forum, send me email, or, if you&#039;re
really desperate, read the rest of this page.</P>

<h3>How Do I Create a Form</h3>
<p>In the CMS Admin Menu, you should get a new menu item called FormBuilder. Click on this. On the page
that gets shown, there are options (at the bottom of the list of Forms) to Add a New Form or Modify
Configuration.</p>

<h3>Adding a Form to a Page</h3>
<p>In the main FormBuilder admin page, you can see an example of the tag used to display each form. It looks
something like {cms_module module=&#039;FormBuilder&#039; form=&#039;sample_form&#039;}</p>
<p>By copying this tag into the content of a page, or into a template, will cause that form to be displayed.
In theory, you can have multiple forms on a page if you really want to. Be careful when pasting the tag
into a page&#039;s content if you use a WYSIWYG editor such as TinyMCE, FCKEdit, or HTMLArea. These editors may stealthily
change the quote marks (&quot;) into HTML entities (&amp;quot;), and the forms will not show up. Try using
single quotes (&#039;) or editing the HTML directly.</p>

<h3>Working with Forms</h3>
<p>By clicking on a Form&#039;s name, you enter the Form Edit page. There are several tabs, which are described below:</p>
<h4>Main</h4>
<p>This is the main place you&#039;ll work on your form. Here, you give it a name, an alias (which is used to identify it for placing it in a page or template), and, optionally, a CSS class with which to wrap the whole thing.</p>
<p>Below this, if you have it enabled, is the &quot;fast field adder&quot; pulldown, that lets you quickly add a field to the end of your form by selecting the field type.</p>
<p>Below this is the list of fields that make up your form. More detail on this is described below.</p>
<h4>Form Submission</h4>
<p>When the form is submitted, you can either redirect the user to another page of your site, or you can present the user some message (which can contain any of the user&#039;s form entries, or just static text). In this tab, you select which of these approaches you wish to use, and, if you chose redirection, it allows you to pick the page to redirect users to after a successful form submission.</p>
<p>Also on this page, you can specify the labels of various submission buttons (&quot;Previous&quot;, &quot;next&quot;, &quot;submit&quot;). You can also opt to have some Javascript added to the last page of a form that will prevent multiple submissions (useful on slow servers).</p>
<h4>Form Display Options</h4>
<p>This tab allows for other form customizations, like the symbol to show for required fields.</p>
<h4>Captcha Settings</h4>
<p>If you have installed the Captcha module, this tab lets you configure the Captcha settings for your form.</p>
<h4>Form Template</h4>
<p>This is where you do your customization work of your form&#039;s Smarty Template. See the section called Form Template Variables below.</p>
<p>The form should default to a Custom template that documents the Smarty tags available to you.</p>
<p>Unless you&#039;re a Smarty expert, you probably don&#039;t want to mess around with this. If you are a Smarty expert, this is where you can unleash your magic.</p>
<h4>Submission Template</h4>
<p>If, in the Form Submission tab, you selected &#039;Display &quot;Submission Template&quot;, this is where you can create that template. There is a display of which smarty variables are available to you, and a button to generate a sample template.</p>
<p>If you&#039;re a Smarty expert, you can do all manner of creative and powerful things here. If you&#039;re not a Smarty expert, you might just want to use the default.
</p>

<h3>Adding Fields to your Form</h3>
<p>The types of fields that are currently supported fit into four groups: standard input fields, display control fields, email-specific fields, and form result handling fields (also called Form Dispositions in places):</p>
<ul>
<li>Standard Input Fields - these are inputs that allow entry of typical form elements; text inputs, radio buttons, etc.</li>
<li>Display Control Fields - these input control how the user will see the display of the form; page breaks, static text, etc.</li>
<li>Email-specific Fields - some forms generate email, and email-specific fields can alter attributes of the emails sent.</li>
<li>Form Dispositions - These determine what happens when the user
submits the form; for each result handling field, some method of transmitting, saving, or emailing the
form contents takes place. A form may have multiple form dispositions.</li>
</ul>
<p>Form fields are assigned names. These names identify the field, not only on the screen as labels for the user,
but in the data when it&#039;s submitted so you know what the user is responding to. Phrasing the name like a question
is a handy way of making it clear to the user what is expected. Similarly, many fields have both Names and Values.
The Names are what gets shown to the user; the Value is what gets saved or transmitted when the user submits
the form. The Values are never seen by the user, nor are they visible in the HTML, so it&#039;s safe to use for
email addresses and such.</p>
<p>Some fields can have multiple values, or multiple name/value pairs. When you first create such a field,
there may not be sufficient inputs for you to specify all the values you want. To get more space for inputting
these values, use the buttons at the bottom of the page for adding options.</p>
<p>Fields can be assigned validation rules, which vary according to the type of the field. These rules help
ensure that the user enters valid data. They may also be
separately marked &quot;Required&quot;, which will force the user to enter a response.</p>
<p>Fields also may be assigned a CSS class. This simply wraps the input in a div with that class, so as to allow
customized layouts. To use this effectively, you may need to &quot;view source&quot; on the generated form, and then
write your CSS.</p>
<ul>
<li>Standard Inputs
<ul><li>Text Input. This is a standard text field. You can limit the length, and apply various validation
functions to the field.</li>
<li>Text Area. This is a big, free-form text input field.</li>
<li>Checkbox. This is a standard check box.</li>
<li>Checkbox Group. This is a collection of checkboxes. The only difference between this input and a
collection of Checkbox inputs is that they are presented as a group, with one name, and can have a validation function requiring that you check one or more of the boxes in the group.</li>
<li>Radio Group. This is a collection of radio buttons. Only one of the group may be selected by the user.</li>
<li>Pulldown. This is a standard pulldown menu. It&#039;s really conceptually the same thing as a radio button
group, but is better when there are a large number of options.</li>
<li>Multiselect. This is a multi-select field. It&#039;s really conceptually the same thing as a checkbox button
group, but is better when there are a large number of options, as you can limit the number displayed on the screen at any one time.</li>
<li>State. This is a pulldown listing the States of the U.S.</li>
<li>Countries. This is a pulldown listing the Countries of the world (as of July 2005).</li>
<li>Date Picker. This is a triple pulldown allowing the user to select a date.</li>
<li>Time Picker. This is a set of pulldowns allowing the user to select a time (using 12 or 24 hour clock).</li>
<li>File Upload. This is a file upload field.</li>
<li>Link (User Entered). This creates a double input field for getting a link URL and link title.</li>
<li>Text Field (Multiple). This field creates one or more text inputs with add and delete buttons, effectively giving the end user a way of creating variable-length lists.</li>
</ul></li>

<li>Email-specific Inputs
<ul><li>Email From Address Field. This allows users to provide their email address. The email generated when the form gets handled will use this address in the &quot;From&quot; field.</li>
<li>Email From Name Field. This allows users to provide their name. The email generated when the form gets handled will use this name in the &quot;From&quot; field.</li>
<li>Email Subject Field. This allows users to provide a subject for their email. The email generated when the form gets handled will use this in the &quot;Subject&quot; field. This may cause trouble with certain dispositions that want to control the Email Subject, so use it with caution.</li>
</ul></li>

<li>Display Control Fields<ul>
<li>-Page Break. This allows you to split your feedback form into multiple pages. Each page is
independently validated. This is good for applications like online surveys.</li>
<li>-Fieldset Start. Combined with Fieldset End, this allows you to group various fields within your form. Use this to start a given grouping.</li>
<li>-Fieldset End. Combined with Fieldset Start, this allows you to group various fields within your form. Use this to end a given grouping.</li>
<li>-Hidden Field. This allows you to embed a hidden field in your form.</li>
<li>-Static Text. This allows you to put text or a label in the middle of your form. This is useful for giving additional help text, especially if you&#039;re not using a Custom Template to render your form.</li>
<li>-Static Link. This allows you to put a link to a given page into your form. Optionally, you can have it autopopulate with the page where the form is embedded (useful if you\&#039;re sending results via email).</li>
<li>-Computed Field. This allows you to embed a computed field in your form. It is not visible to the user until after the form is submitted. It allows you to do simple arithmetic or string concatenation.</li>
</ul></li>

<li>Form Handling Inputs (Dispositions)
<ul><li>*Call a User Defined Tag With the Form Results. This submits all the form results to the User-Defined Tag you specify. The UDT can handle the results however it wants.</li>
<li>*Email Results Based on Pulldown. This is useful for web sites where comments get routed based on their subject matter, e.g., bugs get sent to one person, marketing questions to another person, sales requests to someone else, etc. The pulldown is populated with the subjects, and each gets directed to a specific email address. You set up these mappings in the when you create or edit a field of this type. If you use one of these &quot;Director&quot; pulldowns, the user must make a selection in order to submit the
form. This input is part of the form the user sees, although the email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email Results to set Address(es). This simply sends the form results to one or more email addresses that you enter when you create or edit this type of field. This field and its name are not visible in the
form that the user sees. The email addresses are not made visible nor
are they embedded in the HTML.</li>
<li>*Email to User-Supplied Address. This puts an input field in the form for the user to populate with an email address. The form results get sent to that address. Beware of Spam abuse! Active the primitive anti-spam features in the FormBuilder configuration screen.</li>
<li>*Store Results in Database. This will store the form contents in an internal database. You will always use this disposition if you use the form with FormBrowser.</li>
<li>*Redirect to Page Based on Pulldown. This allows you to redirect the form to a different site page depending on its value. If you have multiple dispositions, make sure this is used last.</li>
<li>*Validate via Email. This is a strange and powerful field. It provides the user a mandatory input for their email address. Once they submit their form, the standard form dispositions are not performed -- rather, it send the user an email with a special coded link. If they click on the link, the other form is considered &quot;approved,&quot; and the other dispositions are all performed.</li>
<li>*Write Results to Flat File. This takes the form results and writes them into a text file. You may
select the name of the file, and set its format. These files are written to the &quot;output&quot; directory under the
module&#039;s installation directory, assuming the web server has permission to write there.</li>
<li>*Save Results to File Based on Pulldown. Like the Flat File disposition, except the value of a pull-down determines which file results get written to.</li>
<li>*Save Results to File(s) Based on Multiple Selections. Like the Flat File disposition, except the value(s) of checkboxes  determines which file(s) results get written to.</li>
</ul></li></li></ul>


<h3>Passing Default Values to Forms</h3>
<p>Calguy added a nice feature, which is that you can pass default field values to your form via the module tag. This allows you to have
the same form in multiple places, but with different default values. It may not work for more exotic field types, but for fields that have
a single value, you can specify like:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_<i>FIELDNAME</i>=&#039;default_value&#039;}</p>
<p>This will set the field with <i>FIELDNAME</i> to &#039;default_value&#039;.</p>
<p>This can be problematic, as sometimes field names are unweildy or contain characters that don&#039;t work well with Smarty. So there is an
alternative like this:</p>
<p>{cms_module module=&#039;FormBuilder&#039; form=&#039;my_form&#039; value_fld<i>NUMBER</i>=&#039;default_value&#039;}</p>
<p>That uses field <i>NUMBER</i>, where <i>NUMBER</i> is the internal FormBuilder field id. You might wonder how you know what that id is. Simply go into the FormBuilder configuration tab,
and check &quot;Show Field IDs&quot;</p>

<h3>Email and Flat File Templates</h3>
<p>Many disposition types allow you to create a template for the email that is generated, or for the way the results are written to a file. If you opt not to create a template, the FormBuilder will use it&#039;s own best guess, which may or may not work out to your liking. You can always click on the &quot;Create Sample Template&quot; and then customize the results.</p>
<p>To the right, you&#039;ll find a legend which lists all of the variables that are available to you to use in your template. As of version 0.3, variables have two names, one based on the field name, the other based on the field ID. If you use field names that have characters outside of the ASCII 32-126 range, it will be safer to use the ID-based variables.</p>
<p><strong>Note that once you&#039;ve changed a template, it will no longer automatically add new fields.</strong> For this reason, it&#039;s usually best to create your templates as the last step of creating your form.</p>
<p>As of version 0.2.4, you can opt to send any of these emails as HTML email. There should be a checkbox at the top of the template page for this. There is also a &quot;Create Sample HTML Template&quot; button over in the legend area. For HTML email, the email body will also provide the default text-only values.</p>

<h3>Configuration</h3>
<p>There are some global configuration options for FormBuilder:</p>
<ul>
<li>Enable fast field add pulldown. This enables the pulldown on the Form Edit page which saves a step in the creation of new fields.</li>
<li>Hide Errors. This is set by default. Unchecking it will cause more detailed errors to be displayed if there are problems when you submit your form.</li>
<li>Require Field Names. Typically, you will want form fields to be named so you can tell which is which. However, in some cases, you might want to have nameless fields. Uncheck this if you want to allow nameless fields.</li>
<li>Unique Field Names. Typically, you will want form fields to have unique names so you can tell which is which. Uncheck this if you want to allow fields to share names.</li>
<li>Use relaxed email validation. This uses a less restrictive regular expression for validating email; e.g., x@y will be allowed, where typically x@y.tld is required.</li>
<li>Show Form Builder Version. Displays the version of FormBuilder you&#039;re using in a comment when the form is generated. Typically only useful when debugging.</li>
<li>Enable primitive anti-spam features. When turned on, this allows any given IP address to only generate 10 emails per hour.</li>
<li>Show Field IDs. When turned on, FormBuilder will display field ids when adding or editing a form.</li>
</ul>
<h3>Styling and CSS</h3>
<p>Paul Noone graciously provides us all with a pretty good standard CSS that you can use for forms:</p>
<pre>
	/* Sample FormBuilder CSS base */
	form {margin-top:0}
	form, td, th, li { font-size: 100%}
	form div {margin-bottom:0}
	fieldset div {
		margin-bottom:0.5em;
		margin-left:1em;
	}
	fieldset div div {
		margin-top:0.5em;
		margin-left:1em
	}
	fieldset {
		margin-bottom:1em;
		border:1px solid #F60;
		padding:0.5em
	}
	fieldset label {
		width:auto;
	}
	legend {
		color:#FFF;
		background:#F60;
		font-style:italic;
		font-size:1.2em;
		margin-bottom:0.5em;
		padding:0.2em;
		width:auto;
		border:1px solid #CCC
	}
	textarea {
		margin: 0.5em 0;
		width:98%;
		height: 6em
	}

	/* Apply this class to text/select input fields with shorter labels
		to help alignment */
	.short-label label {float:left; width:10em}
	.short-label fieldset div input,
	.short-label fieldset div select {width:16em}

	/* Pretty up your Captcha image output */
	.captcha {
		margin:0.5em 0;
		width:200px;
		text-align:center
	}
	.captcha img {border:1px solid #F60; margin-bottom:0.5em}
	.captcha input {width:196px; margin-top:0.5em}

	/* Just a bit more room for the Submit button */
	.submit {margin-top:0.5em}
</pre>

<h3>Form Template Variables</h3>

<h3>Form Template Variables</h3>
<p>You can edit it to make your form layout look any way you&#039;d like.
   To make the form work, you&#039;ll need to always include the {$fb_hidden} and {$submit}
   tags.</p>

<p>You can access your form fields either using the $fields array or by directly accessing fields by their names (e.g., {$myfield->input} )</p>


<p>Each field has the following attributes:</p>
<table>
<tr><th>Field</th><th>Value</th></tr>
<tr><td>field->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>field->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>field->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>field->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>field->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>field->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>field->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>field->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>field->needs_div</td><td>1 if the field needs to be wrapped in a DIV (or table row, if that&#039;s the way you swing)</td></tr>
<tr><td>field->name</td><td>the field&#039;s name</td></tr>
<tr><td>field->input</td><td>the field&#039;s input control (e.g., the input field itself)</td></tr>
<tr><td>field->op</td><td>a control button associated with the field if applicable (e.g., the delete button for expandable text input)</td></tr>
<tr><td>field->input_id</td><td>the ID of the field&#039;s input (useful for <label for=&quot;&quot;>)</td></tr>
<tr><td>field->type</td><td>the field&#039;s data type</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>field->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In certain cases, field->input is actually an array of objects rather than an input. This happens, for example, in CheckBoxGroups or RadioButtonGroups. For them, you can iterate through field->input->name and field->input->inputs.</p>
    
<p>Additional smarty variables that you can use include:</p>
<table>
<tr><th>Variable</th><th>Value</th></tr>
<tr><td>total_pages</td><td>number of pages for multi-page forms</td></tr>
<tr><td>this_page</td><td>number fo the current page for multi-page forms</td></tr>
<tr><td>title_page_x_of_y</td><td>displays &quot;page x of y&quot; for multi-page forms</td></tr>
<tr><td>css_class</td><td>CSS Class for the form</td></tr>
<tr><td>form_name</td><td>Form name</td></tr>
<tr><td>form_id</td><td>Form database ID</td></tr>
<tr><td>prev</td><td>&quot;Back&quot; button for multipart forms</td></tr>
<tr><td>submit</td><td>&quot;Continue&quot; or &quot;Submit&quot; button for multipart forms, adjusts automatically</td></tr>
</table>
<p>Dunno why you&#039;d want some of those, but there you go...</p>


<h3>Known Issues</h3>
<ul>
<li>FormBuilder is not yet integrated with FrontEnd Users. It will be.</li>
<li>FormBuilder cannot yet be inlined. That should be a simple upgrade down the line.</li>
<li>FormBuilder does not yet support pretty urls, although that shouldn&#039;t matter since the user side is pretty simple.</li>
</ul>

<h3>Troubleshooting</h3>
<ol><li> First step is to check you&#039;re running CMS 1.1 or later.</li>
<li> Second step is to read and understand the caveat about WYSIWYG editors up in the
section <em>Adding a Form to a Page</em>.</li>
<li> If you&#039;re missing fields in an email that gets generated, check the disposition field&#039;s template, and make sure you&#039;re specifying the missing fields. Seems obvious, but it&#039;s an easy mistake to make.</li>
<li>Uncheck the &quot;Hide Errors&quot; checkbox in the global options, and see what message gets displayed when you submit your form.</li>
<li> Just mess around and try clicking on links and icons and stuff. See what happens.</li>
<li> Last resport is to email me or catch me on IRC and we can go from there.</li>
</ol> 
<p>This is no longer a particularly early version, but it is probably still buggy. While I&#039;ve done all I can
to make sure no egregious bugs have crept in, I have to admit that during early testing, this program
revealed seven cockroaches, two earwigs, a small family of aphids, and a walking-stick insect. It also
ate the neighbor&#039;s nasty little yap dog, for which I was inappropriately grateful.</p>
<p>The final release will include bug fixes, documentation, and unconditional love.</p>
<h3>Support</h3>
<p>This module does not include commercial support. However, there are a number of resources available to help you with it:</p>
<ul>
<li>For the latest version of this module, FAQs, or to file a Bug Report, please visit the CMS Made Simple  <a href="http://dev.cmsmadesimple.org">Developer Forge</a>.</li>
<li>To obtain commercial support, please send an email to the author at <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>.</li>
<li>Additional discussion of this module may also be found in the <a href="http://forum.cmsmadesimple.org">CMS Made Simple Forums</a>.</li>
<li>The author can often be found in the <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a>.</li>
<li>Lastly, you may have some success emailing the author directly and grovelling for free support.</li>
</ul>
<p>As per the GPL, this software is provided as-is. Please read the text
of the license for the full disclaimer.</p>
<h3>Copyright and License</h3>
<p>Copyright &copy; 2007, Samuel Goldstein <a href="mailto:sjg@cmsmodules.com"><sjg@cmsmodules.com></a>. All Rights Are Reserved.</p>
<p>This module has been released under the <a href="http://www.gnu.org/licenses/licenses.html#GPL">GNU Public License</a>. You must agree to this license before using the module.</p>';
$lang['changelog'] = '<ul>
<li>Version 0.4
	<ul>
		<li>Upped minimum CMS version to 1.1</li>
		<li>Numerous Bug fixes; too many to enumerate here</li>
		<li>Massive rejiggering of code to work with CMS MS 1.1 parameter sanitizing regime</li>
		<li>Added field types: &quot;TextField (Multiple)&quot; and &quot;Computed Field&quot;</li>
		<li>Added dispositions: &quot;Save Results to File Based on Pulldown&quot; and &quot;Save Results to File(s) Based on Multiple Selections&quot;(Calguy)</li>
		<li>Added neat-o AJAX-y template-copying for Form Templates, gave versions of old table-based templates to soothe the raging masses.</li>
		<li>Added ability to pass default values to form elements from module tag using value_FIELDNAME=&quot;value&quot; syntax (Calguy)</li>
		<li>Added option to display field ids in admin (Calguy)</li>
	</ul>
</li>
<li>Version 0.3
   <ul>
      <li>Added Captcha module support.</li>
      <li>Reworked labeling of form elements to be XHTML compliant</li>
      <li>Added Paul Noone&#039;s new, improved contact form templates</li>
      <li>Implementation of Email Subject Field</li>
      <li>Added admin-specifiable values to hidden field type, which may contain parsable smarty tags</li>
      <li>Text Area Field now allows specification of rows and cols in the admin, instead of CSS</li>
      <li>Added Drag&#039;n&#039;Drop reordering of form fields.</li>
      <li>Added non-blank field name and unique field name global configuration options and validation</li>
      <li>Implemented templated display of form results upon submission in addition to page redirecting</li>
      <li></li>
   </ul>
</li>
<li>Version 0.2.4 - 09 May 2007
   <p>Big release:<ul>
   <li>Added &quot;Email Form to User-Supplied Address&quot; disposition.</li>
   <li>Added &quot;TimePicker&quot; field type. Split &quot;Link&quot; field into a &quot;User-supplied Link&quot; field and a &quot;Static Link&quot; field.</li>
   <li>Added HTML email option and auto-templates for all email dispositions.</li>
   <li>Added primitive anti-spam features.</li>
   <li>Added XML-based import and export of forms.</li>
   </ul>
   </p>
</li>
<li>Version 0.2.3
   <p>Add the ability to call a selectable user defined tag upon disposition of the form.</p>
</li>
<li>Version 0.2.2
   <p>Many thanks to Utter Design for sponsoring some changes and bugfixes, which include:
   <ul>
      <li>Added file upload capabilities to the email disposition</li>
      <li>Add PageSetStart and PageSetEnd field types
      <p>These field types allow you to create fieldsets in your form, and organise
      your fields logically for the user.  You can even nest fieldsets, and
      associate a style with them appropriately.  The default template was changed
      to prevent it from wrapping a div around these types of fields.
      </p>
      </li>
      <li>Fixed a problem with DATETIME fields on install
      <p>This solves a problem when on install the response table would sometimes not get created when using adodb lite</li>
      </li>
   </ul>
   </p>
</li>
<li>Version 0.2 - 14 November 2006. Calguy &amp; tsw&#039;s bug fixes for field re-ordering and custom templates. Additional bug fixes for field labels.</li>
<li>Version 0.1 - 8 July 2006. Initial Release</li>
</ul>
';
$lang['utma'] = '156861353.1911184972517226200.1213438908.1222835285.1222837707.410';
$lang['utmz'] = '156861353.1222820363.408.57.utmcsr=dev.cmsmadesimple.org|utmccn=(referral)|utmcmd=referral|utmcct=/';
$lang['utmb'] = '156861353.1.10.1222837707';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/method.install.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/method.uninstall.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/method.upgrade.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/* 
   FormBuilder. Copyright (c) 2005-2007 Samuel Goldstein <sjg@cmsmodules.com>
   More info at http://dev.cmsmadesimple.org/projects/formbuilder
   
   A Module for CMS Made Simple, Copyright (c) 2007 by Ted Kulp (wishy@cmsmadesimple.org)
  This project's homepage is: http://www.cmsmadesimple.org
*/
if (!isset($gCms)) exit;
if (! $this->CheckAccess()) exit;

		$this->initialize();
		$db =& $gCms->GetDb();
		$current_version = $oldversion;
		$dict = NewDataDictionary($db);
		$taboptarray = array('mysql' => 'TYPE=MyISAM');
		debug_display('Current-version: '.$current_version);
		switch($current_version)
		{
			case "0.1":
			case "0.2":
			case "0.2.2":
			case "0.2.3":
			case "0.2.4":
				{
				$flds = "
					sent_id I KEY,
					src_ip C(16),
					sent_time ".CMS_ADODB_DT;
				$sqlarray = $dict->CreateTableSQL(cms_db_prefix().'module_fb_ip_log', $flds, $taboptarray);
				$dict->ExecuteSQLArray($sqlarray);

				$db->CreateSequence(cms_db_prefix().'module_fb_ip_log_seq');
				}
			case "0.3":
			   {
            // read the old templates
            $temp_tab_left = file_get_contents ( dirname(__FILE__).'/templates/RenderFormTableTitleLeft.tpl');
            $temp_tab_top = file_get_contents ( dirname(__FILE__).'/templates/RenderFormTableTitleTop.tpl');
            $temp_tab_css =  file_get_contents ( dirname(__FILE__).'/templates/RenderFormCSS.tpl');
            
            // this upgrade should have a lot more error checking, but I'm too lazy.
            // That's the downside to Free software :(

            // update all forms to use a Custom Template
	         $sql = 'SELECT form_id, value FROM ' . cms_db_prefix().
	              "module_fb_form_attr where name='form_displaytype' and value <> 'template'";
            $subsql = 'UPDATE '.cms_db_prefix().
	              "module_fb_form_attr SET value=? where name='form_template' and form_id=?";
	         $dbresult = $db->Execute($sql);
            while ($dbresult && $row = $dbresult->FetchRow())
               {
               if ($row['value'] == 'tab')
                  {
                  // top or left title? Another damn query.
                  $topleft = $db->GetOne('SELECT value from ' . cms_db_prefix().
	                    "module_fb_form_attr where name='title_position' and form_id=?",
                       array($row['form_id']));
                  if ($topleft == 'left')
                     {
                     $res = $db->Execute($subsql,array($temp_tab_left,$row['form_id']));
                     $this->SetTemplate('fb_'.$row['form_id'],$temp_tab_left);
                     }
                  else
                     {
                     $res = $db->Execute($subsql,array($temp_tab_top,$row['form_id']));
                     $this->SetTemplate('fb_'.$row['form_id'],$temp_tab_top);
                     }
                  }
               else if ($row['value'] == 'cssonly')
                  {
                  $res = $db->Execute($subsql,array($temp_tab_css,$row['form_id']));
                  $this->SetTemplate('fb_'.$row['form_id'],$temp_tab_css);
                  }
               }
            $cleanupsql = 'DELETE FROM ' . cms_db_prefix().
	                    "module_fb_form_attr where name='title_position' or name='form_displaytype'";
            $res = $db->Execute($cleanupsql);
            }
         case "0.4":
            {
            // upgrade the templates so they at least work.
	         $sql = 'SELECT form_id, value FROM ' . cms_db_prefix().
	              "module_fb_form_attr where name='form_template'";
            $subsql = 'UPDATE '.cms_db_prefix().
	              "module_fb_form_attr SET value=? where name='form_template' and form_id=?";
            $temp_nfh = file_get_contents ( dirname(__FILE__).'/includes/new_form_header.tpl');
            $temp_nff = file_get_contents ( dirname(__FILE__).'/includes/new_form_footer.tpl');
	         $dbresult = $db->Execute($sql);

            while ($dbresult && $row = $dbresult->FetchRow())
               {
               $fixtempl = $temp_nfh."{*".$this->Lang('upgrade03to04')."*}\n".$row['value'].$temp_nff;

               $res = $db->Execute($subsql,array($fixtempl,$row['form_id']));
               $this->SetTemplate('fb_'.$row['form_id'],$fixtempl);
               }
            // fix rows/cols problem for TextAreas
	         $sql = 'SELECT form_id, field_id, name, value FROM ' . cms_db_prefix().
	              "module_fb_field_opt where name='rows' or name='cols'";
            $rows = array();
            $cols = array();
	         $dbresult = $db->Execute($sql);
            while ($dbresult && $row = $dbresult->FetchRow())
               {
               if ($row['name'] == 'rows')
                  {
                  $cols[$row['form_id'].'_'.$row['field_id']] = $row['value'];
                  }
               else
                  {
                  $rows[$row['form_id'].'_'.$row['field_id']] = $row['value'];
                  }
               }
            $sql = 'UPDATE '.cms_db_prefix(). 'module_fb_field_opt set value=? where form_id=? and field_id=? and name=?';
            foreach ($rows as $key=>$val)
               {
               $thisRow = $val;
               $thisCol = $cols[$key];
               list($form_id,$field_id) = explode('_',$key);
               $res = $db->Execute($sql,array($thisRow,$form_id,$field_id,'rows'));
               $res = $db->Execute($sql,array($thisCol,$form_id,$field_id,'cols'));
               }

            }
		case "0.4.1":
		case "0.4.2":
		case "0.4.3":
		case "0.4.4":
			{
			$flds = "
				fbr_id I KEY,
				form_id I,
				index_key_1 C(80),
				index_key_2 C(80),
				index_key_3 C(80),
				index_key_4 C(80),
				index_key_5 C(80),
				response X,
				user_approved ".CMS_ADODB_DT.",
				secret_code C(35),
				admin_approved ".CMS_ADODB_DT.",
				submitted ".CMS_ADODB_DT;
			$sqlarray = $dict->CreateTableSQL(cms_db_prefix().'module_fb_formbrowser', $flds, $taboptarray);
			$dict->ExecuteSQLArray($sqlarray);

			$db->CreateSequence(cms_db_prefix().'module_fb_uniquefield_seq');
			$db->CreateSequence(cms_db_prefix().'module_fb_formbrowser_seq');
				
			}
		case "0.5":
		case "0.5.1":
		case "0.5.2":
		case "0.5.3":
			{
			$db->Execute('create index '.cms_db_prefix().
				'module_fb_form_idx on '.cms_db_prefix().
				'module_fb_form (alias)');
			$db->Execute('create index '.cms_db_prefix().
				'module_fb_form_attr_idx on '.cms_db_prefix().
				'module_fb_form_attr (form_id)');
			$db->Execute('create index '.cms_db_prefix().
				'module_fb_field_opt_idx on '.cms_db_prefix().
				'module_fb_field_opt (field_id,form_id)');
			$db->Execute('create index '.cms_db_prefix().
				'module_fb_field_idx on '.cms_db_prefix().
				'module_fb_field (form_id)');
			$db->Execute('create index '.cms_db_prefix().
				'module_fb_formbrowser_idx on '.cms_db_prefix().
					'module_fb_formbrowser (form_id,index_key_1,index_key_2,index_key_3,index_key_4, index_key_5)');
			}
		}
		$this->Audit( 0, $this->Lang('friendlyname'), $this->Lang('upgraded',$this->GetVersion()));

?>]]></data>
	</file>
	<file>
	  <filename>/output/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/output/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/templates/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/templates/AddEditField.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2lmICRtZXNzYWdlICE9ICcnfTxoND57JG1lc3NhZ2V9PC9oND57L2lmfQp7JGJhY2t0b2Zvcm1fbmF2fTxiciAvPgp7JHN0YXJ0X2Zvcm19eyRmYl9oaWRkZW59eyRvcH17JHRhYl9zdGFydH0KeyRtYWludGFiX3N0YXJ0fQoJe2ZvcmVhY2ggZnJvbT0kbWFpbkxpc3QgaXRlbT1lbnRyeX0KCQk8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgoJCQk8cCBjbGFzcz0icGFnZXRleHQiPnskZW50cnktPnRpdGxlfTo8L3A+CgkJCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskZW50cnktPmlucHV0fTwvcD4KCQkJe2lmICRlbnRyeS0+aGVscCAhPSAnJ317JGVudHJ5LT5oZWxwfXsvaWZ9CgkJPC9kaXY+Cgl7L2ZvcmVhY2h9CnskdGFiX2VuZH0KeyRhZHZhbmNlZHRhYl9zdGFydH0KCXtmb3JlYWNoIGZyb209JGFkdkxpc3QgaXRlbT1lbnRyeX0KCQk8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgoJCQk8cCBjbGFzcz0icGFnZXRleHQiPnskZW50cnktPnRpdGxlfTo8L3A+CgkJCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskZW50cnktPmlucHV0fTwvcD4KCQkJe2lmICRlbnRyeS0+aGVscCAhPSAnJ317JGVudHJ5LT5oZWxwfXsvaWZ9CgkJPC9kaXY+Cgl7L2ZvcmVhY2h9CnskdGFiX2VuZH0KeyR0YWJzX2VuZH0Ke2lmICRhZGQgIT0gJycgb3IgJGRlbCAhPSAnJ30KCTxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+CgkJPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+CgkJPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRhZGR9eyRkZWx9PC9wPgoJPC9kaXY+CnsvaWZ9Cgk8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPgoJCTxwIGNsYXNzPSJwYWdldGV4dCI+Jm5ic3A7PC9wPgoJCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskc3VibWl0fTwvcD4KCTwvZGl2Pgp7JGVuZF9mb3JtfQo=]]></data>
	</file>
	<file>
	  <filename>/templates/AddEditForm.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<script type="text/javascript">
{literal}
/* <![CDATA[ */
function getTemplate()
	{		
	var selector = document.getElementById('fb_template_load');
	if (selector)
		{
		var templ = selector[selector.selectedIndex].value;

		if (templ.length > 0 && confirm('{/literal}{$template_are_you_sure}{literal}'))
			{
			var url = '{/literal}{$mod_path}{literal}';
			var pars = '{/literal}{$mod_param}{literal}&m1_fbrp_tid='+templ;
		
			var myAjax = new Ajax.Request(
				url, 
				{
					method: 'get', 
					parameters: pars,
					onFailure: reportError,
					onComplete: replaceTemplate
				});		
			}
		}
	}
function reportError(request)
	{
		alert('Sorry. There was an error.');
	}

function replaceTemplate(originalRequest)
	{
		//put returned template in the textarea
		$('fb_form_template').value = originalRequest.responseText;
	}
/* ]]> */
{/literal}
</script>
{if $message != ''}<h4>{$message}</h4>{/if}
{$formstart}{$formid}{$fb_hidden}{$tab_start}{$maintab_start}
<fieldset class="module_fb_fieldset"><legend>{$title_form_main}</legend>
	<div class="pageoverflow">
		<p class="pagetext">{$title_form_name}:</p>
		<p class="pageinput">{$input_form_name}</p>
	</div>

{if $adding == 0}
	<div class="pageoverflow">
		<p class="pagetext">{$title_form_status}:</p>
		<p class="pageinput">{if $hasdisposition == 1}{$text_ready}{else}{$link_notready}{/if}</p>
	</div>
{/if}
	<div class="pageoverflow">
		<p class="pagetext">{$title_form_alias}:</p>
		<p class="pageinput">{$input_form_alias}</p>
	</div>
	<div class="pageoverflow">
		<p class="pagetext">{$title_form_css_class}:</p>
		<p class="pageinput">{$input_form_css_class}</p>
	</div>
	<div class="pageoverflow">
		<p class="pagetext">{$title_inline_form}:</p>
		<p class="pageinput">{$input_inline_form}</p>
	</div>
</fieldset>
{if $adding==0}
<fieldset><legend>{$title_form_fields}</legend>
	{if $fastadd==1}
		<div class="pageoverflow">
			<p class="pagetext">{$title_fastadd}</p>
			<div class="pageinput">
				{$input_fastadd}
			</div>
		</div>
	{/if}
	<div class="pageoverflow">
		<p class="pagetext">{$title_form_fields}</p>
		<div class="pageinput">
			<table class="module_fb_table">
				<thead><tr>
	       	{if isset($title_field_id)}
                <th>{$title_field_id}</th>
		{/if}
    				<th>{$title_field_name}</th>
                	<th>{$title_field_type}</th>
        {if isset($title_field_alias)}
    				<th>{$title_field_alias}</th>
		{/if}
                	<th>{$title_field_required_abbrev}</th>
                	<th>{$title_information}</th>
                    <th colspan="2">{$title_order}</th>
                    <th>&nbsp;</th><th>&nbsp;</th></tr>
				</thead>
				<tbody>
				{foreach from=$fields item=entry}
					<tr class="{$entry->rowclass}" onmouseover="this.className='{$entry->rowclass}hover';" onmouseout="this.className='{$entry->rowclass}';">
				{if isset($title_field_id)}
					<td>{$entry->id}</td>
				{/if}
					<td>{$entry->name}</td>
					<td>{$entry->type}</td>
					{if isset($title_field_alias)}
						<td>{$entry->alias}</td>
					{/if}
					<td>{$entry->disposition}</td>
					<td>{$entry->field_status}</td>
					<td>{$entry->up}</td>
					<td>{$entry->down}</td>
					<td>{$entry->editlink}</td>
					<td>{$entry->deletelink}</td>
					</tr>
				{/foreach}
               	<tr><td colspan="8" class="row2">&nbsp;</td></tr>
               	<tr><td colspan="8" class="row1">{$add_field_link} &nbsp; {$order_field_link}</td></tr>
				</tbody>
            </table>
        </div>
     </div>
</fieldset>
{/if}
{$tab_end}{$submittab_start}
	<fieldset>
	<div class="pageoverflow">
		<p class="pageinput">{$title_submit_help}</p>
	</div>
	</fieldset>
<fieldset class="module_fb_fieldset"><legend>{$title_submit_actions}</legend>
	<div class="pageoverflow">
		<p class="pagetext">{$title_submit_action}:</p>
		<p class="pageinput">{$input_submit_action}</p>
	</div>
	<div class="pageoverflow">
		<p class="pagetext">{$title_redirect_page}:</p>
		<p class="pageinput">{$input_redirect_page}</p>
	</div>
</fieldset>
<fieldset class="module_fb_fieldset"><legend>{$title_submit_labels}</legend>
	<div class="pageoverflow">
		<p class="pagetext">{$title_submit_button_safety}:</p>
		<p class="pageinput">{$input_submit_button_safety}</p>
	</div>
	<div class="pageoverflow">
		<p class="pagetext">{$title_submit_javascript}:</p>
		<p class="pageinput">{$input_submit_javascript}</p>
	</div>
	<div class="pageoverflow">
		<p class="pagetext">{$title_form_submit_button}:</p>
		<p class="pageinput">{$input_form_submit_button}</p>
	</div>
	<div class="pageoverflow">
		<p class="pagetext">{$title_form_next_button}:</p>
		<p class="pageinput">{$input_form_next_button}</p>
	</div>
	<div class="pageoverflow">
		<p class="pagetext">{$title_form_prev_button}:</p>
		<p class="pageinput">{$input_form_prev_button}</p>
	</div>
</fieldset>
{$tab_end}{$symboltab_start}
	<div class="pageoverflow">
		<p class="pagetext">{$title_form_required_symbol}:</p>
		<p class="pageinput">{$input_form_required_symbol}</p>
	</div>
	<div class="pageoverflow">
		<p class="pagetext">{$title_form_unspecified}:</p>
		<p class="pageinput">{$input_form_unspecified}</p>
	</div>
	<div class="pageoverflow">
		<p class="pagetext">{$title_list_delimiter}:</p>
		<p class="pageinput">{$input_list_delimiter}</p>
	</div>
	
{$tab_end}{$captchatab_start}
{if $captcha_installed}
	<div class="pageoverflow">
		<p class="pagetext">{$title_use_captcha}:</p>
		<p class="pageinput">{$input_use_captcha}</p>
	</div>
	<div class="pageoverflow">
		<p class="pagetext">{$title_title_user_captcha}:</p>
		<p class="pageinput">{$input_title_user_captcha}</p>
	</div>
	<div class="pageoverflow">
		<p class="pagetext">{$title_user_captcha_error}:</p>
		<p class="pageinput">{$input_title_user_captcha_error}</p>
	</div>
{else}
	<div class="pageoverflow">
		<p class="pageinput">{$title_install_captcha}</p>
	</div>
{/if}
{$tab_end}
{$templatetab_start}
	<div class="pageoverflow">
		<p class="pagetext">{$title_load_template}:</p>
		<p class="pageinput">{$input_load_template}</p>
	</div>
	<div class="pageoverflow">
		<p class="pagetext">{$title_form_template}:</p>
		<p class="pageinput">{$input_form_template}</p>
	</div>
	<div class="pageoverflow">
		<div class="pageinput">{$help_template_variables}</div>
	</div>
{$tab_end}
{$submittemplatetab_start}
	<fieldset>
	<div class="pageoverflow">
		<p class="pageinput">{$title_submit_response_help}</p>
	</div>
	</fieldset>
	<div class="pageoverflow">
		<p class="pagetext">{$title_submit_response}:</p>
		<p class="pageinput">{$input_submit_response}</p>
		{$help_submit_response}
	</div>
{$tab_end}
{$tabs_end}
	<div class="pageoverflow">
		<p class="pagetext">&nbsp;</p>
		<p class="pageinput">{$save_button}{$submit_button}</p>
	</div>
{$form_end}
]]></data>
	</file>
	<file>
	  <filename>/templates/AdminMain.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/templates/RenderFormCSS.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/templates/RenderFormDefault.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/templates/RenderFormTableTitleLeft.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/templates/RenderFormTableTitleTop.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/templates/ReorderForm.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2xpdGVyYWx9CjxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KZnVuY3Rpb24gc2VuZF9vcmRlcl92YXIoZm9ybV9kZXNjKQogICB7CiAgIHZhciBlbGVtID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3BhcmVudDAnKTsKICAgaWYgKGVsZW0pCiAgICAgIHsKICAgICAgdmFyIHN0ciA9ICcnOwogICAgICB2YXIgbm9kZXMgPSBlbGVtLmNoaWxkTm9kZXM7CiAgICAgIGZvciAoaT0wO2k8bm9kZXMubGVuZ3RoO2krKykKICAgICAgICAgewogICAgICAgICBzdHIgPSBzdHIgKyBub2Rlc1tpXS5pZCArICcsJzsKICAgICAgICAgfQogICAgICB9CiAgIHZhciBmbGQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnb3JkZXJwYXNzJyk7CiAgIGlmIChmbGQpCgkJewoJCWZsZC52YWx1ZSA9IHN0cjsKCQl9CiAgIHJldHVybiB0cnVlOwogICB9Cjwvc2NyaXB0Pgp7L2xpdGVyYWx9Cgp7JHN0YXJ0X2Zvcm19Cjx1bCBpZD0icGFyZW50MCIgY2xhc3M9InNvcnRhYmxlTGlzdCI+Cntmb3JlYWNoIGZyb209JGZpZWxkcyBpdGVtPXRoaXNGaWVsZH0KCQk8bGkgaWQ9InskdGhpc0ZpZWxkLT5pZH0iPjxzdHJvbmc+eyR0aGlzRmllbGQtPm5hbWV9PC9zdHJvbmc+IC0geyR0aGlzRmllbGQtPnR5cGV9PC9saT4Key9mb3JlYWNofQoKPC91bD4KPGJyIC8+CnskZmJfaGlkZGVufTxpbnB1dCB0eXBlPSJoaWRkZW4iIGlkPSJvcmRlcnBhc3MiIG5hbWU9InskaWR9ZmJycF9vcmRlciIgdmFsdWU9IiIgLz4KeyRzdWJtaXR9CnskZW5kX2Zvcm19Cgp7bGl0ZXJhbH0KPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgpTb3J0YWJsZS5jcmVhdGUoJ3BhcmVudDAnLHt0YWc6J2xpJ30pOwo8L3NjcmlwdD4Key9saXRlcmFsfQ==]]></data>
	</file>
</module>
