<?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.8.1</version>
  <mincmsversion>1.11</mincmsversion>
	<help><![CDATA[<div id="page_tabs">
    <div id="general">General</div>
	<div id="forms">Forms</div>
	<div id="fields">Fields</div>
	<div id="template_variable">Templates and Variables</div>
	<div id="advanced">Advanced</div>
	<div id="styling">Styling</div>
	<div id="configuration">Configuration</div>
	<div id="about">About</div>
</div>

<div class="clearb"></div>

<div id="page_content">
	<div id="general_c">
		<h3>What Does This Do?</h3>
		<p>The Form Builder Module allows you to create 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 {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>
	</div>
	
	<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
	
	<div id="forms_c">
		<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>
	</div>
	
	<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
	
	<div id="fields_c">
		<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>

		<h4>Standard Inputs</h4>
		<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>Button. This doens't do anything, but you can hook it into some Javascript.</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>Password. This is an asterisked-out text field, useful for passwords.</li>
		<li>Password Again (verify). This is a field that must match a Password field for submission
		to succeed.</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>

		<h4>Email-specific Inputs</h4>
		<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>

		<h4>Display Control Fields</h4>
		<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>
		<li>User Tag. This calls the specified User Defined Tag, and displays anything it returns. The UDT gets called any time the field would be visible.</li>
		</ul>

		<h4>Form Handling Inputs (Dispositions)</h4>
		<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 \$params['field_name'], and as \$params['field_alias'] (if defined).</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 "From Address" Field, and send copy. This works like the Email "From Address" Field described above, but it provides options for sending a copy of the results to the user.</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 results based on frontend fields. This field is an email disposition that allows form fields' user input to specify the Email Subject, "From Name", "From Address", and Destination Email Address.</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>*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>*Write Results to a Unique Flat File for each submission. This takes the form results and writes them to a unique text file for each form submission.
		You can specify a filename pattern using values from form fields, set its format, and set the directory where the files will be stored.</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.0.3. Stores the form results in an XML structure as a single database record. This is the only interface to Form Browser.</li>
		<li>*Store Results for ListItExtended. Stores the form results into ListItExtended object and saves it into database.</li>
		<li>*Submit to an arbitrary form action. Craft an HTTP GET or POST, and transmit it using cURL to the specified URL. This lets you use FormBuilder as a front-end to any CGI or Form Handling script out there.</li>
		</ul>
	</div>
	
	<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
	
	<div id="template_variable_c">
		
<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>Variable</th><th>Value</th></tr>
<tr><td>$entry->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>$entry->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>$entry->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>$entry->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>$entry->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>$entry->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>$entry->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>$entry->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>$entry->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>$entry->name</td><td>the field's name</td></tr>
<tr><td>$entry->helptext</td><td>the field's help text</td></tr>
<tr><td>$entry->input</td><td>the field's input control (e.g., the input field itself)</td></tr>
<tr><td>$entry->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>$entry->input_id</td><td>the ID of the field's input (useful for label for="foo")</td></tr>
<tr><td>$entry->alias</td><td>the alias specified for this field</td></tr>
<tr><td>$entry->id</td><td>the internal / opaque id FormBuilder uses for this field</td></tr>
<tr><td>$entry->type</td><td>the field's data type</td></tr>                             
<tr><td>$entry->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>$entry->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In the case of a multipage form, you will also have access to the value of previous fields. They
are in the $previous array, or accessible by their names (e.g., &#123;$myfield->value} ).
You can use this in Static Text fields as well, which is a nice way to personalize forms!</p>

<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>$in_formbrowser</td><td>1 if form is being viewed from FormBrowser</td></tr>
<tr><td>$in_admin</td><td>1 if form is being viewed via FormBrowser admin</td></tr>
<tr><td>$fbr_id</td><td>Response ID if form is being viewed from FormBrowser</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>

	</div>
	
	<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
	
	<div id="advanced_c">
		<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>{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 unwieldy or contain characters that don't work well with Smarty. So there is an
		alternative like this:</p>
		<p>{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 its 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. As of version 0.5, variables also have aliases, which you can use.</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>Use with FormBrowser v3</h3>
		<p>There are some special features when using FormBuilder with FormBrowser. The new approach stores the form results in XML, so that far fewer
		queries are needed to retrieve records. This means you can use FormBrowser with hundreds or even thousands of records. It also means you
		will have to choose up front which fields you will want to be able to sort by. You can choose up to five. Changing these after there are submitted records will result in improper sorting! A re-index function will be added to a future version.</p>
		<p>In advanced options, you can tie a form to Frontend Users. That means each user gets one record for the form; they can create it
		a single time, subsequent times they will be editing their record. The record will not be visible to any other users (excluding admins).
		This form should be added to your page using the syntax {FormBuilder action='feuserform' form='form_name'}.</p>
		<p>For greater data safety, you can encrypt the stored forms in the database. You can use the built-in mycrypt library or the OpenSSL module.
		In either case, for the passphrase, you can either enter text in the field or a file name. If you specify a file name, the contents of that
		file will be used as the passphrase for encrypting.</p>
		<p>If you encrypt, be aware that the fields you use for sorting are <strong>not</strong> encrypted. You can choose to hash them; the cheat here
		is that the first four letters are left intact to allow for sorting. The sorting may not be perfect, and this weakens the security since it
		exposes some cleartext, but it is better than nothing.</p>
		<p><strong>DISCLAIMER</strong>. The encryption offered here should be considered just one more hurdle for a hacker, not as a guarantee that
		your information will be secure. A smart hacker who has found some exploit to view database records may well be smart enough to get at
		the module source code, and find their way to the passphrase. This will not protect you against an enemy who has full access to your
		server, some familiarity with PHP, and the time to poke around. <em><strong>Do not</strong> use this to protect high-value information such as financial data,
		sensitive political information, human rights data, or anything else that might be of value to a repressive government or organized crime
		cartel.</em></p>
		
		<h3>Using with User Defined Tags (UDTs)</h3>
		<p>Several options for customizing behavior via UDTs is provided (thanks to kind code contributions, see credits).</p>

		<ul>
		<li>Call User Defined Tag With the Form Results. This field type submits the human-readable form results to the User-Defined
		Tag you specify. The UDT can handle the results however it wants. Values are passed as $params['field_name'], and
		as $params['field_alias'] (if defined). As per a suggestion, it also populates all of the Smarty values that would be visible to the Submission Template too!</li>
		<li>User Tag Field. This calls the specified UDT, and displays anything it returns. The UDT gets called any time the field would be visible.</li>
		<li>Validation UDT. Set this for a form, and the UDT will receive all of the form's human-readable results. The UDT should do whatever
		validation it wants, and return an array with the first value being true or false (indication whether the form validates), and the second
		value being error messages (if any).</li>
		<li>User defined tag to call before form is displayed the first time (only called once). This
		is set in the Form Admin in the UDT Integration tab. The UDT gets called on the first display
		of the form.</li>
		<li>User defined tag to call before form is displayed (called on every page of multipage
		forms). This is set in the Form Admin in the UDT Integration tab. The UDT gets called
		every time any page of the form is displayed (including when validation fails).</li>
		</ul>
	</div>
	
	<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
	
	<div id="styling_c">
		<h3>Styling and CSS</h3>
		<p>After a bit of nagging on the part of people who actually respect standards, FormBuilder no longer encourages tricks like embedding CSS in 
		static text fields. Instead, it creates a stylesheet called "FormBuilder Default" that you are encouraged to attach to the page template
		that you use for pages that contain your form.</p>  
		<p>This default CSS was graciously provided by Paul Noone.</p>
	</div>
	
	<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
	
	<div id="configuration_c">
		<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 no longer set by default. Checking it will hide the more detailed errors that would 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>Miscellaneous Notes</h3>
		<ul>
      <li>Any fields that sends email to a specified email address will also accept a comma-separated list of email addresses.</li>
		  <li>The File Upload field type won't repopulate on form failure to validate. This is not a bug: it's a security limitation and it's enforced by the browsers. As such, currently and in the foreseeable HTML5 future (as it was in the past with the exception of Opera browsers), only the user can populate a file input field. It's not possible to (re)populate the file input field either with javascript or by setting a default value as it's not supported by the browsers.</li>
		</ul>
		<h3>Known Issues</h3>
		<ul>
		<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>FormBuilder/FormBrowser <strong>requires</strong> PHP 5.2.4 or later to function correctly.</li>
		<li>First step is to check you're running CMS 1.11 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>Make sure you can successfully send email via the test in the CMSMailer Module. It's simply amazing how many problems boil down to a misconfigured CMSMailer.</li>
		<li>Last resort 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>	
	</div>
	
	<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
	
	<div id="about_c">
		<h3>Copyright and License</h3>
		<p>Copyright &copy; 2006, Samuel Goldstein. All Rights Are Reserved.</p>
		<p>Copyright &copy; 2012, Tapio Löytty. All Rights Are Reserved.</p>
		<p>Copyright &copy; 2014, Morten Poulsen [morten at poulsen dot org]. All Rights Are Reserved.</p>
		<br />
		<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>
		<br />
		<p>Many people have contributed code, bug reports, cash, and ideas to FormBuilder. Among them:</p>
		<ul>
			<li>Fernando Morgado - code</li>
			<li>Rolf Tjassens - code</li>
			<li>Ryan Foster - code</li>
			<li>Jonathan Schmid - code, helptext</li>
			<li><a href="http://www.bpti.eu" target="_blank">Baltic institute of advanced technology</a> - code, funding</li>
			<li>Jeremy Bass - code and suggestions</li>
			<li>Alberto Benati - code</li>
			<li>Tyler Boespflug - funding and ideas</li>
			<li>Jeff Bosch - UDT Validation</li>
			<li>Robert Campbell - numerous code contributions</li>
			<li>Piotras Cimmperman - code</li>
			<li>Nuno Costa - suggestions</li>
			<li>Marc Geldon - code</li>
			<li>Kevin Grandon - code</li>
			<li>Ronny Krijt - code</li>
			<li>Paul Noone - CSS and ideas</li>
			<li>Prue Rowland - bug fixes</li>
			<li>Simon Schaufelberger - code</li>
			<li>Adam Shaw-Vardi - funding and ideas</li>
      <li>Jean-Claude Etiemble (jce76350): testing and suggestions;</li>
		</ul>
		<p>I apologize for any omissions - notify me, and I'll correct the omission!</p>
	</div>

	<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --><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><![CDATA[<br />Author: Morten Poulsen &lt;morten@poulsen.org&gt;<br /><br />Version: 0.8.1<br /><br />Change History:<br /><ul>
  <li>Version 0.8.1:
    <ul>
      <li>Fixed #6357 - Duplicate Form Aliases Allowed;</li>
	  <li>Fixed #6536 - "Javascript for field" not included in input for "Validate-via-Email Address";</li>
	  <li>Fixed #6640 - TextFieldExpandable: incorrect output when only one value;</li>
      <li>Fixed #7063 - UDT validation doesn't work properly with standard validation;</li>
	  <li>Fixed #7886 - Call to a member function Type() on a non-object at CatalogerItemsField.class.php:90;</li>
	  <li>Fixed #8691 - UDT validation doesn't work properly with standard validation;</li>
	  <li>Fixed #9637 - Fatal error on Form with Email results field - Object of class fbDispositionFromEmailAddressField could not be converted to string;</li>
	  <li>Fixed #9976 - Checkbox does not get auto ticked when using value_fldNUMBER" and "value_FIELDNAME";</li>
	  <li>Fixed #10229 - fixes validation of emails; fixes the appearance of html entities if the form doesn't validate;</li>
	  <li>Fixed #10260 - Textarea clear default on click && {strip} not working;</li>	    
	  <li>Feature Request #10117 - Add directive REQUIRED in nHTML5;</li>
	  <li>Feature Request #10268 - HTML5 placeholder for "*Email "From Address" Field, and send copy";</li>
	  <li>Fixed Show textfield in CheckboxExtendedField class;</li>
	  <li>Fixes to DispositionEmail related with uploaded files and attachments. Now we can properly separate the path, the url and the filename. Probably fixes a bunch of old issues;</li>
	  <li>Fixes multiple pages uploads;</li>
	  <li>Improvements to DatePicker and TimePicker;</li>
	  <li>The "Use relaxed email validation" preference is removed, emails just have to pass validation;</li>
	  <li>Some preferences are moved to the private config; might be definitely removed/hardcoded in a future version;</li>
	  <li>Updates for HTML5</li>
    </ul>
  </li>
  <li>Version 0.8:<br />
	<p>Because the 0.7.4 release was unstable, a new group of developers went back to the working code of 0.7.3 and started working from there. First priority: a stable Formbuilder release!</p>
    <ul>
	    <li>Fixed #7408 - Debug informations shown during upgrade;</li>
	    <li>Fixed #7450 - countries WAY out of date - causing a few problems with Serbian customers;</li>
	    <li>Fixed #8510 - Warning: Illegal string offset 'sent';</li>
	    <li>Fixed #8893 - Text input (multiple) delete button;</li>
	    <li>Fixed #9296 - Field keeps being required even if unset;</li>
	    <li>Fixed #9360 - Formbuilder doesn't upload files on multi page forms;</li>
	    <li>Fixed #9738 - Helptext Form Template Variables;</li>
		<li>Fixed #9511 - Missing language string: validation_length;</li>
	    <li>Fixed #9513 - Undefined variable/index notices in apache log;</li>
	    <li>Fixed #9959 - When email field isn't required validation makes it required;</li>
		<li>Fixed #10255 - File upload does not work when form is incomplete or has errors: removed the <strong>delete</strong> checkbox and the text with the file name when form submission fails;
		<p>(<strong>Note: not a bug <i>per se</i>, but an inconsistency: the browsers don't support a default value for file upload fields for security reasons.</strong>)</p></li>
	    <li>Code cleanup;</li>
	    <li>Fixes for CMSMS Core 2.0 release;</li>
	    <li>Field table width is now 100%;</li>
	    <li>Help text re-written and English only now;</li>
    </ul>
  </li>
  <li>Version 0.7.4:
    <ul>
      <li>This release was not stable and therefore withdrawn from the Forge;</li>
    </ul>
  </li>
  <li>Version 0.7.3:
    <ul>
      <li>Compatibility release for 1.11;</li>
      <li>Adding cancel buttons to form and field instances;</li>
      <li>Removing ugly go back link;</li>
      <li>Ensuring usability in PHP strict mode;</li>
      <li>Some template fixes;</li>
      <li>NOTE: This is not feature or bug release, this is compatibility release as we ain't working with anything else than maintaining certain compatibility with this module. Stay tuned for FormBuilder2 within this year;</li>
    </ul>
  </li>
  <li>Version 0.7.2:
    <ul>
      <li>Many bug fixes;</li>
      <li>Last version of 0.x series;</li>
      <li>Fixing compability with 1.10.x series;</li>
      <li>Fixing problems with Form Browser;</li>
    </ul>
  </li>
  <li>Version 0.7.1 - (calguy1000):
    <ul>
      <li>Fixes the search for fields to not show backup files etc;</li>
      <li>Fixes a CMS Version comparison;</li>
      <li>Adds a disposition to allow selecting users to email based on an FEU property.   Also assigns smarty variables with info about matching usess;</li>
    </ul>
  </li>
	<li>Version 0.7:
		<ul>
			<li>Fixed a bug which caused the Date Submitted sorting in Form Browser to be inconsistent across pages at first;</li>
			<li>Fixed a bug which caused a Checkbox Field to be unable to be required. Checkbox Fields can now be made required;</li>
			<li>Fixed Bug #5610: File Upload Field advanced options now save correctly;</li>
			<li>Fixed Bug #5702: When using the "Frontend User binding" advanced option on the FormBrowser Disposition, checkboxes can now be saved in the "unchecked" state. Thanks Mike Hughesdon!</li>
			<li>Fixed Bug #5422: Multiple forms using the "Frontend User binding" advanced option on the FormBrowser Disposition now correctly load previously submitted data. Thanks Mike Hughesdon!</li>
			<li>Added: New Disposition - DispositionUniqueFile. Write form results to a unique file for each form submission;</li>
			<li>Added: TinyMCE integrated;</li>
			<li>Added: New Disposition - DispositionEmailBasedFrontendFields. Send form results via email with frontend-user-specified Subject, "From Name", "From Address", and Destination Address;</li>
			<li>Added: Random number generator to UniqueIntegerField;</li>
			<li>Fixed Bug #5555/#5453: Dominica (DM) is now properly selectable in the Country Picker Field;</li>
			<li>Fixed Bug #4307: Files uploaded on earlier pages of a multi-page form are now attached to Email Dispositions on later pages;</li>
			<li>Fixed Bug #3605: Dates are now translated in Email Dispositions.</li>
			<li>Fixed Bug #5358: DispositionFromEmailAddressField now creates a correct label for its input field;</li>
			<li>Fixed Bug #1822: Hidden Fields can now be edited in an Admin Form Browser;</li>
			<li>Added Feature Request #5277: Allow DispositionFormBrowser to be hidden;</li>
			<li>Several other cleanups and minor fixes;</li>
		</ul>
	</li>
	<li>Version 0.6.4.
		<ul>
			<li>Bugs fixes for Field Sorting. Thanks to everyone who reported and Stikki for fixing it!</li>
			<li>Improvements FileUpload field: overwrite flag, file renaming, and hiding filename in output;</li>
			<li>Additional patches from Ryan Foster for DatePicker;</li>
		</ul>
	</li>
  <li>Version 0.6.3:
	  <ul>
		  <li>Security patch for Upload field type;</li>
		  <li>Numerous bugs fixes. Thanks to everyone who reported;</li>
		  <li>Numerous fixes and improvements for use with FormBrowser v0.3.x;</li>
		  <li>Improvements to the ComputedField type to allow much more computation;</li>
		  <li>Vilkis' fixes for localizing CountryPicker;</li>
		  <li>Ryan Foster's patch for re-ordering date inputs on DatePicker;</li>
	  </ul>
  </li>
  <li>Version 0.6.2:
	  <ul>
		  <li>A lot of small and big bugs fixes. Thanks to everyone who reported;</li>
		  <li>Introducing dynamic field management;</li>
		  <li>New "YearPullDown" field type added;</li>
		  <li>Compatible with CMSMS 1.7.1 and further;</li>
		  <li>Added jQuery. Prototype removed completely;</li>
		  <li>Added some styling;</li>
	  </ul>
  </li>
  <li>Version 0.6.1:
	  <ul>
		  <li>Numerous Bug fixes. If your bug isn't fixed, post it in the tracker!</li>
		  <li>New Validation UDT code provided by Jeff Bosch;</li>
		  <li>Ability to reject blank/only spaces for required fields;</li>
		  <li>New "CompanyDirectory"" Field type provided by Jeremy Bass</li>
		  <li>Improvements to default value code provided by Jeremy Bass;</li>
		  <li>New "Module Interface" field type provided by Jeremy Bass;</li>
		  <li>New "User Defined Tag Call" field type;</li>
		  <li>Fix to support syntax highlighters for templates and Javascript on admin side;</li>
		  <li></li>
	  </ul>
  </li>
  <li>Version 0.6 - 30 Dec 09: Bug fixes. Finally releasing this thing!</li>
  <li>Version 0.6b2:
     <ul>
        <li>Numerous bug fixes. Thanks for all who reported on bugs!</li>
        <li>Added Form Disposition to do an HTTP GET or POST to any arbitrary URL for form handling;</li>
        <li>Added capability (and example of) advanced multipage contact form where a previous response gets displayed on a subsequent page as per uptoeleven's FR;</li>
        <li>Fix for template $fld_X remapping on XML import;</li>
        <li>Extended to provide DOM/CSS id attributes to fields;</li>
        <li>Cleaned up bad use of references for PHP 5.x;</li>
     </ul>
  </li>
  <li>Version 0.6b1:
	  <ul>
		  <li>Updated database code to be CMSMS 1.7-compatible;</li>
		  <li>Added Button field type.</li>
		  <li>Implemented FormBrowser v0.3 Disposition;</li>
		  <li>Numerous code fixes;</li>
	  </ul>
  </li>
  <li>Version 0.5.12 - 3 Sept 09: Numerous user-submitted fixes. Thanks to Calguy and Simon Schaufi;</li>
  <li>Version 0.5.11 - 19 Jan 09 (calguy1000):
    <ul>
      <li>Adds the capability to call a UDT before the form is displayed;</li>
      <li>Move changelog to an external file;</li>
    </ul>
  </li>
  <li>Version 0.5.10: 12 Jan 09. Bug fixes to restore functionality of FormBrowser;</li>
  <li>Version 0.5.9: Jan 09 (calguy1000) - Minor change to the DispositionFile class;</li>
  <li>Version 0.5.8: Jan 09 (calguy1000) - Minor change to the DispositionMultiselectFileDirector class;</li>
  <li>Version 0.5.7: Jan 09 (calguy1000) - Minor change to the DispositionMultiselectFileDirector class;</li>
  <li>Version 0.5.6: 23 Dec 08. Bug fixes;</li>
  <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>
     </ul>
  </li>
  <li>Version 0.2.4 - 09 May 2007
     <p>Big release:</p>
     <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>
  </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:</p>
     <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.</p>
        </li>
     </ul>
  </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><br />]]></about>
	<description><![CDATA[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[PD9waHAKIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIyBNb2R1bGU6IEZvcm1CdWlsZGVyCiMgQXV0aG9yOiBTYW11ZWwgR29sZHN0ZWluLCBNb3J0ZW4gUG91bHNlbgojLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQojIENNUyBNYWRlIFNpbXBsZSBpcyAoYykgMjAwNCAtIDIwMTEgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQojIENNUyBNYWRlIFNpbXBsZSBpcyAoYykgMjAxMSAtIDIwMTQgYnkgVGhlIENNU01TIERldiBUZWFtCiMgVGhpcyBwcm9qZWN0J3MgaG9tZXBhZ2UgaXM6IGh0dHA6Ly93d3cuY21zbWFkZXNpbXBsZS5vcmcKIyBUaGUgbW9kdWxlJ3MgaG9tZXBhZ2UgaXM6IGh0dHA6Ly9kZXYuY21zbWFkZXNpbXBsZS5vcmcvcHJvamVjdHMvZm9ybWJ1aWxkZXIKIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIyBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQojIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CiMgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKIyAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgojCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCiMgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKIyBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCiMgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCiMgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNyBVU0EKIyBPciByZWFkIGl0IG9ubGluZTogaHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzL2xpY2Vuc2VzLmh0bWwjR1BMCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgppZiAoIWlzX29iamVjdChAY21zbXMoKSkpIGV4aXQ7CgppZiAoaXNzZXQoJHBhcmFtc1snZmJycF9jYW5jZWwnXSkpIHsKCSRwYXJtc1snZm9ybV9pZCddID0gJHBhcmFtc1snZm9ybV9pZCddOwoJJHRoaXMtPlJlZGlyZWN0KCRpZCwgJ2FkbWluX2FkZF9lZGl0X2Zvcm0nLCAkcmV0dXJuaWQsICRwYXJtcyk7Cn0KCiR0aGlzLT5pbml0aWFsaXplKCk7CgokYWVmb3JtID0gbmV3IGZiRm9ybSgkdGhpcywgJHBhcmFtcyx0cnVlKTsKJGFlZmllbGQgPSAkYWVmb3JtLT5OZXdGaWVsZCgkcGFyYW1zKTsKaWYgKGlzc2V0KCRwYXJhbXNbJ2ZicnBfYWVmX3VwZCddKSB8fCAoaXNzZXQoJHBhcmFtc1snZmJycF9hZWZfYWRkJ10pICYmICRhZWZpZWxkLT5HZXRGaWVsZFR5cGUoKSAhPSAnJykpCgl7CgkvLyBzYXZlIHRoZSBmaWVsZC4KCSR0aGlzLT5Eb0FjdGlvbignYWRtaW5fc3RvcmVfZmllbGQnLCAkaWQsICRwYXJhbXMpOwoJcmV0dXJuOwoJfQplbHNlaWYgKGlzc2V0KCRwYXJhbXNbJ2ZicnBfYWVmX2FkZCddKSkKCXsKCS8vIHNob3VsZCBoYXZlIGdvdCBhIGZpZWxkIHR5cGUgZGVmaW5pdGlvbiwgc28gZ2l2ZSByZXN0IG9mIHRoZSBmaWVsZCBvcHRpb25zCgkvLyByZXNlcnZlIHRoaXMgc3BhY2UgZm9yIHNwZWNpYWwgb3BzIDopCgl9CmVsc2VpZiAoaXNzZXQoJHBhcmFtc1snZmJycF9hZWZfb3B0YWRkJ10pKQoJewoJLy8gY2FsbCB0aGUgZmllbGQncyBvcHRpb24gYWRkIG1ldGhvZCwgd2l0aCBhbGwgYXZhaWxhYmxlIHBhcmFtZXRlcnMKCSRhZWZpZWxkLT5Eb09wdGlvbkFkZCgkcGFyYW1zKTsKCX0KZWxzZWlmIChpc3NldCgkcGFyYW1zWydmYnJwX2FlZl9vcHRkZWwnXSkpCgl7CgkvLyBjYWxsIHRoZSBmaWVsZCdzIG9wdGlvbiBkZWxldGUgbWV0aG9kLCB3aXRoIGFsbCBhdmFpbGFibGUgcGFyYW1ldGVycwoJJGFlZmllbGQtPkRvT3B0aW9uRGVsZXRlKCRwYXJhbXMpOwoJfQplbHNlCgl7CgkvLyBuZXcgZmllbGQsIG9yIGltcGxpY2l0IGFlZl9hZGQuCgkvLyBhZ2FpbiwgcmVzZXJ2aW5nIHRoZSBzcGFjZSBmb3IgZnV0dXJlIGVuZGVhdm9ycwoJfQoKZWNobyAkYWVmb3JtLT5BZGRFZGl0RmllbGQoJGlkLCAkYWVmaWVsZCwgKGlzc2V0KCRwYXJhbXNbJ2ZicnBfZGlzcG9zZV9vbmx5J10pPyRwYXJhbXNbJ2ZicnBfZGlzcG9zZV9vbmx5J106MCksICRyZXR1cm5pZCwgaXNzZXQoJHBhcmFtc1snZmJycF9tZXNzYWdlJ10pPyR0aGlzLT5TaG93TWVzc2FnZSgkcGFyYW1zWydmYnJwX21lc3NhZ2UnXSk6JycpOwoKIwojIEVPRgojCQkKPz4=]]></data>
	</file>
	<file>
	  <filename>/action.admin_add_edit_form.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.admin_delete_field.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.admin_delete_form.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.admin_get_template.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.admin_store_field.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.admin_store_form.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></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[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]]></data>
	</file>
	<file>
	  <filename>/action.admin_update_field_required.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.default.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: FormBuilder
# Author: Samuel Goldstein, Morten Poulsen
#-------------------------------------------------------------------------
# CMS Made Simple is (c) 2004 - 2011 by Ted Kulp (wishy@cmsmadesimple.org)
# CMS Made Simple is (c) 2011 - 2014 by The CMSMS Dev Team
# This project's homepage is: http://www.cmsmadesimple.org
# The module's homepage is: http://dev.cmsmadesimple.org/projects/formbuilder
#-------------------------------------------------------------------------
# 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
#-------------------------------------------------------------------------

if (!is_object(@cmsms())) exit;

if (! isset($params['form_id']) && isset($params['form']))
	{
		// get the form by name, not ID
		$params['form_id'] = $this->GetFormIDFromAlias($params['form']);
	}

$inline = false;

if( (isset($params['inline'])) && preg_match('/t(rue)*|y(yes)*|1/i',$params['inline']))
	{
		$inline = true;
	}

$fbrp_callcount = 0;
$aeform = new fbForm($this,$params,true,true);

$fld = $aeform->GetFormBrowserField();

if ($fld !== false && $fld->GetOption('feu_bind','0')=='1')
	{
		$feu = $this->GetModuleInstance('FrontEndUsers');
		if ($feu == false)
			{
			debug_display("FAILED to instantiate FEU!");
			return;
			}
			
		if ($feu->LoggedInId() === false)
			{
				echo $this->Lang('please_login');
				return;
			}
	}

if( !($inline || ($aeform->GetAttr('inline','0')== '1'))) $id = 'cntnt01';

$this->smarty->assign('fb_form_has_validation_errors',0);
$this->smarty->assign('fb_show_submission_errors',0);
$this->smarty->assign('fb_form_header', $aeform->RenderFormHeader());
$this->smarty->assign('fb_form_footer',$aeform->RenderFormFooter());

$finished = false;
$fieldExpandOp = false;

if( isset($params['fbrp_callcount']) )
	{
		$fbrp_callcount = (int)$params['fbrp_callcount'];
	}

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 && (($aeform->GetPageCount() > 1 && $aeform->GetPageNumber() > 0) || (isset($params['fbrp_done'])&& $params['fbrp_done']==1)))
	{
		// Validate form
		$res = $aeform->Validate();
    
		// We have validate errors
		if ($res[0] === false)
		{
			$this->smarty->assign('fb_form_validation_errors',$res[1]);
			$this->smarty->assign('fb_form_has_validation_errors',1);

			$aeform->PageBack();

			// No validate errors, proceed
		} else if (isset($params['fbrp_done']) && $params['fbrp_done']==1) {
      
			// Check captcha, if installed
			$ok = true;
			$captcha = $this->getModuleInstance('Captcha');
			
			if ($aeform->GetAttr('use_captcha','0')== '1' && $captcha != null)
			{
        #this should work with Captcha 0.4.6 and higher (JM)
        $cptcneedsinput = method_exists($captcha, 'NeedsInputField') ? $captcha->NeedsInputField() : true;        
        $tovalidate = $cptcneedsinput ? $params['fbrp_captcha_phrase'] : '';
                
				if( !$captcha->CheckCaptcha($tovalidate) )
				{
					$this->smarty->assign('captcha_error',$aeform->GetAttr('captcha_wrong',$this->Lang('wrong_captcha')));

					$aeform->PageBack();
					$ok = false;
				}
        
			}
		
			// All ok, dispose form and manage fileuploads
			if ($ok)
			{
				$finished = true;
				$aeform->manageFileUploads();
				$results = $aeform->Dispose($returnid);
			}
		}
	}

if (! $finished)
	{
		$parms = array();
		$parms['form_name'] = $aeform->GetName();
		$parms['form_id'] = $aeform->GetId();
		$this->SendEvent('OnFormBuilderFormDisplay',$parms);

		if (isset($params['fb_from_fb']))
			{
				$this->smarty->assign('fb_form_start',
				$this->CreateFormStart($id, 'user_edit_resp', $returnid, 'post',
				'multipart/form-data', 
				($aeform->GetAttr('inline','0')== '1'), '',
				array('fbrp_callcount'=>$fbrp_callcount+1)).
				$this->CreateInputHidden($id,'response_id',isset($params['response_id'])?$params['response_id']:'-1'));
			}
			else
			{
				$this->smarty->assign('fb_form_start',
				$this->CreateFormStart($id, 'default', $returnid, 'post', 
				'multipart/form-data', 
				($aeform->GetAttr('inline','0')== '1'), '',
				array('fbrp_callcount'=>$fbrp_callcount+1)));
			}

		$this->smarty->assign('fb_form_end',$this->CreateFormEnd());
		$this->smarty->assign('fb_form_done',0);
	}
	else
	{
		$this->smarty->assign('fb_form_done',1);
		if ($results[0] == true)
			{
				$parms = array();
				$parms['form_name'] = $aeform->GetName();
				$parms['form_id'] = $aeform->GetId();
				$this->SendEvent('OnFormBuilderFormSubmit',$parms);

				$act = $aeform->GetAttr('submit_action','text');
				if ($act == 'text')
					{
						$message = $aeform->GetAttr('submit_response','');

						$aeform->setFinishedFormSmarty(true);
						echo $this->ProcessTemplateFromData( $message );
						return;
					}
					else if ($act == 'redir')
					{
						$ret = $aeform->GetAttr('redirect_page','-1');
						if ($ret != -1)
							{
								$this->RedirectContent($ret);
								return;
							}
					}
			}
			else
			{
				$parms = array();
				$params['fbrp_error']='';
				$this->smarty->assign('fb_submission_error',
				$this->Lang('submission_error'));

				$show = $this->GetPreference('hide_errors','1');
				$this->smarty->assign('fb_submission_error_list',$results[1]);
				$this->smarty->assign('fb_show_submission_errors',$show);

				$parms['form_name'] = $aeform->GetName();
				$parms['form_id'] = $aeform->GetId();
				$this->SendEvent('OnFormBuilderFormSubmitError',$parms);
			}
	}

$udtonce = $aeform->GetAttr('predisplay_udt','');
$udtevery = $aeform->GetAttr('predisplay_each_udt','');

if (!$finished && ((!empty($udtonce) && $udtonce != '-1') || (!empty($udtevery) && $udtevery != '-1')))
	{
		$usertagops = cmsms()->GetUserTagOperations();
		$parms = $params;
		$parms['FORM'] =& $aeform;

		if( isset($fbrp_callcount) && $fbrp_callcount == 0 && !empty($udtonce) && "-1" != $udtonce )
			{
				$tmp = $usertagops->CallUserTag($udtonce,$parms);
			}
			
		if(!empty($udtevery) && "-1" != $udtevery)
			{
				$tmp = $usertagops->CallUserTag($udtevery,$parms);
			}

	}

echo $aeform->RenderForm($id, $params, $returnid);

#
# EOF
#
?>]]></data>
	</file>
	<file>
	  <filename>/action.defaultadmin.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: FormBuilder
# Author: Samuel Goldstein, Morten Poulsen
#-------------------------------------------------------------------------
# CMS Made Simple is (c) 2004 - 2011 by Ted Kulp (wishy@cmsmadesimple.org)
# CMS Made Simple is (c) 2011 - 2014 by The CMSMS Dev Team
# This project's homepage is: http://www.cmsmadesimple.org
# The module's homepage is: http://dev.cmsmadesimple.org/projects/formbuilder
#-------------------------------------------------------------------------
# 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
#-------------------------------------------------------------------------

if (!is_object(@cmsms())) exit;

$admintheme = cms_utils::get_theme_object();
$smarty = cmsms()->GetSmarty();

// and a list of all the existent forms.
$forms = $this->GetForms();
$num_forms = count($forms);

if( !formbuilder_utils::is_CMS2() )
	{
		$smarty->assign(
			'tabheaders', $this->StartTabHeaders() 
			. $this->SetTabHeader('forms', $this->Lang('forms') ) 
			. $this->SetTabHeader('config', $this->Lang('configuration') )
			. $this->EndTabHeaders()
			. $this->StartTabContent()
			);
                  
		$smarty->assign('start_formtab', $this->StartTab("forms"));
		$smarty->assign('start_configtab', $this->StartTab("config"));
		$smarty->assign('end_tab', $this->EndTab());
		$smarty->assign('end_tabs', $this->EndTabContent());
	}

$smarty->assign('start_configform', $this->CreateFormStart(
	$id,
	'admin_update_config',
	$returnid
	)
	); 

$smarty->assign('frmbld', $this);
$smarty->assign('title_form_name', $this->Lang('title_form_name'));
$smarty->assign('title_form_alias', $this->Lang('title_form_alias'));

$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'))
			{
				$conf = $this->GetConfig();
				$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=\"".$conf['root_url']."/modules/".$this->GetName()."/images/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', '',
				$admintheme->DisplayImage('icons/system/edit.gif',$this->Lang('edit'),'','','systemicon'),
					array('form_id'=>$thisForm['form_id']));
				$oneset->deletelink = $this->CreateLink($id,
					'admin_delete_form', '',
				$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'))
	{
		$smarty->assign('addlink',$this->CreateLink($id,
			'admin_add_edit_form', '',
		$admintheme->DisplayImage('icons/system/newobject.gif', $this->Lang('title_add_new_form'),'',
			'','systemicon'), array()));
		$smarty->assign('addform',$this->CreateLink($id,
			'admin_add_edit_form', '', $this->Lang('title_add_new_form'),
			array()));
		$smarty->assign('may_config',1);
	}	
	else
	{
		$smarty->assign('no_permission',
		$this->Lang('lackpermission'));
	}

$smarty->assign('title_hide_errors',$this->Lang('title_hide_errors'));    
$smarty->assign('input_hide_errors',$this->CreateInputCheckbox($id, 'fbrp_hide_errors', 1, $this->GetPreference('hide_errors','0')). $this->Lang('title_hide_errors_long'));
  
//$smarty->assign('title_relaxed_email_regex',$this->Lang('title_relaxed_email_regex'));    
//$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'));
  
//$smarty->assign('title_enable_fastadd',$this->Lang('title_enable_fastadd'));
//$smarty->assign('input_enable_fastadd',$this->CreateInputCheckbox($id, 'fbrp_enable_fastadd', 1, $this->GetPreference('enable_fastadd','1')). $this->Lang('title_enable_fastadd_long'));    
  
$smarty->assign('title_require_fieldnames',$this->Lang('title_require_fieldnames'));    
$smarty->assign('input_require_fieldnames',$this->CreateInputCheckbox($id, 'fbrp_require_fieldnames', 1, $this->GetPreference('require_fieldnames','1')). $this->Lang('title_require_fieldnames_long'));    
  
$smarty->assign('title_unique_fieldnames',$this->Lang('title_unique_fieldnames'));
$smarty->assign('input_unique_fieldnames',$this->CreateInputCheckbox($id, 'fbrp_unique_fieldnames', 1, $this->GetPreference('unique_fieldnames','1')). $this->Lang('title_unique_fieldnames_long'));    
  
$smarty->assign('title_enable_antispam',$this->Lang('title_enable_antispam'));
$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','1')). $this->Lang('title_show_fieldaliases_long'));
  
//$smarty->assign('title_show_version',$this->Lang('title_show_version'));
//$smarty->assign('input_show_version',$this->CreateInputCheckbox($id, 'fbrp_show_version', 1, $this->GetPreference('show_version','1')). $this->Lang('title_show_version_long'));

$smarty->assign('title_blank_invalid',$this->Lang('title_blank_invalid'));
$smarty->assign('input_blank_invalid',$this->CreateInputCheckbox($id,
	'fbrp_blank_invalid', 1, $this->GetPreference('blank_invalid','0')).
	$this->Lang('title_blank_invalid_long'));
         
$smarty->assign('submit', $this->CreateInputSubmit($id, 'fbrp_submit', $this->Lang('save')));
$smarty->assign('end_configform',$this->CreateFormEnd());
  
$smarty->assign('start_xmlform',$this->CreateFormStart($id, 'importxml', $returnid, 'post','multipart/form-data'));
$smarty->assign('submitxml', $this->CreateInputSubmit($id, 'fbrp_submit', $this->Lang('upload')));
$smarty->assign('end_xmlform',$this->CreateFormEnd());
  
$smarty->assign('input_xml_to_upload',$this->CreateInputFile($id, 'fbrp_xmlfile'));
$smarty->assign('title_xml_to_upload',$this->Lang('title_xml_to_upload'));
$smarty->assign('title_xml_upload_formname',$this->Lang('title_xml_upload_formname'));
$smarty->assign('input_xml_upload_formname',
	$this->CreateInputText($id,'fbrp_import_formname','',25));
$smarty->assign('title_xml_upload_formalias',$this->Lang('title_xml_upload_formalias'));
$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'));
  
$smarty->assign_by_ref('forms', $formArray);

if( formbuilder_utils::is_CMS2() )
	{
		echo $this->ProcessTemplate('AdminMain2.tpl');
	}
	else
	{
		echo $this->ProcessTemplate('AdminMain.tpl');
	}    

#
# EOF
#  
?>]]></data>
	</file>
	<file>
	  <filename>/action.exportxml.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.feuserform.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIyBNb2R1bGU6IEZvcm1CdWlsZGVyCiMgQXV0aG9yOiBTYW11ZWwgR29sZHN0ZWluLCBNb3J0ZW4gUG91bHNlbgojLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQojIENNUyBNYWRlIFNpbXBsZSBpcyAoYykgMjAwNCAtIDIwMTEgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQojIENNUyBNYWRlIFNpbXBsZSBpcyAoYykgMjAxMSAtIDIwMTQgYnkgVGhlIENNU01TIERldiBUZWFtCiMgVGhpcyBwcm9qZWN0J3MgaG9tZXBhZ2UgaXM6IGh0dHA6Ly93d3cuY21zbWFkZXNpbXBsZS5vcmcKIyBUaGUgbW9kdWxlJ3MgaG9tZXBhZ2UgaXM6IGh0dHA6Ly9kZXYuY21zbWFkZXNpbXBsZS5vcmcvcHJvamVjdHMvZm9ybWJ1aWxkZXIKIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIyBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQojIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CiMgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKIyAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgojCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCiMgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKIyBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCiMgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCiMgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNyBVU0EKIyBPciByZWFkIGl0IG9ubGluZTogaHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzL2xpY2Vuc2VzLmh0bWwjR1BMCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgppZiAoIWlzX29iamVjdChAY21zbXMoKSkpIGV4aXQ7CgokZmV1ID0gJiR0aGlzLT5HZXRNb2R1bGVJbnN0YW5jZSgnRnJvbnRFbmRVc2VycycpOwoKaWYgKCRmZXUgPT0gZmFsc2UgfHwgJGZldS0+TG9nZ2VkSW4oKSA9PSBmYWxzZSkKCXsKCQlyZXR1cm47Cgl9CgkKJHRoaXMtPkRvQWN0aW9uKCdkZWZhdWx0JywkaWQsJHBhcmFtcywgJHJldHVybmlkKTsKCiMKIyBFT0YKIwo/Pg==]]></data>
	</file>
	<file>
	  <filename>/action.importxml.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.validate.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/changelog.inc</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<ul>
  <li>Version 0.8.1:
    <ul>
      <li>Fixed #6357 - Duplicate Form Aliases Allowed;</li>
	  <li>Fixed #6536 - "Javascript for field" not included in input for "Validate-via-Email Address";</li>
	  <li>Fixed #6640 - TextFieldExpandable: incorrect output when only one value;</li>
      <li>Fixed #7063 - UDT validation doesn't work properly with standard validation;</li>
	  <li>Fixed #7886 - Call to a member function Type() on a non-object at CatalogerItemsField.class.php:90;</li>
	  <li>Fixed #8691 - UDT validation doesn't work properly with standard validation;</li>
	  <li>Fixed #9637 - Fatal error on Form with Email results field - Object of class fbDispositionFromEmailAddressField could not be converted to string;</li>
	  <li>Fixed #9976 - Checkbox does not get auto ticked when using value_fldNUMBER" and "value_FIELDNAME";</li>
	  <li>Fixed #10229 - fixes validation of emails; fixes the appearance of html entities if the form doesn't validate;</li>
	  <li>Fixed #10260 - Textarea clear default on click && {strip} not working;</li>	    
	  <li>Feature Request #10117 - Add directive REQUIRED in nHTML5;</li>
	  <li>Feature Request #10268 - HTML5 placeholder for "*Email "From Address" Field, and send copy";</li>
	  <li>Fixed Show textfield in CheckboxExtendedField class;</li>
	  <li>Fixes to DispositionEmail related with uploaded files and attachments. Now we can properly separate the path, the url and the filename. Probably fixes a bunch of old issues;</li>
	  <li>Fixes multiple pages uploads;</li>
	  <li>Improvements to DatePicker and TimePicker;</li>
	  <li>The "Use relaxed email validation" preference is removed, emails just have to pass validation;</li>
	  <li>Some preferences are moved to the private config; might be definitely removed/hardcoded in a future version;</li>
	  <li>Updates for HTML5</li>
    </ul>
  </li>
  <li>Version 0.8:<br />
	<p>Because the 0.7.4 release was unstable, a new group of developers went back to the working code of 0.7.3 and started working from there. First priority: a stable Formbuilder release!</p>
    <ul>
	    <li>Fixed #7408 - Debug informations shown during upgrade;</li>
	    <li>Fixed #7450 - countries WAY out of date - causing a few problems with Serbian customers;</li>
	    <li>Fixed #8510 - Warning: Illegal string offset 'sent';</li>
	    <li>Fixed #8893 - Text input (multiple) delete button;</li>
	    <li>Fixed #9296 - Field keeps being required even if unset;</li>
	    <li>Fixed #9360 - Formbuilder doesn't upload files on multi page forms;</li>
	    <li>Fixed #9738 - Helptext Form Template Variables;</li>
		<li>Fixed #9511 - Missing language string: validation_length;</li>
	    <li>Fixed #9513 - Undefined variable/index notices in apache log;</li>
	    <li>Fixed #9959 - When email field isn't required validation makes it required;</li>
		<li>Fixed #10255 - File upload does not work when form is incomplete or has errors: removed the <strong>delete</strong> checkbox and the text with the file name when form submission fails;
		<p>(<strong>Note: not a bug <i>per se</i>, but an inconsistency: the browsers don't support a default value for file upload fields for security reasons.</strong>)</p></li>
	    <li>Code cleanup;</li>
	    <li>Fixes for CMSMS Core 2.0 release;</li>
	    <li>Field table width is now 100%;</li>
	    <li>Help text re-written and English only now;</li>
    </ul>
  </li>
  <li>Version 0.7.4:
    <ul>
      <li>This release was not stable and therefore withdrawn from the Forge;</li>
    </ul>
  </li>
  <li>Version 0.7.3:
    <ul>
      <li>Compatibility release for 1.11;</li>
      <li>Adding cancel buttons to form and field instances;</li>
      <li>Removing ugly go back link;</li>
      <li>Ensuring usability in PHP strict mode;</li>
      <li>Some template fixes;</li>
      <li>NOTE: This is not feature or bug release, this is compatibility release as we ain't working with anything else than maintaining certain compatibility with this module. Stay tuned for FormBuilder2 within this year;</li>
    </ul>
  </li>
  <li>Version 0.7.2:
    <ul>
      <li>Many bug fixes;</li>
      <li>Last version of 0.x series;</li>
      <li>Fixing compability with 1.10.x series;</li>
      <li>Fixing problems with Form Browser;</li>
    </ul>
  </li>
  <li>Version 0.7.1 - (calguy1000):
    <ul>
      <li>Fixes the search for fields to not show backup files etc;</li>
      <li>Fixes a CMS Version comparison;</li>
      <li>Adds a disposition to allow selecting users to email based on an FEU property.   Also assigns smarty variables with info about matching usess;</li>
    </ul>
  </li>
	<li>Version 0.7:
		<ul>
			<li>Fixed a bug which caused the Date Submitted sorting in Form Browser to be inconsistent across pages at first;</li>
			<li>Fixed a bug which caused a Checkbox Field to be unable to be required. Checkbox Fields can now be made required;</li>
			<li>Fixed Bug #5610: File Upload Field advanced options now save correctly;</li>
			<li>Fixed Bug #5702: When using the "Frontend User binding" advanced option on the FormBrowser Disposition, checkboxes can now be saved in the "unchecked" state. Thanks Mike Hughesdon!</li>
			<li>Fixed Bug #5422: Multiple forms using the "Frontend User binding" advanced option on the FormBrowser Disposition now correctly load previously submitted data. Thanks Mike Hughesdon!</li>
			<li>Added: New Disposition - DispositionUniqueFile. Write form results to a unique file for each form submission;</li>
			<li>Added: TinyMCE integrated;</li>
			<li>Added: New Disposition - DispositionEmailBasedFrontendFields. Send form results via email with frontend-user-specified Subject, "From Name", "From Address", and Destination Address;</li>
			<li>Added: Random number generator to UniqueIntegerField;</li>
			<li>Fixed Bug #5555/#5453: Dominica (DM) is now properly selectable in the Country Picker Field;</li>
			<li>Fixed Bug #4307: Files uploaded on earlier pages of a multi-page form are now attached to Email Dispositions on later pages;</li>
			<li>Fixed Bug #3605: Dates are now translated in Email Dispositions.</li>
			<li>Fixed Bug #5358: DispositionFromEmailAddressField now creates a correct label for its input field;</li>
			<li>Fixed Bug #1822: Hidden Fields can now be edited in an Admin Form Browser;</li>
			<li>Added Feature Request #5277: Allow DispositionFormBrowser to be hidden;</li>
			<li>Several other cleanups and minor fixes;</li>
		</ul>
	</li>
	<li>Version 0.6.4.
		<ul>
			<li>Bugs fixes for Field Sorting. Thanks to everyone who reported and Stikki for fixing it!</li>
			<li>Improvements FileUpload field: overwrite flag, file renaming, and hiding filename in output;</li>
			<li>Additional patches from Ryan Foster for DatePicker;</li>
		</ul>
	</li>
  <li>Version 0.6.3:
	  <ul>
		  <li>Security patch for Upload field type;</li>
		  <li>Numerous bugs fixes. Thanks to everyone who reported;</li>
		  <li>Numerous fixes and improvements for use with FormBrowser v0.3.x;</li>
		  <li>Improvements to the ComputedField type to allow much more computation;</li>
		  <li>Vilkis' fixes for localizing CountryPicker;</li>
		  <li>Ryan Foster's patch for re-ordering date inputs on DatePicker;</li>
	  </ul>
  </li>
  <li>Version 0.6.2:
	  <ul>
		  <li>A lot of small and big bugs fixes. Thanks to everyone who reported;</li>
		  <li>Introducing dynamic field management;</li>
		  <li>New "YearPullDown" field type added;</li>
		  <li>Compatible with CMSMS 1.7.1 and further;</li>
		  <li>Added jQuery. Prototype removed completely;</li>
		  <li>Added some styling;</li>
	  </ul>
  </li>
  <li>Version 0.6.1:
	  <ul>
		  <li>Numerous Bug fixes. If your bug isn't fixed, post it in the tracker!</li>
		  <li>New Validation UDT code provided by Jeff Bosch;</li>
		  <li>Ability to reject blank/only spaces for required fields;</li>
		  <li>New "CompanyDirectory"" Field type provided by Jeremy Bass</li>
		  <li>Improvements to default value code provided by Jeremy Bass;</li>
		  <li>New "Module Interface" field type provided by Jeremy Bass;</li>
		  <li>New "User Defined Tag Call" field type;</li>
		  <li>Fix to support syntax highlighters for templates and Javascript on admin side;</li>
		  <li></li>
	  </ul>
  </li>
  <li>Version 0.6 - 30 Dec 09: Bug fixes. Finally releasing this thing!</li>
  <li>Version 0.6b2:
     <ul>
        <li>Numerous bug fixes. Thanks for all who reported on bugs!</li>
        <li>Added Form Disposition to do an HTTP GET or POST to any arbitrary URL for form handling;</li>
        <li>Added capability (and example of) advanced multipage contact form where a previous response gets displayed on a subsequent page as per uptoeleven's FR;</li>
        <li>Fix for template $fld_X remapping on XML import;</li>
        <li>Extended to provide DOM/CSS id attributes to fields;</li>
        <li>Cleaned up bad use of references for PHP 5.x;</li>
     </ul>
  </li>
  <li>Version 0.6b1:
	  <ul>
		  <li>Updated database code to be CMSMS 1.7-compatible;</li>
		  <li>Added Button field type.</li>
		  <li>Implemented FormBrowser v0.3 Disposition;</li>
		  <li>Numerous code fixes;</li>
	  </ul>
  </li>
  <li>Version 0.5.12 - 3 Sept 09: Numerous user-submitted fixes. Thanks to Calguy and Simon Schaufi;</li>
  <li>Version 0.5.11 - 19 Jan 09 (calguy1000):
    <ul>
      <li>Adds the capability to call a UDT before the form is displayed;</li>
      <li>Move changelog to an external file;</li>
    </ul>
  </li>
  <li>Version 0.5.10: 12 Jan 09. Bug fixes to restore functionality of FormBrowser;</li>
  <li>Version 0.5.9: Jan 09 (calguy1000) - Minor change to the DispositionFile class;</li>
  <li>Version 0.5.8: Jan 09 (calguy1000) - Minor change to the DispositionMultiselectFileDirector class;</li>
  <li>Version 0.5.7: Jan 09 (calguy1000) - Minor change to the DispositionMultiselectFileDirector class;</li>
  <li>Version 0.5.6: 23 Dec 08. Bug fixes;</li>
  <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>
     </ul>
  </li>
  <li>Version 0.2.4 - 09 May 2007
     <p>Big release:</p>
     <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>
  </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:</p>
     <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.</p>
        </li>
     </ul>
  </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>/classes/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/classes/ButtonField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDkgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCgpjbGFzcyBmYkJ1dHRvbkZpZWxkIGV4dGVuZHMgZmJGaWVsZEJhc2UgCnsKCiAgZnVuY3Rpb24gZmJCdXR0b25GaWVsZCgmJGZvcm1fcHRyLCAmJHBhcmFtcykKICB7CiAgICAkdGhpcy0+ZmJGaWVsZEJhc2UoJGZvcm1fcHRyLCAkcGFyYW1zKTsKICAgICRtb2QgPSAkZm9ybV9wdHItPm1vZHVsZV9wdHI7CiAgICAkdGhpcy0+VHlwZSA9ICdCdXR0b25GaWVsZCc7CiAgICAkdGhpcy0+RGlzcGxheUluRm9ybSA9IHRydWU7CiAgICAkdGhpcy0+RGlzcGxheUluU3VibWlzc2lvbiA9IGZhbHNlOwogICAgJHRoaXMtPk5vblJlcXVpcmFibGVGaWVsZCA9IHRydWU7CiAgICAkdGhpcy0+VmFsaWRhdGlvblR5cGVzID0gYXJyYXkoKTsKICAgICR0aGlzLT5zb3J0YWJsZSA9IGZhbHNlOwogIH0KCgogIGZ1bmN0aW9uIEdldEZpZWxkSW5wdXQoJGlkLCAmJHBhcmFtcywgJHJldHVybmlkKQogIHsKICAgICRtb2QgPSAkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CgkkanMgPSAkdGhpcy0+R2V0T3B0aW9uKCdqYXZhc2NyaXB0JywnJyk7CgkkY3NzaWQgPSAkdGhpcy0+R2V0Q1NTSWRUYWcoKTsKCiAgICAkcmV0ID0gJzxpbnB1dCB0eXBlPSJidXR0b24iIG5hbWU9IicuJGlkLidmYnJwX18nLiR0aGlzLT5JZC4nIiB2YWx1ZT0iJyAuCgkgICAkdGhpcy0+R2V0T3B0aW9uKCd0ZXh0JywnJykuJyIgJy4kanMuJGNzc2lkLicvPic7CgkKCXJldHVybiAkcmV0OwogIH0KCiAgZnVuY3Rpb24gUHJlUG9wdWxhdGVBZG1pbkZvcm0oJGZvcm1EZXNjcmlwdG9yKQogIHsKICAgICRtb2QgPSAkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CiAgICAkbWFpbiA9IGFycmF5KAoJCSAgYXJyYXkoJG1vZC0+TGFuZygndGl0bGVfYnV0dG9uX3RleHQnKSwKICAgICAgICAgICAgCQkkbW9kLT5DcmVhdGVJbnB1dFRleHQoJGZvcm1EZXNjcmlwdG9yLCdmYnJwX29wdF90ZXh0JywKCQkJCQkgICAgICAkdGhpcy0+R2V0T3B0aW9uKCd0ZXh0JywnJyksIDQwKSkpOwogICAgJGFkdiA9IGFycmF5KCk7CiAgICByZXR1cm4gYXJyYXkoJ21haW4nPT4kbWFpbiwnYWR2Jz0+JGFkdik7CiAgfQoKfQoKPz4K]]></data>
	</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 fbCatalogerItemsField(&$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)
  {
    $gCms = cmsms();
    $mod = $this->form_ptr->module_ptr;
    $cataloger = $mod->GetModuleInstance('Cataloger');
    
    if( !$cataloger )
    {
	    return $mod->Lang('error_cataloger_module_not_available');
    }
    
    $tmp_attrs = $this->_get_cataloger_attribute_fields();
    
    $lines = (int)$this->GetOption('lines', '5');
    $nameregex = trim($this->GetOption('nameregex', ''));
    
    $tmp_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.
    $smarty_vars_set = cms_utils::get_app_data('fb_smarty_vars_set');
    
    if( !empty($smarty_vars_set) )
    {
		  $smarty = cmsms()->GetSmarty();
		  if( !$smarty ) return;
		  $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);
        }
		  }

      cms_utils::set_app_data('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;
	$attrs = array();
	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);
	      }
	  }
   $cssid = $this->GetCSSIdTag();
	return $mod->CreateInputSelectList($id,'fbrp__'.$this->Id.'[]', $results, $val,
					   $size, $cssid);
      }

    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
    {
      $gCms = cmsms();
      
      $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('title_cataloger_attribute_fields'),$mod->Lang('help_cataloger_attribute_fields'));
      $main[] = $tmp;
      
      #$attrs = array();
      $attrs = $this->_get_cataloger_attribute_fields();
          
      foreach( $attrs as $one )
      {
        $safeattr = strtolower(preg_replace('/\W/','',$one->attr));
        if( $one->field_type == '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;
    if ($this->HasValue())
      {
	$fieldRet = array();
	if (! is_array($this->Value))
	  {
	    $this->Value = array($this->Value);
	  }
	if ($as_string)
	  {
	    return join($form->GetAttr('list_delimiter',','),$this->Value);
	  }
	else
	  {
	    return array($this->Value);
	  }			
      }
    else
      {
	if ($as_string)
	  {
	    return $mod->Lang('unspecified');
	  }
	else
	  {
	    return array($mod->Lang('unspecified'));
	  }
      }
	
  }
  
  private function _get_cataloger_attribute_fields()
  {
    $mod = $this->form_ptr->module_ptr;
    $cataloger = $mod->GetModuleInstance('Cataloger');
    
    if (!is_object($cataloger))
    {
      return array();
    }
    
    # for some odd reason cataloger is giving us and array of arrays of objects (these being the attrs)
    # so we fix it here and if any further changes occur we just have to alter one method
    # (JM)
    
    $attrs_array = $cataloger->getUserAttributes();
    $attrs = array();
    
    foreach($attrs_array as $one_array)
    {
      foreach($one_array as $one)
      {
        $attrs[] = $one;
      }
    }

    return $attrs;
  }

}
?>]]></data>
	</file>
	<file>
	  <filename>/classes/CCEmailAddressField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/CheckboxExtendedField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCglGb3JtQnVpbGRlci4gQ29weXJpZ2h0IChjKSAyMDA1LTIwMDYgU2FtdWVsIEdvbGRzdGVpbiA8c2pnQGNtc21vZHVsZXMuY29tPgoJTW9yZSBpbmZvIGF0IGh0dHA6Ly9kZXYuY21zbWFkZXNpbXBsZS5vcmcvcHJvamVjdHMvZm9ybWJ1aWxkZXIKCglBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQoJVGhpcyBwcm9qZWN0J3MgaG9tZXBhZ2UgaXM6IGh0dHA6Ly93d3cuY21zbWFkZXNpbXBsZS5vcmcKCglUaGlzIEZpZWxkIHdyaXR0ZW4gYnkgVGFwaW8gIlN0aWtraSIgTPZ5dHR5IDx0YXBzYUBibGFja21pbGsuZmk+CiovCgpjbGFzcyBmYkNoZWNrYm94RXh0ZW5kZWRGaWVsZCBleHRlbmRzIGZiRmllbGRCYXNlIHsKCglmdW5jdGlvbiBmYkNoZWNrYm94RXh0ZW5kZWRGaWVsZCgmJGZvcm1fcHRyLCAmJHBhcmFtcykKCXsKICAgICAgICBwYXJlbnQ6OmZiRmllbGRCYXNlKCRmb3JtX3B0ciwgJHBhcmFtcyk7CiAgICAgICAgJG1vZCA9ICRmb3JtX3B0ci0+bW9kdWxlX3B0cjsKCQkkdGhpcy0+VHlwZSA9ICAnQ2hlY2tib3hFeHRlbmRlZEZpZWxkJzsKCQkkdGhpcy0+RGlzcGxheUluRm9ybSA9IHRydWU7CgkJJHRoaXMtPk5vblJlcXVpcmFibGVGaWVsZCA9IHRydWU7CgkJJHRoaXMtPlZhbGlkYXRpb25UeXBlcyA9IGFycmF5KAogICAgICAgICAgICAkbW9kLT5MYW5nKCd2YWxpZGF0aW9uX25vbmUnKT0+J25vbmUnLAogICAgICAgICAgICAkbW9kLT5MYW5nKCd2YWxpZGF0aW9uX211c3RfY2hlY2snKT0+J2NoZWNrZWQnLAogICAgICAgICAgICAkbW9kLT5MYW5nKCd2YWxpZGF0aW9uX2VtcHR5Jyk9PidlbXB0eScKICAgICAgICAgICAgKTsKCQkkdGhpcy0+c29ydGFibGUgPSBmYWxzZTsKCQkkdGhpcy0+aGFzTXVsdGlwbGVGb3JtQ29tcG9uZW50cyA9IHRydWU7CSAgCSAgCgl9CgoJZnVuY3Rpb24gR2V0RmllbGRJbnB1dCgkaWQsICYkcGFyYW1zLCAkcmV0dXJuaWQpCgl7CgkJJG1vZCA9ICR0aGlzLT5mb3JtX3B0ci0+bW9kdWxlX3B0cjsKCQkkanMgPSAkdGhpcy0+R2V0T3B0aW9uKCdqYXZhc2NyaXB0JywnJyk7CgkJJGNoZWNrX3ZhbHVlID0gJHRoaXMtPl9jaGVja192YWx1ZSgpOwoJCSRvdXRwdXQgPSBhcnJheSgpOwoJCSRib3hfbGFiZWwgPSAnJzsJCQoJCSR0ZXh0X2xhYmVsID0gJyc7CQkKCQkkaHRtbDVfMCA9ICcnOwoJCSRodG1sNV8xID0gJyc7CgogICAgICAgICAgICAgICAgaWYgKCR0aGlzLT5HZXRPcHRpb24oJ2h0bWw1JywnMCcpID09ICcxJykKICAgICAgICAgICAgICAgIHsKCQkJaWYgKCR0aGlzLT5WYWxpZGF0aW9uVHlwZSA9PSAnY2hlY2tlZCcpCgkJCXsKICAgICAgICAgICAgICAgICAgICAgICAgCSRodG1sNV8wID0gJyByZXF1aXJlZCc7CgkJCX0KCgkJCSR2YWwgPSAkdGhpcy0+VmFsdWVbJ3RleHQnXTsKCQkJJGh0bWw1XzEgPSAnIHBsYWNlaG9sZGVyPSInLiR0aGlzLT5HZXRPcHRpb24oJ2RlZmF1bHQnKS4nIic7CgkJCWlmICgkdGhpcy0+VmFsaWRhdGlvblR5cGUgPT0gJ2VtcHR5JykKICAgICAgICAgICAgICAgIAl7CiAgICAgICAgICAgICAgICAgICAgICAgIAkkaHRtbDVfMSAuPSAnIHJlcXVpcmVkJzsKCQkJfQogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgZWxzZQogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgICAgICAkdmFsID0gJHRoaXMtPlZhbHVlWyd0ZXh0J10gPyAkdGhpcy0+VmFsdWVbJ3RleHQnXSA6ICR0aGlzLT5HZXRPcHRpb24oJ2RlZmF1bHQnKTsKICAgICAgICAgICAgICAgICAgICAgICAgaWYoJHRoaXMtPkdldE9wdGlvbignY2xlYXJfZGVmYXVsdCcsJzAnKSA9PSAxKQogICAgICAgICAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJGpzIC49ICcgb25mb2N1cz0iaWYodGhpcy52YWx1ZT09dGhpcy5kZWZhdWx0VmFsdWUpIHRoaXMudmFsdWU9XCdcJzsiIG9uYmx1cj0iaWYodGhpcy52YWx1ZT09XCdcJykgdGhpcy52YWx1ZT10aGlzLmRlZmF1bHRWYWx1ZTsiJzsKICAgICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgfQoKCQlpZiAoISR0aGlzLT5WYWx1ZVsnYm94J10gJiYgJHRoaXMtPkdldE9wdGlvbignaXNfY2hlY2tlZCcsJzAnKT09JzEnKSB7CgkJCgkJCSR0aGlzLT5WYWx1ZVsnYm94J10gPSAndCc7CgkJfQoJCQoJCWlmIChzdHJsZW4oJHRoaXMtPkdldE9wdGlvbignYm94X2xhYmVsJywnJykpID4gMCkgewoJCQkkYm94X2xhYmVsID0gJzxsYWJlbCBmb3I9IicuJHRoaXMtPkdldENTU0lkKCdfMCcpLiciPicuJHRoaXMtPkdldE9wdGlvbignYm94X2xhYmVsJykuJzwvbGFiZWw+JzsKCQl9CQoJCQoJCWlmIChzdHJsZW4oJHRoaXMtPkdldE9wdGlvbigndGV4dF9sYWJlbCcsJycpKSA+IDApIHsKCQkJJHRleHRfbGFiZWwgPSAnPGxhYmVsIGZvcj0iJy4kdGhpcy0+R2V0Q1NTSWQoJ18xJykuJyI+Jy4kdGhpcy0+R2V0T3B0aW9uKCd0ZXh0X2xhYmVsJykuJzwvbGFiZWw+JzsKCQl9CQoJCQoJCSRvYmogPSBuZXcgc3RkQ2xhc3MoKTsKCQkkb2JqLT5uYW1lID0gJGJveF9sYWJlbDsKCQkkb2JqLT5pbnB1dCA9ICRtb2QtPkNyZWF0ZUlucHV0Q2hlY2tib3goJGlkLCAnZmJycF9fJy4kdGhpcy0+SWQuJ1tib3hdJywgJ3QnLCR0aGlzLT5WYWx1ZVsnYm94J10sJGpzLiRodG1sNV8wLiR0aGlzLT5HZXRDU1NJZFRhZygnXzAnKSk7CgkJCgkJJG91dHB1dFtdID0gJG9iajsKCgkJaWYoJHRoaXMtPkdldE9wdGlvbignc2hvd190ZXh0ZmllbGQnKSkgewoJCQoJCQkkb2JqID0gbmV3IHN0ZENsYXNzKCk7CgkJCSRvYmotPm5hbWUgPSAkdGV4dF9sYWJlbDsKCQkJJG9iai0+aW5wdXQgPSAkbW9kLT5mYkNyZWF0ZUlucHV0VGV4dCgkaWQsICdmYnJwX18nLiR0aGlzLT5JZC4nW3RleHRdJywoJGNoZWNrX3ZhbHVlWyd0ZXh0J10/JHRoaXMtPlZhbHVlWyd0ZXh0J106JycpLDI1LDI1LCRqcy4kaHRtbDVfMS4kdGhpcy0+R2V0Q1NTSWRUYWcoJ18xJykpOwkJCgkJCQkKCQkJJG91dHB1dFtdID0gJG9iajsKCQkKCQl9CgkJCQoJCXJldHVybiAkb3V0cHV0OwoJfQoKCWZ1bmN0aW9uIEdldEh1bWFuUmVhZGFibGVWYWx1ZSgkYXNfc3RyaW5nPXRydWUpCgl7CgkJJG1vZCA9ICR0aGlzLT5mb3JtX3B0ci0+bW9kdWxlX3B0cjsKCQkkZm9ybSA9ICR0aGlzLT5mb3JtX3B0cjsKCQkkdmFsID0gJHRoaXMtPlZhbHVlOwoJCSRyZXQgPSAnJzsKCgkJaWYgKCEkdmFsWydib3gnXSkgewoJCQkKCQkJJHJldCAuPSAkdGhpcy0+R2V0T3B0aW9uKCd1bmNoZWNrZWRfdmFsdWUnLCRtb2QtPkxhbmcoJ3ZhbHVlX3VuY2hlY2tlZCcpKTsKCQl9IGVsc2UgewoJCQoJCQkkcmV0IC49ICR0aGlzLT5HZXRPcHRpb24oJ2NoZWNrZWRfdmFsdWUnLCRtb2QtPkxhbmcoJ3ZhbHVlX2NoZWNrZWQnKSk7CgkJfQkJCgoJCWlmICgkdmFsWyd0ZXh0J10gJiYgIWVtcHR5KCR2YWxbJ3RleHQnXSkpIHsKCQkKCQkJJHJldCAuPSAkZm9ybS0+R2V0QXR0cignbGlzdF9kZWxpbWl0ZXInLCcsJykuJHZhbFsndGV4dCddOwoJCQoJCX0KCQkJCgkJaWYgKCRhc19zdHJpbmcpCgkJCXsKCQkJcmV0dXJuICRyZXQ7CgkJCX0KCQllbHNlCgkJCXsKCQkJcmV0dXJuIGFycmF5KCRyZXQpOwoJCQl9Cgl9CgoKCWZ1bmN0aW9uIFN0YXR1c0luZm8oKQoJewoJCSRtb2QgPSAkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CgkJJHJldCA9ICAoJHRoaXMtPkdldE9wdGlvbignaXNfY2hlY2tlZCcsJzAnKT09JzEnPyRtb2QtPkxhbmcoJ2NoZWNrZWRfYnlfZGVmYXVsdCcpOiRtb2QtPkxhbmcoJ3VuY2hlY2tlZF9ieV9kZWZhdWx0JykpOwoJCWlmIChzdHJsZW4oJHRoaXMtPlZhbGlkYXRpb25UeXBlKT4wKQoJCSAgewoJCSAgCSRyZXQgLj0gIiwgIi5hcnJheV9zZWFyY2goJHRoaXMtPlZhbGlkYXRpb25UeXBlLCR0aGlzLT5WYWxpZGF0aW9uVHlwZXMpOwoJCSAgfQoJCXJldHVybiAkcmV0OwoJfQoKCWZ1bmN0aW9uIFByZVBvcHVsYXRlQWRtaW5Gb3JtKCRmb3JtRGVzY3JpcHRvcikKCXsKCQkkbW9kID0gJHRoaXMtPmZvcm1fcHRyLT5tb2R1bGVfcHRyOwoJCSRtYWluID0gYXJyYXkoCgkJCWFycmF5KCRtb2QtPkxhbmcoJ3RpdGxlX2NoZWNrYm94X2xhYmVsJyksCiAgICAgICAgICAgIAkJJG1vZC0+Q3JlYXRlSW5wdXRUZXh0KCRmb3JtRGVzY3JpcHRvciwgJ2ZicnBfb3B0X2JveF9sYWJlbCcsCiAgICAgICAgICAgIAkJJHRoaXMtPkdldE9wdGlvbignYm94X2xhYmVsJywnJyksMjUsMjU1KSksCgkJCWFycmF5KCRtb2QtPkxhbmcoJ3RpdGxlX3RleHRmaWVsZF9sYWJlbCcpLAogICAgICAgICAgICAJCSRtb2QtPkNyZWF0ZUlucHV0VGV4dCgkZm9ybURlc2NyaXB0b3IsICdmYnJwX29wdF90ZXh0X2xhYmVsJywKICAgICAgICAgICAgCQkkdGhpcy0+R2V0T3B0aW9uKCd0ZXh0X2xhYmVsJywnJyksMjUsMjU1KSksCQkJCQkKICAgICAgICAgICAgYXJyYXkoJG1vZC0+TGFuZygndGl0bGVfY2hlY2tlZF92YWx1ZScpLAogICAgICAgICAgICAJCSRtb2QtPkNyZWF0ZUlucHV0VGV4dCgkZm9ybURlc2NyaXB0b3IsICdmYnJwX29wdF9jaGVja2VkX3ZhbHVlJywKICAgICAgICAgICAgCQkkdGhpcy0+R2V0T3B0aW9uKCdjaGVja2VkX3ZhbHVlJywkbW9kLT5MYW5nKCd5ZXMnKSksMjUsMjU1KSksCiAgICAgICAgICAgIGFycmF5KCRtb2QtPkxhbmcoJ3RpdGxlX3VuY2hlY2tlZF92YWx1ZScpLAogICAgICAgICAgICAJCSRtb2QtPkNyZWF0ZUlucHV0VGV4dCgkZm9ybURlc2NyaXB0b3IsICdmYnJwX29wdF91bmNoZWNrZWRfdmFsdWUnLAogICAgICAgICAgICAJCSR0aGlzLT5HZXRPcHRpb24oJ3VuY2hlY2tlZF92YWx1ZScsJG1vZC0+TGFuZygnbm8nKSksMjUsMjU1KSksCgkJCWFycmF5KCRtb2QtPkxhbmcoJ3RpdGxlX2RlZmF1bHRfc2V0JyksCgkJCQkkbW9kLT5DcmVhdGVJbnB1dEhpZGRlbigkZm9ybURlc2NyaXB0b3IsJ2ZicnBfb3B0X2lzX2NoZWNrZWQnLCcwJykuJG1vZC0+Q3JlYXRlSW5wdXRDaGVja2JveCgkZm9ybURlc2NyaXB0b3IsICdmYnJwX29wdF9pc19jaGVja2VkJywgJzEnLCAkdGhpcy0+R2V0T3B0aW9uKCdpc19jaGVja2VkJywnMCcpKSksCgkJCWFycmF5KCRtb2QtPkxhbmcoJ3RpdGxlX3Nob3dfdGV4dGZpZWxkJyksCgkJCQkkbW9kLT5DcmVhdGVJbnB1dEhpZGRlbigkZm9ybURlc2NyaXB0b3IsJ2ZicnBfb3B0X3Nob3dfdGV4dGZpZWxkJywnMCcpLiRtb2QtPkNyZWF0ZUlucHV0Q2hlY2tib3goJGZvcm1EZXNjcmlwdG9yLCAnZmJycF9vcHRfc2hvd190ZXh0ZmllbGQnLCAnMScsICR0aGlzLT5HZXRPcHRpb24oJ3Nob3dfdGV4dGZpZWxkJywnMCcpKSkJCQoJCSk7CgkJCQkKICAgICAgICAgICAgICAgICRhZHYgPSBhcnJheSgKICAgICAgICAgICAgICAgICAgICAgICAgYXJyYXkoJG1vZC0+TGFuZygndGl0bGVfZmllbGRfZGVmYXVsdF92YWx1ZScpLCRtb2QtPkNyZWF0ZUlucHV0VGV4dCgkZm9ybURlc2NyaXB0b3IsICdmYnJwX29wdF9kZWZhdWx0JywkdGhpcy0+R2V0T3B0aW9uKCdkZWZhdWx0JyksMjUsMTAyNCkpLAogICAgICAgICAgICAgICAgICAgICAgICBhcnJheSgkbW9kLT5MYW5nKCd0aXRsZV9jbGVhcl9kZWZhdWx0JyksJG1vZC0+Q3JlYXRlSW5wdXRIaWRkZW4oJGZvcm1EZXNjcmlwdG9yLCdmYnJwX29wdF9jbGVhcl9kZWZhdWx0JywnMCcpLgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICRtb2QtPkNyZWF0ZUlucHV0Q2hlY2tib3goJGZvcm1EZXNjcmlwdG9yLCAnZmJycF9vcHRfY2xlYXJfZGVmYXVsdCcsJzEnLCR0aGlzLT5HZXRPcHRpb24oJ2NsZWFyX2RlZmF1bHQnLCcwJykpLic8YnIgLz4nLgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICRtb2QtPkxhbmcoJ3RpdGxlX2NsZWFyX2RlZmF1bHRfaGVscCcpKQogICAgICAgICAgICAgICAgKTsKCgkJcmV0dXJuIGFycmF5KCdtYWluJz0+JG1haW4sJ2Fkdic9PiRhZHYpOwoJfQoKCWZ1bmN0aW9uIFZhbGlkYXRlKCkKCXsKCQkkbW9kID0gJHRoaXMtPmZvcm1fcHRyLT5tb2R1bGVfcHRyOwoJCSR0aGlzLT52YWxpZGF0ZWQgPSB0cnVlOwoJCSR0aGlzLT52YWxpZGF0aW9uRXJyb3JUZXh0ID0gJyc7CgoJCXN3aXRjaCAoJHRoaXMtPlZhbGlkYXRpb25UeXBlKQoJCSAgewoJCSAgCSAgIGNhc2UgJ25vbmUnOgoJCSAgCSAgICAgICBicmVhazsKCQkgIAkgICBjYXNlICdjaGVja2VkJzoKCQkgIAkgICAgICAgaWYgKCR0aGlzLT5WYWx1ZVsnYm94J10gPT0gZmFsc2UpCgkJICAJICAgICAgICAgICB7CgkJICAJICAgICAgICAgICAkdGhpcy0+dmFsaWRhdGVkID0gZmFsc2U7CgkJICAJICAgICAgICAgICAkdGhpcy0+dmFsaWRhdGlvbkVycm9yVGV4dCA9ICRtb2QtPkxhbmcoJ3lvdV9tdXN0X2NoZWNrJywkdGhpcy0+R2V0T3B0aW9uKCdib3hfbGFiZWwnLCcnKSk7CgkJICAJICAgICAgICAgICB9CgkJICAJICAgICAgIGJyZWFrOwoJCSAgCSAgIGNhc2UgJ2VtcHR5JzoKCQkgIAkgICAgICAgaWYgKGVtcHR5KCR0aGlzLT5WYWx1ZVsndGV4dCddKSkKCQkgIAkgICAgICAgICAgIHsKCQkgIAkgICAgICAgICAgICR0aGlzLT52YWxpZGF0ZWQgPSBmYWxzZTsKCQkgIAkgICAgICAgICAgICR0aGlzLT52YWxpZGF0aW9uRXJyb3JUZXh0ID0gJG1vZC0+TGFuZygncGxlYXNlX2VudGVyX2FfdmFsdWUnLCR0aGlzLT5HZXRPcHRpb24oJ3RleHRfbGFiZWwnLCcnKSk7CgkJICAJICAgICAgICAgICB9CgkJICAJICAgICAgIGJyZWFrOwoKCQkJCSAgIAoJCSAgfQoJCXJldHVybiBhcnJheSgkdGhpcy0+dmFsaWRhdGVkLCAkdGhpcy0+dmFsaWRhdGlvbkVycm9yVGV4dCk7Cgl9CgoJCglwcml2YXRlIGZ1bmN0aW9uIF9jaGVja192YWx1ZSgpIHsKCQkKCQkkdmFsID0gJHRoaXMtPlZhbHVlOwoJCSR2YWxpZCA9IGFycmF5KCdib3gnPT5mYWxzZSwgJ3RleHQnPT5mYWxzZSk7CgkKCQlpZigkdmFsID09PSBmYWxzZSkgewoJCQoJCQlyZXR1cm4gZmFsc2U7CgkJfQoJCgkJaWYoaXNzZXQoJHZhbFsnYm94J10pKSB7CgkJCgkJCSR2YWxpZFsnYm94J10gPSB0cnVlOwoJCX0KCQkKCQlpZihpc3NldCgkdmFsWyd0ZXh0J10pICYmICFlbXB0eSgkdmFsWyd0ZXh0J10pKSB7CgkJCgkJCSR2YWxpZFsndGV4dCddID0gdHJ1ZTsKCQl9IAoJCQoJCXJldHVybiB2YWxpZDsKCQoJfQoJCn0gLy8gZW5kIG9mIGNsYXNzCgo/Pgo=]]></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;
	
	// Constructor
	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 = false;
		$this->ValidationTypes = array();
        $this->boxAdd = 0;
        $this->hasMultipleFormComponents = true;
        $this->sortable = false;
	}

	// Count how many boxes we have
	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;
	    }
	}

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

	// Get add button
	function GetOptionAddButton()
	{
		$mod = $this->form_ptr->module_ptr;
		return $mod->Lang('add_checkboxes');
	}

	// Get delete button
	function GetOptionDeleteButton()
	{
		$mod = $this->form_ptr->module_ptr;
		return $mod->Lang('delete_checkboxes');
	}

	// Get input
	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="'.$this->GetCSSId('_'.$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',$js.$this->GetCSSIdTag('_'.$i));

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

	// Get Human readable value
	function GetHumanReadableValue($as_string=true)
	{
		$form = $this->form_ptr;
		
		// Init names
		$names = $this->GetOptionRef('box_name');
		if (! is_array($names)) {
		
				$names = array($names);
		}
		
		// Init checked boxes
		$checked = $this->GetOptionRef('box_checked');
		if (! is_array($checked)) {
		
			$checked = array($checked);
		}
		
		// Init unchecked boxes
		$unchecked = $this->GetOptionRef('box_unchecked');
		if (! is_array($unchecked)) {
		
			$unchecked = array($unchecked);
		}
		
		//$fieldLabels = array();
		$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[$names[$i-1]] = $unchecked[$i-1];
				}
			} else {
				
				if( isset($checked[$i-1]) && trim($checked[$i-1]) != '' ) $fieldRet[$names[$i-1]] = $checked[$i-1];
			}
		}
		
		if ($as_string) {
			
			// Check if we should include labels
			if($this->GetOption('include_labels','0') == true) {
			
				$output = '';
				foreach($fieldRet as $key=>$value) {
				
					$output .= $key.': '.$value.$form->GetAttr('list_delimiter',',');
				
				}
			
				$output = substr($output,0,strlen($output)-1);
				return $output;
			}
			
			return join($form->GetAttr('list_delimiter',','),$fieldRet);
			
		} else {
		
			return $fieldRet;
		}
	}

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

	// Delete action
	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++;
				}
			}
	}

	// Populate tabs
	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 pagetable" cellpadding="0" cellspacing="0"><thead><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></thead><tbody>';

		$rowclass = 'row1';
		for ($i=0;$i<($this->boxCount>1?$this->boxCount:1);$i++)
			{
			$boxes .= '<tr class="'.$rowclass.'"><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>'.
            		$mod->CreateInputCheckbox($formDescriptor, 'fbrp_del_'.$i, $i,-1).
             		'</td></tr>';
					
			($rowclass == 'row1'?$rowclass='row2':$rowclass='row1');
			}
		$boxes .= '</tbody></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(
			array($mod->Lang('title_field_includelabels'),$mod->CreateInputHidden($formDescriptor,'fbrp_opt_include_labels','0').
						$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_include_labels','1',$this->GetOption('include_labels','0')).$mod->Lang('title_field_includelabels_help'))
		);
		
		return array('main'=>$main,'adv'=>$adv);
	}


	// Before admin submit do cleanup
	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();
	}
	
} // End of Class

?>
]]></data>
	</file>
	<file>
	  <filename>/classes/CompanyDirectoryField.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 CompanyDirectory 
 * the item list is filtered by an array
 * of options as specified in the admin.
 * This Field written by Jeremy Bass <jeremyBass@cableone.net>
 */
class fbCompanyDirectoryField extends fbFieldBase {

  var $optionCount;
  var $optionAdd;

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


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

    $mod = $this->form_ptr->module_ptr;
    $CompanyDirectory = $mod->GetModuleInstance('CompanyDirectory');
    if( !$CompanyDirectory )
      {
	return $mod->Lang('error_CompanyDirectory_module_not_available');
      }

    $results = array();

		$db = $gCms->GetDb();
 		$Like=$this->GetOption('Category','%');
		if($Like==''||$Like=='%'||$Like=='All'){
			$processPath="LIKE  '%'";
		}else{
			$processPath="=  ?";
		}
 		$query = 'SELECT com.id, com.company_name FROM '.cms_db_prefix().'module_compdir_company_categories AS comcat '
				.'LEFT JOIN '.cms_db_prefix().'module_compdir_categories AS cat ON cat.id = comcat.category_id '
				.'LEFT JOIN '.cms_db_prefix().'module_compdir_companies AS com ON com.id = comcat.company_id '
				.'WHERE cat.name '.$processPath.' AND status = \'published\'';

		$query2 = 'SELECT value FROM '.cms_db_prefix().'module_compdir_fieldvals AS comfv '
				.'LEFT JOIN '.cms_db_prefix().'module_compdir_fielddefs AS fdd ON fdd.id = comfv.fielddef_id '
				.'LEFT JOIN '.cms_db_prefix().'module_compdir_companies AS com ON comfv.company_id = com.id '
				.'WHERE com.company_name = ? AND fdd.name = ?';
		$val=array();
		$companies = array();
		$field=$this->GetOption('FieldDefs','');
		if($Like==''||$Like=='%'||$Like=='All'){
			$dbr = $db->Execute( $query , array());
				while( $dbr && ($row = $dbr->FetchRow()) ){
					$company=$row['company_name'];
					$FDval='';
					$dbr2 = $db->Execute( $query2 , array($company,$field));
						while( $dbr2 && ($row = $dbr2->FetchRow()) ){
							$FDval=$row['value'];
						}
					$companies[$company] = $FDval;
				}

		}else{
			if(is_array($Like)){
				foreach($Like as $key => $value){
					$dbr = $db->Execute( $query , array($value));
						while( $dbr && ($row = $dbr->FetchRow()) ){
							$company=$row['company_name'];
							$FDval='';
							$dbr2 = $db->Execute( $query2 , array($company,$field));
								while( $dbr2 && ($row = $dbr2->FetchRow()) ){
									$FDval=$row['value'];
								}
							$companies[$company] = $FDval;
						}
				}
			}else{
				$dbr = $db->Execute( $query , array($Like));
					while( $dbr && ($row = $dbr->FetchRow()) ){
							$company=$row['company_name'];
							$FDval='';
							$dbr2 = $db->Execute( $query2 , array($company,$field));
								while( $dbr2 && ($row = $dbr2->FetchRow()) ){
									$FDval=$row['value'];
								}
							$companies[$company] = $FDval;
					}
			}
		}

      foreach($companies as $key=>$val)
         {
         if (empty($val))
            {
            $companies[$key]=$key;
            }
         }
		// All done, do we have something to display?
		if( count($companies) ){
			$size = min(50,count($companies)); // 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);
				}
			}
			
			$cssid = $this->GetCSSIdTag();
			$UserInput = $this->GetOption('UserInput','Dropdown');
			if($UserInput=='Select List-single'){
				return $mod->CreateInputSelectList($id,'fbrp__'.$this->Id.'[]', $companies, $val, $size, $cssid);
			}elseif($UserInput=='Select List-multiple'){
				return $mod->CreateInputSelectList($id,'fbrp__'.$this->Id.'[]', $companies, $val, $size, $cssid, true);
			}elseif($UserInput=='Dropdown'){
				return $mod->CreateInputDropdown($id,'fbrp__'.$this->Id.'', $companies, '-1', $val);
			}elseif($UserInput=='Radio Group'){
				return $mod->CreateInputRadioGroup($id,'fbrp__'.$this->Id.'', $companies, $val,'',' ');
			}
		}

    return ''; // error
	}


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

  function PrePopulateAdminForm($formDescriptor)
  {
    $mod = $this->form_ptr->module_ptr;
	$gCms = cmsms();
   //$CompanyDirectory = $mod->GetModuleInstance('CompanyDirectory');
	 $db =& $gCms->GetDb();
		$query = 'SELECT id, name FROM '.cms_db_prefix().'module_compdir_categories ';
		$dbr = $db->Execute( $query , array());
		$Categories = array();
		$Categories['All'] = 'All';
		while( $dbr && ($row = $dbr->FetchRow()) )
		{
			$Categories[$row['name']] = $row['name'];
		}
		$CategorySelected=$this->GetOption('Category','');

		$query = 'SELECT * FROM '.cms_db_prefix().'module_compdir_fielddefs ORDER BY item_order';
		$dbr = $db->Execute( $query , array());
		$FieldDefs = array();
		$FieldDefs['none'] = 'none';
		while( $dbr && ($row = $dbr->FetchRow()) )
		{
			$FieldDefs[$row['name']] = $row['name'];
		}
		$FieldDefsSelected=$this->GetOption('FieldDefs','');
		
		//check and force the right type
		if(!is_array($CategorySelected)){$CategorySelected=explode(',',$CategorySelected);}
		if(!is_array($FieldDefsSelected)){$FieldDefsSelected=explode(',',$FieldDefsSelected);}		
		
		
		$Useinput=array($mod->Lang('option_dropdown')=>'Dropdown',
			   $mod->Lang('option_selectlist_single')=>'Select List-single',
			   $mod->Lang('option_selectlist_multiple')=>'Select List-multiple',
			   $mod->Lang('option_radiogroup')=>'Radio Group'
			   );
		
		$main = array(
				array($mod->Lang('title_company_field_note'),''),  
				array($mod->Lang('title_pick_categories'),
					$mod->CreateInputSelectList($formDescriptor,'fbrp_opt_Category[]', $Categories, $CategorySelected, 5,'',true)
				),
				array($mod->Lang('title_pick_fielddef'),
					$mod->CreateInputSelectList($formDescriptor,'fbrp_opt_FieldDefs', $FieldDefs, $FieldDefsSelected, 5,'',false)
				)
		);
		$adv = array(
				array($mod->Lang('title_choose_user_input'),
					$mod->CreateInputDropdown ($formDescriptor,'fbrp_opt_UserInput', $Useinput, '-1', $this->GetOption('UserInput','')) 
				)
		);
		return array('main'=>$main,'adv'=>$adv);
  }

  function GetHumanReadableValue($as_string=true)
  {
    $mod = $this->form_ptr->module_ptr;
    $form = $this->form_ptr;
    if ($this->HasValue())
      {
	$fieldRet = array();
	if (! is_array($this->Value))
	  {
	    $this->Value = array($this->Value);
	  }
	if ($as_string)
	  {
	    return join($form->GetAttr('list_delimiter',','),$this->Value);
	  }
	else
	  {
	    return array($this->Value);
	  }			
      }
    else
      {
	if ($as_string)
	  {
	    return $mod->Lang('unspecified');
	  }
	else
	  {
	    return array($mod->Lang('unspecified'));
	  }
      }
	
  }

}
?>
]]></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')=>'',
				$mod->Lang('AD') =>'AD',
				$mod->Lang('AE') =>'AE',
				$mod->Lang('AF') =>'AF',
				$mod->Lang('AG') =>'AG',
				$mod->Lang('AI') =>'AI',
				$mod->Lang('AL') =>'AL',
				$mod->Lang('AM') =>'AM',
				$mod->Lang('AN') =>'AN',
				$mod->Lang('AO') =>'AO',
				$mod->Lang('AQ') =>'AQ',
				$mod->Lang('AR') =>'AR',
				$mod->Lang('AS') =>'AS',
				$mod->Lang('AT') =>'AT',
				$mod->Lang('AU') =>'AU',
				$mod->Lang('AW') =>'AW',
				$mod->Lang('AX') =>'AX',
				$mod->Lang('AZ') =>'AZ',
				$mod->Lang('BA') =>'BA',
				$mod->Lang('BB') =>'BB',
				$mod->Lang('BD') =>'BD',
				$mod->Lang('BE') =>'BE',
				$mod->Lang('BF') =>'BF',
				$mod->Lang('BG') =>'BG',
				$mod->Lang('BH') =>'BH',
				$mod->Lang('BI') =>'BI',
				$mod->Lang('BJ') =>'BJ',
				$mod->Lang('BM') =>'BM',
				$mod->Lang('BN') =>'BN',
				$mod->Lang('BO') =>'BO',
				$mod->Lang('BR') =>'BR',
				$mod->Lang('BS') =>'BS',
				$mod->Lang('BT') =>'BT',
				$mod->Lang('BV') =>'BV',
				$mod->Lang('BW') =>'BW',
				$mod->Lang('BY') =>'BY',
				$mod->Lang('BZ') =>'BZ',
				$mod->Lang('CA') =>'CA',
				$mod->Lang('CC') =>'CC',
				$mod->Lang('CD') =>'CD',
				$mod->Lang('CF') =>'CF',
				$mod->Lang('CG') =>'CG',
				$mod->Lang('CH') =>'CH',
				$mod->Lang('CI') =>'CI',
				$mod->Lang('CK') =>'CK',
				$mod->Lang('CL') =>'CL',
				$mod->Lang('CM') =>'CM',
				$mod->Lang('CN') =>'CN',
				$mod->Lang('CO') =>'CO',
				$mod->Lang('CR') =>'CR',
				$mod->Lang('CU') =>'CU',
				$mod->Lang('CV') =>'CV',
				$mod->Lang('CX') =>'CX',
				$mod->Lang('CY') =>'CY',
				$mod->Lang('CZ') =>'CZ',
				$mod->Lang('DE') =>'DE',
				$mod->Lang('DJ') =>'DJ',
				$mod->Lang('DK') =>'DK',
				$mod->Lang('DM') =>'DM',
				$mod->Lang('DO') =>'DO',
				$mod->Lang('DZ') =>'DZ',
				$mod->Lang('EC') =>'EC',
				$mod->Lang('EE') =>'EE',
				$mod->Lang('EG') =>'EG',
				$mod->Lang('EH') =>'EH',
				$mod->Lang('ER') =>'ER',
				$mod->Lang('ES') =>'ES',
				$mod->Lang('ET') =>'ET',
				$mod->Lang('FI') =>'FI',
				$mod->Lang('FJ') =>'FJ',
				$mod->Lang('FK') =>'FK',
				$mod->Lang('FM') =>'FM',
				$mod->Lang('FO') =>'FO',
				$mod->Lang('FR') =>'FR',
				$mod->Lang('FX') =>'FX',
				$mod->Lang('GA') =>'GA',
				$mod->Lang('GB') =>'GB',
				$mod->Lang('GD') =>'GD',
				$mod->Lang('GE') =>'GE',
				$mod->Lang('GF') =>'GF',
				$mod->Lang('GF') =>'GF',
				$mod->Lang('GH') =>'GH',
				$mod->Lang('GI') =>'GI',
				$mod->Lang('GL') =>'GL',
				$mod->Lang('GM') =>'GM',
				$mod->Lang('GN') =>'GN',
				$mod->Lang('GP') =>'GP',
				$mod->Lang('GQ') =>'GQ',
				$mod->Lang('GR') =>'GR',
				$mod->Lang('GS') =>'GS',
				$mod->Lang('GT') =>'GT',
				$mod->Lang('GU') =>'GU',
				$mod->Lang('GW') =>'GW',
				$mod->Lang('GY') =>'GY',
				$mod->Lang('HK') =>'HK',
				$mod->Lang('HM') =>'HM',
				$mod->Lang('HN') =>'HN',
				$mod->Lang('HR') =>'HR',
				$mod->Lang('HT') =>'HT',
				$mod->Lang('HU') =>'HU',
				$mod->Lang('ID') =>'ID',
				$mod->Lang('IE') =>'IE',
				$mod->Lang('IL') =>'IL',
				$mod->Lang('IM') =>'IM',
				$mod->Lang('IN') =>'IN',
				$mod->Lang('IO') =>'IO',
				$mod->Lang('IQ') =>'IQ',
				$mod->Lang('IR') =>'IR',
				$mod->Lang('IS') =>'IS',
				$mod->Lang('IT') =>'IT',
				$mod->Lang('JE') =>'JE',
				$mod->Lang('JM') =>'JM',
				$mod->Lang('JO') =>'JO',
				$mod->Lang('JP') =>'JP',
				$mod->Lang('KE') =>'KE',
				$mod->Lang('KG') =>'KG',
				$mod->Lang('KH') =>'KH',
				$mod->Lang('KI') =>'KI',
				$mod->Lang('KM') =>'KM',
				$mod->Lang('KN') =>'KN',
				$mod->Lang('KP') =>'KP',
				$mod->Lang('KR') =>'KR',
				$mod->Lang('KW') =>'KW',
				$mod->Lang('KY') =>'KY',
				$mod->Lang('KZ') =>'KZ',
				$mod->Lang('LA') =>'LA',
				$mod->Lang('LB') =>'LB',
				$mod->Lang('LC') =>'LC',
				$mod->Lang('LI') =>'LI',
				$mod->Lang('LK') =>'LK',
				$mod->Lang('LR') =>'LR',
				$mod->Lang('LS') =>'LS',
				$mod->Lang('LT') =>'LT',
				$mod->Lang('LU') =>'LU',
				$mod->Lang('LV') =>'LV',
				$mod->Lang('LY') =>'LY',
				$mod->Lang('MA') =>'MA',
				$mod->Lang('MC') =>'MC',
				$mod->Lang('MD') =>'MD',
				$mod->Lang('MG') =>'MG',
				$mod->Lang('MH') =>'MH',
				$mod->Lang('MK') =>'MK',
				$mod->Lang('ML') =>'ML',
				$mod->Lang('MM') =>'MM',
				$mod->Lang('MN') =>'MN',
				$mod->Lang('MO') =>'MO',
				$mod->Lang('MP') =>'MP',
				$mod->Lang('MQ') =>'MQ',
				$mod->Lang('MR') =>'MR',
				$mod->Lang('MS') =>'MS',
				$mod->Lang('MT') =>'MT',
				$mod->Lang('MU') =>'MU',
				$mod->Lang('MV') =>'MV',
				$mod->Lang('MW') =>'MW',
				$mod->Lang('MX') =>'MX',
				$mod->Lang('MY') =>'MY',
				$mod->Lang('MZ') =>'MZ',
				$mod->Lang('NA') =>'NA',
				$mod->Lang('NC') =>'NC',
				$mod->Lang('NE') =>'NE',
				$mod->Lang('NF') =>'NF',
				$mod->Lang('NG') =>'NG',
				$mod->Lang('NI') =>'NI',
				$mod->Lang('NL') =>'NL',
				$mod->Lang('NO') =>'NO',
				$mod->Lang('NP') =>'NP',
				$mod->Lang('NR') =>'NR',
				$mod->Lang('NT') =>'NT',
				$mod->Lang('NU') =>'NU',
				$mod->Lang('NZ') =>'NZ',
				$mod->Lang('OM') =>'OM',
				$mod->Lang('PA') =>'PA',
				$mod->Lang('PE') =>'PE',
				$mod->Lang('PF') =>'PF',
				$mod->Lang('PG') =>'PG',
				$mod->Lang('PH') =>'PH',
				$mod->Lang('PK') =>'PK',
				$mod->Lang('PL') =>'PL',
				$mod->Lang('PM') =>'PM',
				$mod->Lang('PN') =>'PN',
				$mod->Lang('PR') =>'PR',
				$mod->Lang('PS') =>'PS',
				$mod->Lang('PT') =>'PT',
				$mod->Lang('PW') =>'PW',
				$mod->Lang('PY') =>'PY',
				$mod->Lang('QA') =>'QA',
				$mod->Lang('RE') =>'RE',
				$mod->Lang('RO') =>'RO',
				$mod->Lang('RS') =>'RS',
				$mod->Lang('RU') =>'RU',
				$mod->Lang('RW') =>'RW',
				$mod->Lang('SA') =>'SA',
				$mod->Lang('SB') =>'SB',
				$mod->Lang('SC') =>'SC',
				$mod->Lang('SD') =>'SD',
				$mod->Lang('SE') =>'SE',
				$mod->Lang('SG') =>'SG',
				$mod->Lang('SH') =>'SH',
				$mod->Lang('SI') =>'SI',
				$mod->Lang('SJ') =>'SJ',
				$mod->Lang('SK') =>'SK',
				$mod->Lang('SL') =>'SL',
				$mod->Lang('SM') =>'SM',
				$mod->Lang('SN') =>'SN',
				$mod->Lang('SO') =>'SO',
				$mod->Lang('SR') =>'SR',
				$mod->Lang('ST') =>'ST',
				$mod->Lang('SV') =>'SV',
				$mod->Lang('SY') =>'SY',
				$mod->Lang('SZ') =>'SZ',
				$mod->Lang('TC') =>'TC',
				$mod->Lang('TD') =>'TD',
				$mod->Lang('TF') =>'TF',
				$mod->Lang('TG') =>'TG',
				$mod->Lang('TH') =>'TH',
				$mod->Lang('TJ') =>'TJ',
				$mod->Lang('TK') =>'TK',
				$mod->Lang('TM') =>'TM',
				$mod->Lang('TN') =>'TN',
				$mod->Lang('TO') =>'TO',
				$mod->Lang('TP') =>'TP',
				$mod->Lang('TR') =>'TR',
				$mod->Lang('TT') =>'TT',
				$mod->Lang('TV') =>'TV',
				$mod->Lang('TW') =>'TW',
				$mod->Lang('TZ') =>'TZ',
				$mod->Lang('UA') =>'UA',
				$mod->Lang('UG') =>'UG',
				$mod->Lang('UK') =>'UK',
				$mod->Lang('UM') =>'UM',
				$mod->Lang('US') =>'US',
				$mod->Lang('UY') =>'UY',
				$mod->Lang('UZ') =>'UZ',
				$mod->Lang('VA') =>'VA',
				$mod->Lang('VC') =>'VC',
				$mod->Lang('VE') =>'VE',
				$mod->Lang('VG') =>'VG',
				$mod->Lang('VI') =>'VI',
				$mod->Lang('VN') =>'VN',
				$mod->Lang('VU') =>'VU',
				$mod->Lang('WF') =>'WF',
				$mod->Lang('WS') =>'WS',
				$mod->Lang('YE') =>'YE',
				$mod->Lang('YT') =>'YT',
				$mod->Lang('YU') =>'YU',
				$mod->Lang('ZA') =>'ZA',
				$mod->Lang('ZM') =>'ZM',
				$mod->Lang('ZW') =>'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;
                $html5 = '';

                if ($this->GetOption('html5','0') == '1'&& $this->IsRequired()) 
		{
			$html5 = ' required';
                }
		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_country','') != '')
		  {
		  $this->SetValue($this->GetOption('default_country',''));
		  }

		return $mod->CreateInputDropdown($id, 'fbrp__'.$this->Id, $this->Countries, -1,
         $this->Value, $html5.$js.$this->GetCSSIdTag());
	}

	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_country',
            		$this->Countries, -1, $this->GetOption('default_country',''))),
			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());
	}
}

#
# EOF
#
?>
]]></data>
	</file>
	<file>
	  <filename>/classes/DatePickerField.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 fbDatePickerField extends fbFieldBase {

	var $Months;
	
	function fbDatePickerField(&$form_ptr, &$params)
	{
        $mod = $form_ptr->module_ptr;	
	
        $this->fbFieldBase($form_ptr, $params);
		$this->Type = 'DatePickerField';
		$this->DisplayInForm = true;
		$this->ValidationTypes = array(
            $mod->Lang('validation_none')=>'none',
            );
        $this->Months = array(
			''=>'',
            $mod->Lang('date_january')=>1,
            $mod->Lang('date_february')=>2,
            $mod->Lang('date_march')=>3,
            $mod->Lang('date_april')=>4,
            $mod->Lang('date_may')=>5,
            $mod->Lang('date_june')=>6,
            $mod->Lang('date_july')=>7,
            $mod->Lang('date_august')=>8,
            $mod->Lang('date_september')=>9,
            $mod->Lang('date_october')=>10,
            $mod->Lang('date_november')=>11,
            $mod->Lang('date_december')=>12);
    $this->hasMultipleFormComponents = true;
    $this->labelSubComponents = false;
	}


    function StatusInfo()
	{
      $mod = $this->form_ptr->module_ptr;
      $today = getdate();
		return $mod->Lang("date_range",array($this->GetOption('start_year',($today['year']-10)) ,
         $this->GetOption('end_year',($today['year']+10)))).
         ($this->GetOption('default_year','-1')!=='-1'?' ('.$this->GetOption('default_year','-1').')':'');
	}


	function GetFieldInput($id, &$params, $returnid)
	{
		$mod = $this->form_ptr->module_ptr;
       $today = getdate();
       $Days = array(''=>'');
       for ($i=1;$i<32;$i++)
         {
         	$Days[$i]=$i;
         }
       $Year = array(''=>'');
	   $sty = $this->GetOption('start_year',($today['year']-10));
	   if ($sty == -1)
			{
			$sty = $today['year'];
			}
       for ($i=$sty;$i<$this->GetOption('end_year',($today['year']+10))+1;$i++)
         {
         	$Year[$i]=$i;
         }
		if ($this->HasValue())
			{
			$user_order = $this->GetOption('date_order','d-m-y');
			$arrUserOrder = explode("-", $user_order);
			
			$today['mday'] = $this->GetArrayValue(array_search("d", $arrUserOrder));
			$today['mon'] = $this->GetArrayValue(array_search("m", $arrUserOrder));
			$today['year'] = $this->GetArrayValue(array_search("y", $arrUserOrder));
			}
		else if ($this->GetOption('default_blank','0') == '1')
			{
			$today['mday']='';
			$today['mon']='';
			$today['year']='';
			}
		else if ($this->GetOption('default_year','-1') != '-1')
		   {
         $today['year'] = $this->GetOption('default_year','-1');
         }

      $ret = array();
      $day = new stdClass();
	  $js = $this->GetOption('javascript','');

      $day->input = $mod->CreateInputDropdown($id, 'fbrp__'.$this->Id.'[]', $Days, -1,
          $today['mday'], $js.$this->GetCSSIdTag('_day'));
 		$day->title = $mod->Lang('day');
 		$day->name = '<label for="'.$this->GetCSSId('_day').'">'.$mod->Lang('day').'</label>';
 
      $mon = new stdClass();
	$month_format = $this->GetOption('month_input','t');
	$months = $this->Months;
	if( $month_format != 't' )
	{
		$months = array();
		foreach($this->Months as $name=>$value)
		{
			if( $month_format == 'n' )
			{
				$months[$value] = $value;
			}
			else
			{
				$months[$value." - ".$name] = $value;
			}
		}
	}
      $mon->input = $mod->CreateInputDropdown($id, 'fbrp__'.$this->Id.'[]', $months, -1,
          $today['mon'], $js.$this->GetCSSIdTag('_month'));
 		$mon->title = $mod->Lang('mon');
 		$mon->name = '<label for="'.$this->GetCSSId('_month').'">'.$mod->Lang('mon').'</label>';
 
      $yr = new stdClass();
      $yr->input = $mod->CreateInputDropdown($id, 'fbrp__'.$this->Id.'[]', $Year, -1,
         $today['year'],$js.$this->GetCSSIdTag('_year'));
      $yr->name = '<label for="'.$this->GetCSSId('_year').'">'.$mod->Lang('year').'</label>';
      $yr->title = $mod->Lang('year');

		$order = array("d" => $day, "m" => $mon, "y" => $yr);
		$user_order = $this->GetOption('date_order','d-m-y');
		$arrUserOrder = explode("-", $user_order);
		foreach ($arrUserOrder as $key)
			{
			array_push($ret, $order[$key]);
			}

      return $ret;
	}

	function GetHumanReadableValue($as_string=true)
	{
		$mod = $this->form_ptr->module_ptr;
		if ($this->HasValue())
			{
			// Original:  Day, Month, Year
			//$theDate = mktime ( 1, 1, 1, $this->GetArrayValue(1),  $this->GetArrayValue(0), $this->GetArrayValue(2) );
			// Month, Day, Year
			//$theDate = mktime ( 1, 1, 1, $this->GetArrayValue(0),  $this->GetArrayValue(1), $this->GetArrayValue(2) );
			$user_order = $this->GetOption('date_order','d-m-y');
			$arrUserOrder = explode("-", $user_order);
			$theDate = mktime ( 1, 1, 1,
				$this->GetArrayValue(array_search("m", $arrUserOrder)),
				$this->GetArrayValue(array_search("d", $arrUserOrder)),
				$this->GetArrayValue(array_search("y", $arrUserOrder)) );
			$ret = date($this->GetOption('date_format','j F Y'), $theDate);
			
			$ret = str_replace(array("January","February","March","April","May","June","July","August","September","October","November","December"),
				array(
					$mod->Lang('date_january'),
					$mod->Lang('date_february'),
					$mod->Lang('date_march'),
					$mod->Lang('date_april'),
					$mod->Lang('date_may'),
					$mod->Lang('date_june'),
					$mod->Lang('date_july'),
					$mod->Lang('date_august'),
					$mod->Lang('date_september'),
					$mod->Lang('date_october'),
					$mod->Lang('date_november'),
					$mod->Lang('date_december')
					),
				$ret);
			$ret = html_entity_decode($ret, ENT_QUOTES, 'UTF-8');
		}
		else
			{
			$ret = $this->form_ptr->GetAttr('unspecified',$mod->Lang('unspecified'));
			}
		if ($as_string)
			{
			return $ret;
			}
		else
			{
			return array($ret);
			}
	}

	function PrePopulateAdminForm($formDescriptor)
	{
		$mod = $this->form_ptr->module_ptr;
      		$today = getdate();
		$opts = array($mod->Lang('opt_month_input_text')=>'t',$mod->Lang('opt_month_input_number')=>'n',$mod->Lang('opt_month_input_both')=>'b');
		$main = array(
			array($mod->Lang('title_date_format'),
            		array($mod->CreateInputText($formDescriptor, 'fbrp_opt_date_format',
            		$this->GetOption('date_format','j F Y'),25,25),$mod->Lang('help_date_format'))
		    ),
			array($mod->Lang('title_date_order'),
					array($mod->CreateInputText($formDescriptor, 'fbrp_opt_date_order',
					$this->GetOption('date_order','d-m-y'),5,5),$mod->Lang('help_date_order'))
			),
			array($mod->Lang('title_month_input'),
					$mod->CreateInputDropdown($formDescriptor, 'fbrp_opt_month_input',
					$opts, -1, $this->GetOption('month_input','t'))
			),
		   array($mod->Lang('title_default_blank'),
            		$mod->CreateInputHidden($formDescriptor,'fbrp_opt_default_blank','0').
					$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_default_blank',
            		'1',$this->GetOption('default_blank','0')).$mod->Lang('title_default_blank_help')),
		   array($mod->Lang('title_start_year'),
            		$mod->CreateInputText($formDescriptor, 'fbrp_opt_start_year',
            		    $this->GetOption('start_year',($today['year']-10)),10,10)),
		   array($mod->Lang('title_end_year'),
            		$mod->CreateInputText($formDescriptor, 'fbrp_opt_end_year',
            		    $this->GetOption('end_year',($today['year']+10)),10,10)),
		   array($mod->Lang('title_default_year'),
            		array($mod->CreateInputText($formDescriptor, 'fbrp_opt_default_year',
            		    $this->GetOption('default_year','-1'),10,10),$mod->Lang('title_default_year_help'))
         )
      );
		return array('main'=>$main,array());
	}

  function HasValue($deny_blank_responses=false)
  {
    if ($this->Value === false)
		{
		return false;
		}
	if (!is_array($this->Value))
		{
		return false;
		}
	if ($this->GetArrayValue(1) == '' ||
	  	$this->GetArrayValue(0) == '' ||
	    $this->GetArrayValue(2) == '')
		{
		return false;
		}
	return true;
  }


}

?>
]]></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','');
                $html5 = '';

                if ($this->GetOption('html5','0') == '1'&& $this->IsRequired()) 
		{
			$html5 = ' required';
                }
		// 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, $html5.$js.$this->GetCSSIdTag());
	}



    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="pagetable 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
      $this->RemoveAdminField($mainArray, $mod->Lang('title_email_subject'));

	}

	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>';
			}
		list($rv,$mess) = $this->validateEmailAddr($this->GetOption('email_from_address'));
		if (!$rv)
			{
    	    $ret = false;
            $message .= $mess;
			}
        for($i=0;$i<count($opt);$i++)
    	   {
		   list($rv,$mess) = $this->validateEmailAddr($opt[$i]);
		   if (!$rv)
				{
				$ret = false;
				$message .= $mess;
    	        }
			}

        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[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCgpyZXF1aXJlX29uY2UoZGlybmFtZShfX0ZJTEVfXykuJy9EaXNwb3NpdGlvbkVtYWlsQmFzZS5jbGFzcy5waHAnKTsKCmNsYXNzIGZiRGlzcG9zaXRpb25FbWFpbCBleHRlbmRzIGZiRGlzcG9zaXRpb25FbWFpbEJhc2UgewoKCXZhciAkYWRkcmVzc0NvdW50OwoJdmFyICRhZGRyZXNzQWRkOwoKCWZ1bmN0aW9uIGZiRGlzcG9zaXRpb25FbWFpbCgmJGZvcm1fcHRyLCAmJHBhcmFtcykKCXsKICAgICAgICAkdGhpcy0+ZmJEaXNwb3NpdGlvbkVtYWlsQmFzZSgkZm9ybV9wdHIsICRwYXJhbXMpOwogICAgICAgICRtb2QgPSAkZm9ybV9wdHItPm1vZHVsZV9wdHI7CgkJJHRoaXMtPlR5cGUgPSAnRGlzcG9zaXRpb25FbWFpbCc7CgkJJHRoaXMtPkRpc3BsYXlJbkZvcm0gPSBmYWxzZTsKCQkkdGhpcy0+RGlzcGxheUluU3VibWlzc2lvbiA9IGZhbHNlOwoJCSR0aGlzLT5Ob25SZXF1aXJhYmxlRmllbGQgPSB0cnVlOwoJCSR0aGlzLT5Jc0Rpc3Bvc2l0aW9uID0gdHJ1ZTsKCQkkdGhpcy0+SGFzQWRkT3AgPSB0cnVlOwoJCSR0aGlzLT5IYXNEZWxldGVPcCA9IHRydWU7CgkJJHRoaXMtPlZhbGlkYXRpb25UeXBlcyA9IGFycmF5KAogICAgICAgCQkpOwogICAgfQoKCWZ1bmN0aW9uIEdldE9wdGlvbkFkZEJ1dHRvbigpCgl7CgkJJG1vZCA9ICR0aGlzLT5mb3JtX3B0ci0+bW9kdWxlX3B0cjsKCQlyZXR1cm4gJG1vZC0+TGFuZygnYWRkX2FkZHJlc3MnKTsKCX0KCglmdW5jdGlvbiBHZXRPcHRpb25EZWxldGVCdXR0b24oKQoJewoJCSRtb2QgPSAkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CgkJcmV0dXJuICRtb2QtPkxhbmcoJ2RlbGV0ZV9hZGRyZXNzJyk7Cgl9CgoJZnVuY3Rpb24gRG9PcHRpb25BZGQoJiRwYXJhbXMpCgl7CgkJJHRoaXMtPmFkZHJlc3NBZGQgPSAxOwoJfQoKCWZ1bmN0aW9uIERvT3B0aW9uRGVsZXRlKCYkcGFyYW1zKQoJewoJCSRkZWxjb3VudCA9IDA7CgkJZm9yZWFjaCAoJHBhcmFtcyBhcyAkdGhpc0tleT0+JHRoaXNWYWwpCgkJCXsKCQkJaWYgKHN1YnN0cigkdGhpc0tleSwwLDkpID09ICdmYnJwX2RlbF8nKQoJCQkJewoJCQkJJHRoaXMtPlJlbW92ZU9wdGlvbkVsZW1lbnQoJ2Rlc3RpbmF0aW9uX2FkZHJlc3MnLCAkdGhpc1ZhbCAtICRkZWxjb3VudCk7CgkJCQkkZGVsY291bnQrKzsKCQkJCX0KCQkJfQoJfQoKCgogICAgZnVuY3Rpb24gU3RhdHVzSW5mbygpCgl7CgkJJG1vZCA9ICR0aGlzLT5mb3JtX3B0ci0+bW9kdWxlX3B0cjsKCQkkb3B0ID0gJHRoaXMtPkdldE9wdGlvbignZGVzdGluYXRpb25fYWRkcmVzcycsJycpOwoJCSRyZXQ9ICRtb2QtPkxhbmcoJ3RvJykuIjogIjsKCQlpZiAoaXNfYXJyYXkoJG9wdCkpCgkJICB7CgkJICBpZiAoY291bnQoJG9wdCk+MSkKCQkgICAgICB7CgkJICAgICAgJHJldC49IGNvdW50KCRvcHQpOwoJCSAgICAgICRyZXQuPSAiICIuJG1vZC0+TGFuZygncmVjaXBpZW50cycpOwoJCSAgICAgIH0KCQkgIGVsc2UKCQkgICAgICB7CgkJICAgICAgJHJldC49ICRvcHRbMF07CgkJICAgICAgfQoJCSAgfQoJCWVsc2VpZiAoJG9wdCAhPSAnJykKCQkJewoJCQkkcmV0IC49ICRvcHQ7CgkJCX0KCQllbHNlCgkJICB7CiAgICAgICAgICAkcmV0Lj0gJG1vZC0+TGFuZygndW5zcGVjaWZpZWQnKTsKICAgICAgICAgIH0KICAgICAgICAkcmV0Lj0gJHRoaXMtPlRlbXBsYXRlU3RhdHVzKCk7CiAgICAgICAgcmV0dXJuICRyZXQ7Cgl9CgoJZnVuY3Rpb24gY291bnRBZGRyZXNzZXMoKQoJewoJCQkkdG1wID0gJHRoaXMtPkdldE9wdGlvblJlZignZGVzdGluYXRpb25fYWRkcmVzcycpOwoJCQlpZiAoaXNfYXJyYXkoJHRtcCkpCgkJCQl7CgkgICAgICAgIAkkdGhpcy0+YWRkcmVzc0NvdW50ID0gY291bnQoJHRtcCk7CgkgICAgICAgIAl9CgkgICAgICAgIGVsc2VpZiAoJHRtcCAhPT0gZmFsc2UpCgkgICAgICAgIAl7CgkgICAgICAgIAkkdGhpcy0+YWRkcmVzc0NvdW50ID0gMTsKCSAgICAgICAgCX0KCSAgICAgICAgZWxzZQoJICAgICAgICAJewoJICAgICAgICAJJHRoaXMtPmFkZHJlc3NDb3VudCA9IDA7CgkgICAgICAgIAl9Cgl9CgoKICAgIC8vIFNlbmQgb2ZmIHRob3NlIGVtYWlscwoJZnVuY3Rpb24gRGlzcG9zZUZvcm0oJHJldHVybmlkKQoJewoJCSR0bXAgPSAkdGhpcy0+R2V0T3B0aW9uUmVmKCdkZXN0aW5hdGlvbl9hZGRyZXNzJyk7CgkJcmV0dXJuICR0aGlzLT5TZW5kRm9ybSgkdG1wLCR0aGlzLT5HZXRPcHRpb24oJ2VtYWlsX3N1YmplY3QnKSk7Cgl9CgoJZnVuY3Rpb24gUHJlUG9wdWxhdGVBZG1pbkZvcm0oJGZvcm1EZXNjcmlwdG9yKQoJewoJCSRtb2QgPSAkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CgoJCSR0aGlzLT5jb3VudEFkZHJlc3NlcygpOwoJCWlmICgkdGhpcy0+YWRkcmVzc0FkZCA+IDApCgkJCXsKCQkJJHRoaXMtPmFkZHJlc3NDb3VudCArPSAkdGhpcy0+YWRkcmVzc0FkZDsKCQkJJHRoaXMtPmFkZHJlc3NBZGQgPSAwOwoJCQl9CgkJJGRlc3RzID0gJzx0YWJsZSAgY2xhc3M9InBhZ2V0YWJsZSBtb2R1bGVfZmJfdGFibGUiPjx0cj48dGg+Jy4kbW9kLT5MYW5nKCd0aXRsZV9kZXN0aW5hdGlvbl9hZGRyZXNzJykuJzwvdGg+PHRoPicuCgkJCSRtb2QtPkxhbmcoJ3RpdGxlX2RlbGV0ZScpLic8L3RoPjwvdHI+JzsKCgoJCWZvciAoJGk9MDskaTwoJHRoaXMtPmFkZHJlc3NDb3VudD4xPyR0aGlzLT5hZGRyZXNzQ291bnQ6MSk7JGkrKykKCQkJewoJCQkkZGVzdHMgLj0gJzx0cj48dGQ+Jy4KICAgICAgICAgICAgCQkkbW9kLT5DcmVhdGVJbnB1dFRleHQoJGZvcm1EZXNjcmlwdG9yLCAnZmJycF9vcHRfZGVzdGluYXRpb25fYWRkcmVzc1tdJywkdGhpcy0+R2V0T3B0aW9uRWxlbWVudCgnZGVzdGluYXRpb25fYWRkcmVzcycsJGkpLDI1LDEyOCkuCiAgICAgICAgICAgIAkJJzwvdGQ+PHRkPicuCiAgICAgICAgICAgIAkJJG1vZC0+Q3JlYXRlSW5wdXRDaGVja2JveCgkZm9ybURlc2NyaXB0b3IsICdmYnJwX2RlbF8nLiRpLCAkaSwtMSkuCiAgICAgICAgICAgICAJCSc8L3RkPjwvdHI+JzsKCQkJfQoJCSRkZXN0cyAuPSAnPC90YWJsZT4nOwoJCWxpc3QoJG1haW4sJGFkdikgPSAkdGhpcy0+UHJlUG9wdWxhdGVBZG1pbkZvcm1CYXNlKCRmb3JtRGVzY3JpcHRvcik7CgkJYXJyYXlfcHVzaCgkbWFpbixhcnJheSgkbW9kLT5MYW5nKCd0aXRsZV9kZXN0aW5hdGlvbl9hZGRyZXNzJyksJGRlc3RzKSk7CgkJcmV0dXJuIGFycmF5KCdtYWluJz0+JG1haW4sJ2Fkdic9PiRhZHYpOwoJfQoKCWZ1bmN0aW9uIFBvc3RQb3B1bGF0ZUFkbWluRm9ybSgmJG1haW5BcnJheSwgJiRhZHZBcnJheSkKCXsKCQkkdGhpcy0+SGlkZGVuRGlzcG9zaXRpb25GaWVsZHMoJG1haW5BcnJheSwgJGFkdkFycmF5KTsKCX0KCgoJZnVuY3Rpb24gQWRtaW5WYWxpZGF0ZSgpCiAgICB7CgkJJG1vZCA9ICR0aGlzLT5mb3JtX3B0ci0+bW9kdWxlX3B0cjsKICAgIAkkb3B0ID0gJHRoaXMtPkdldE9wdGlvblJlZignZGVzdGluYXRpb25fYWRkcmVzcycpOwogIAkJbGlzdCgkcmV0LCAkbWVzc2FnZSkgPSAkdGhpcy0+RG9lc0ZpZWxkSGF2ZU5hbWUoKTsKCQlpZiAoJHJldCkKCQkJewoJCQlsaXN0KCRyZXQsICRtZXNzYWdlKSA9ICR0aGlzLT5Eb2VzRmllbGROYW1lRXhpc3QoKTsKCQkJfQkJCgkJaWYgKCRvcHQgPT09IGZhbHNlIHx8IGNvdW50KCRvcHQpID09IDApCgkJCXsKCQkJJHJldCA9IGZhbHNlOwoJCQkkbWVzc2FnZSAuPSAkbW9kLT5MYW5nKCdtdXN0X3NwZWNpZnlfb25lX2Rlc3RpbmF0aW9uJykuJzwvYnI+JzsKCQkJfQoJCWxpc3QoJHJ2LCRtZXNzKSA9ICR0aGlzLT52YWxpZGF0ZUVtYWlsQWRkcigkdGhpcy0+R2V0T3B0aW9uKCdlbWFpbF9mcm9tX2FkZHJlc3MnKSk7CgkJaWYgKCEkcnYpCgkJCXsKICAgIAkgICAgJHJldCA9IGZhbHNlOwogICAgICAgICAgICAkbWVzc2FnZSAuPSAkbWVzczsKCQkJfQogICAgICAgIGZvcigkaT0wOyRpPGNvdW50KCRvcHQpOyRpKyspCiAgICAJICAgewoJCSAgIGxpc3QoJHJ2LCRtZXNzKSA9ICR0aGlzLT52YWxpZGF0ZUVtYWlsQWRkcigkb3B0WyRpXSk7CgkJICAgaWYgKCEkcnYpCgkJCQl7CgkJCQkkcmV0ID0gZmFsc2U7CgkJCQkkbWVzc2FnZSAuPSAkbWVzczsKICAgIAkgICAgICAgIH0KCQkJfQogICAgICAgIHJldHVybiBhcnJheSgkcmV0LCRtZXNzYWdlKTsgICAgICAgCiAgICB9Cgp9Cgo/Pgo=]]></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->IsEmailDisposition = 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($returnid)
  {
    return array(true,'');
  }

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

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

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

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

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

   if ($mod->GetPreference('enable_antispam',1))
     {
    $db =$mod->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 > 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();
    
    $rt = $this->GetOption('email_reply_to_address','');
    $rn = $this->GetOption('email_reply_to_name','');
    if (empty($rn))
      {
      $rn = $this->GetOption('email_from_name','');
      }
    if ($this->SetReplyToAddress() && !empty($rt))
      {
      $mail->AddReplyTo($rt,$this->SetFromName()?$rn:'');
      }
    
    if ($this->SetFromAddress())
      {
  	   $mail->SetFrom($this->GetOption('email_from_address'));
      }
    if ($this->SetFromName())
      {
      $mail->SetFromName($this->GetOption('email_from_name'));
      }


	$cc = $this->GetOption('email_cc_address','');
	if (!empty($cc))
		{
		$usebcc = $this->GetOption('use_bcc',0);
		$sub_ads = explode(',',$cc.',');
		foreach ($sub_ads as $this_ad)
			{
			if (!empty($this_ad))
				{
				if ($usebcc == 1)
					{
					$mail->AddBCC(trim($this_ad));	
					}
				else
					{
					$mail->AddCC(trim($this_ad));	
					}
				}
			}
		}
	
    $mail->SetCharSet($this->GetOption('email_encoding','utf-8'));

    $message = $this->GetOption('email_template','');
    $htmlemail = ($this->GetOption('html_email','0') == '1');
	if ($this->GetFieldType() == 'DispositionEmailConfirmation')
		{
		$form->AddTemplateVariable('confirm_url',$mod->Lang('title_confirmation_url'));
		}
    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($htmlemail);

    $theFields = $form->GetFields();

### fix by foaly* 
    ### re-fix by JoMorg

    for($i=0;$i<count($theFields);$i++)
    {
      if (
            strtolower(get_class($theFields[$i])) == 'fbfileuploadfield'
            && !$theFields[$i]->GetOption('suppress_attachment')
            && !$theFields[$i]->GetOption('sendto_uploads')
        )
      {
        // we have a file we wish to attach
        $thisAtt = $theFields[$i]->GetHumanReadableValue();
        
        $filepath = cms_join_path( $theFields[$i]->GetOption('file_destination') );
        
        $fullfilename = cms_join_path($filepath, $thisAtt);
        
        if (function_exists('finfo_open'))
        {
          $finfo = finfo_open(FILEINFO_MIME); // return mime type ala mimetype extension
          $thisType = finfo_file($finfo, $fullfilename);
          finfo_close($finfo);
        }
        else if (function_exists('mime_content_type'))
        {
          $thisType = mime_content_type($fullfilename);
        }
        else
        {
          $thisType = 'application/octet-stream';
        }
                  
        if (! $mail->AddAttachment($fullfilename, $thisAtt, "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($filepath, $filepath ,$thisType)));
        }
      }
    }
### fix by foaly*
  ### end of re-fix by JoMorg
	
    $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)
      {
		if (strpos($thisDest,',') !== false)
			{
			$sub_ads = explode(',',$thisDest);
			foreach ($sub_ads as $this_ad)
				{
				if ($this->GetOption('send_using','to') == 'to')
					$mail->AddAddress(trim($this_ad));
				else if ($this->GetOption('send_using') == 'cc')
					$mail->AddCC(trim($this_ad));
				else
					$mail->AddBCC(trim($this_ad));
				}
			}
		else
			{
			if ($this->GetOption('send_using','to') == 'to')
				$mail->AddAddress(trim($thisDest));
			else if ($this->GetOption('send_using') == 'cc')
				$mail->AddCC(trim($thisDest));
			else
				$mail->AddBCC(trim($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 = $mod->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()),"'")));
    }
	$toReturn = array($res, $mail->GetErrorInfo());
	$mail->reset();
	return $toReturn;
  }

  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;
	if ($this->GetFieldType() == 'DispositionEmailConfirmation')
		{
		$this->form_ptr->AddTemplateVariable('confirm_url',$mod->Lang('title_confirmation_url'));
		}

    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_send_using'),$mod->CreateInputDropdown($formDescriptor, 'fbrp_opt_send_using',
			array($mod->Lang('to_field')=>'to',$mod->Lang('cc_field')=>'cc',$mod->Lang('bcc_field')=>'bcc'), -1, $this->getOption('send_using'))),
		   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($mod->Lang('title_email_cc_address'),$mod->CreateInputText($formDescriptor, 'fbrp_opt_email_cc_address',$this->GetOption('email_cc_address',''),25,128)),
        	array($mod->Lang('title_use_bcc'),
          	$mod->CreateInputHidden($formDescriptor,'fbrp_opt_use_bcc','0').$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_use_bcc',
              '1',$this->GetOption('use_bcc','0'))),
           ),
     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', '','','','80', '15','','html'),
              $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))
           )
     );
  }

  function validateEmailAddr($email)
	{
		$mod = $this->form_ptr->module_ptr;
		$ret = true;
		$message = '';
		
		if (strpos($email,',') !== false)
		{
			$ta = explode(',',$email);	
		}
		else
		{
			$ta = array($email);	
		}
		
		foreach($ta as $to)
		{
//		if (! preg_match(($mod->GetPreference('relaxed_email_regex','0')==0?$mod->email_regex:$mod->email_regex_relaxed), $to))
			if( !email_validator::is_email($to) )
	  	{
	    	$ret = false;
        $message .= $mod->Lang('not_valid_email', $to);
	   	}
		}
		
		return array($ret, $message);
	}

}

// EOF
?>]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionEmailBasedFrontendFields.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(dirname(__FILE__).'/DispositionEmailBase.class.php');

class fbDispositionEmailBasedFrontendFields extends fbDispositionEmailBase {


	function fbDispositionEmailBasedFrontendFields(&$form_ptr, &$params)
	{
        $this->fbDispositionEmailBase($form_ptr, $params);
        $mod = $form_ptr->module_ptr;
		$this->Type = 'DispositionEmailBasedFrontendFields';
		$this->DisplayInForm = false;
		$this->DisplayInSubmission = false;
		$this->NonRequirableField = true;
		$this->IsDisposition = true;
		$this->HideLabel = 1;		
		$this->ValidationTypes = array();
    }

    function StatusInfo()
	{
		$mod = $this->form_ptr->module_ptr;
		
		$opt = $this->GetOptionRef('destination_address','');
		if(!is_array($opt)) {
		
			$opt = array($opt);
		}
		
		$ret= $mod->Lang('to').": ".count($opt)." ".$mod->Lang('fields'); 
        $ret.= $this->TemplateStatus();
        
		return $ret;
	}


    // Send off those emails
	function DisposeForm($returnid)
	{
	
		$mod = $this->form_ptr->module_ptr;
		$form = $this->form_ptr;
		
		$tmp = $form->GetFieldByID($this->GetOption('email_subject'));
		$this->SetOption('email_subject',$tmp->GetHumanReadableValue());
		
		$tmp = $form->GetFieldByID($this->GetOption('email_from_name'));
		$this->SetOption('email_from_name',$tmp->GetHumanReadableValue());

		$tmp = $form->GetFieldByID($this->GetOption('email_from_address'));
		$this->SetOption('email_from_address',$tmp->GetHumanReadableValue());		

		$addarr = array();
		$address = $this->GetOptionRef('destination_address');
		
		if(!is_array($address)) {
		
			$address = array($address);
		}
		
		foreach($address as $item) {
		
			$tmp = $form->GetFieldByID($item);				
			$value = $tmp->GetHumanReadableValue();
			
			if (strpos($value,',') !== false) {
			
				$arr = explode(',',$value);	
			} else {
			
				$arr = array($value);	
			}			
			
			foreach($arr as $email) {
			
				$validate = $this->validateEmailAddr($email);
				
				if($validate[0]) {
				
					$addarr[] = $email;
					
				}
			}
		}
	
		return $this->SendForm($addarr,$this->GetOption('email_subject'));
	}

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

		$parm = array();
		$parm['opt_email_template']['html_button'] = true;
		$parm['opt_email_template']['text_button'] = true;
		$parm['opt_email_template']['is_email'] = true;
		
		$destadd_all = $this->GetFieldList();
		$destadd_tmp = $this->GetOptionRef('destination_address');
		
		if(!is_array($destadd_tmp)) {
		
			$destadd_tmp = array($destadd_tmp);
		}
		
		$destadd_sel = array();
		foreach($destadd_all as $k=>$v) {
		
			if(in_array($v,$destadd_tmp)) {
			
				$destadd_sel[$k] = $v;
			
			}	
		}
	
		$main = array(
			   array($mod->Lang('title_email_subject'),$mod->CreateInputDropdown($formDescriptor, 'fbrp_opt_email_subject',$this->GetFieldList(true),-1,$this->GetOption('email_subject',''))),
			   array($mod->Lang('title_email_from_name'),$mod->CreateInputDropdown($formDescriptor, 'fbrp_opt_email_from_name',$this->GetFieldList(true),-1,$this->GetOption('email_from_name',$mod->Lang('friendlyname')))),
			   array($mod->Lang('title_email_from_address'),array($mod->CreateInputDropdown($formDescriptor, 'fbrp_opt_email_from_address',$this->GetFieldList(true),-1,$this->GetOption('email_from_address','')),
													$mod->Lang('email_from_addr_help',array($_SERVER['SERVER_NAME'])))),
													
			   array($mod->Lang('title_destination_address'),$mod->CreateInputSelectList($formDescriptor, 'fbrp_opt_destination_address[]',$destadd_all,$destadd_sel,5))													
				);
			   
		$adv = 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('email_template',''),'fbrp_opt_email_template', 'module_fb_area_wide', '','','','80', '15','','html'),
													$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))
				);

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

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

	// Validate admin side
	function AdminValidate()
    {
		$mod = $this->form_ptr->module_ptr;
		$subject = $this->GetOption('email_subject','');
		$name = $this->GetOption('email_from_name','');
		$from = $this->GetOption('email_from_address','');
    	$dest = $this->GetOptionRef('destination_address');
		
  		list($ret, $message) = $this->DoesFieldHaveName();
		
		if ($ret) {
		
			list($ret, $message) = $this->DoesFieldNameExist();
		}		
			
		if ($subject == false || count($subject) == 0) {
		
			$ret = false;
			$message .= $mod->Lang('no_field_assigned',$mod->Lang('title_email_subject'));
		}

		if ($name == false || count($name) == 0) {
		
			$ret = false;
			$message .= $mod->Lang('no_field_assigned',$mod->Lang('title_email_from_name'));
		}

		if ($from == false || count($from) == 0) {
		
			$ret = false;
			$message .= $mod->Lang('no_field_assigned',$mod->Lang('title_email_from_address'));
		}

		if ($dest == false || count($dest) == 0) {
		
			$ret = false;
			$message .= $mod->Lang('no_field_assigned',$mod->Lang('title_destination_address'));
		}		
		
		
        return array($ret,$message);       
    }

	// Get all fields
	private function GetFieldList($selectone = false) 
	{
		$mod = $this->form_ptr->module_ptr;
		$form = $this->form_ptr;
		$fields = $form->GetFields();
		$ret = array();
		
		if($selectone) {
		
			$ret[$mod->Lang('select_one')] = '';
		}
	
		foreach($fields as $thisField) {
		
			if($thisField->DisplayInForm) {
		
				$ret[$thisField->GetName()] = $thisField->GetId();
			}
		}
		
		return $ret;
	
	}	
	
	
}

?>]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionEmailConfirmation.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionEmailFromFEUProperty.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)
	{
	    $gCms = cmsms();
	    $userops = $gCms->GetUserOperations();
		$mod = $this->form_ptr->module_ptr;
		$js = $this->GetOption('javascript','');
		$html5 = '';

		if ($this->GetOption('html5','0') == '1'&& $this->IsRequired()) 
		{
			$html5 = ' required';
		}
		// 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, $html5.$js.$this->GetCSSIdTag());
	}



    function StatusInfo()
	{
	    $gCms = cmsms();
	    $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)
	{
	    $gCms = cmsms();
	    $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 GetHumanReadableValue($as_string=true)
	{
	    $gCms = cmsms();
	    $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)
	{
	    $gCms = cmsms();
	    $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;
		list($ret,$message) = $this->validateEmailAddr($this->GetOption('email_from_address'));
        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');
            }
        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;

    $gCms = cmsms();
    $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','');
	$html5 = '';

	if ($this->GetOption('html5','0') == '1'&& $this->IsRequired()) 
	{
		$html5 = ' required';
	}

    // 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, $html5.$js.$this->GetCSSIdTag());
  }

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

	function DisposeForm($returnid)
  {
	$gCms = cmsms();
	$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->createSampleTemplate(false,false,false,true);
	  } 
	$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 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,'{$' . $others[$i]->GetVariableName() . '}');
	  }
      }
    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);
  }

}

?>
]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionForm.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionFormBrowser.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 fbDispositionFormBrowser extends fbFieldBase {

	var $approvedBy;

	function fbDispositionFormBrowser(&$form_ptr, &$params)
	{
      $this->fbFieldBase($form_ptr, $params);
      $mod = $form_ptr->module_ptr;
		$this->Type = 'DispositionFormBrowser';
		$this->IsDisposition = true;
		$this->NonRequirableField = true;
		$this->DisplayInForm = false;
		$this->DisplayInSubmission = false;
		$this->HideLabel = 1;
		$this->NeedsDiv = 0;
		$this->approvedBy = '';
		$this->sortable = false;
	}

	function GetFieldInput($id, &$params, $returnid)
	{
		$mod = $this->form_ptr->module_ptr;
		if ($this->Value === false)
			{
			return '';
			}
		return $mod->CreateInputHidden($id, 'fbrp__'.$this->Id,	
			$this->EncodeReqId($this->Value));
	}

	function SetApprovalName($name)
	{
		$this->approvedBy = $name;
	}

	function StatusInfo()
	{
		$mod = $this->form_ptr->module_ptr;
		$enc = ($this->GetOption('crypt','0') == '1'?$mod->Lang('yes'):$mod->Lang('no'));
		$feu = ($this->GetOption('feu_bind','0') == '1'?$mod->Lang('yes'):$mod->Lang('no'));
		return $mod->Lang('title_encryption').':'.$enc.', '.$mod->Lang('title_feu_binding').':'.$feu;
	}
	
	function DecodeReqId($theVal)
	{
		$tmp = base64_decode($theVal);
		$tmp2 = str_replace(session_id(),'',$tmp);
		if (substr($tmp2,0,1) == '_')
			{
			return substr($tmp2,1);
			}
		else
			{
			return -1;
			}
	}
	
	function EncodeReqId($req_id)
	{
		return base64_encode(session_id().'_'.$req_id);
	}
	
	
	function SetValue($val)
	{
		$decval = base64_decode($val);
   
		if ($val === false)
			{
			// no value set, so we'll leave value as false
			}
		elseif (strpos($decval,'_') === false)
			{
			// unencrypted value, coming in from previous response
			$this->Value = $val;
			}
		else
			{
			// encrypted value coming in from a form, so we'll update.
			$this->Value = $this->DecodeReqId($val);
			}
	}
	
	function PrePopulateAdminForm($formDescriptor)
	{
	
		$mod = $this->form_ptr->module_ptr;
		$form = $this->form_ptr;
		$fields = $form->GetFields();
		$fieldlist = array($mod->Lang('none')=>'-1');
		$main = array();
		$adv = array();
		for ($i=0;$i<count($fields);$i++)
			{
			if ($fields[$i]->DisplayInSubmission())
				{
				$fieldlist[$fields[$i]->GetName()] = $fields[$i]->GetId();
				}
			}
		$current_indexes = array();
		for ($i=1;$i<6;$i++)
			{
			$fname = array_search($this->GetOption('sortfield'.$i),$fieldlist);
			array_push($main,
					array($mod->Lang('title_sortable_field',array($i)),
						$mod->CreateInputDropdown($formDescriptor, 'fbrp_opt_sortfield'.$i, $fieldlist, -1,
					$this->GetOption('sortfield'.$i,-1))
					));
			array_push($current_indexes,$this->GetOption('sortfield'.$i,-1));
			}
	  array_push($main,array($mod->Lang('title_note'),$mod->Lang('title_changing_triggers_reindex').
		$mod->CreateInputHidden($formDescriptor,'fbrp_previous_indices',implode(':',$current_indexes))
		));

	array_push($adv,array($mod->Lang('title_searchable'),
		$mod->CreateInputHidden($formDescriptor, 'fbrp_opt_searchable','0').
		$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_searchable',
		'1',$this->GetOption('searchable','0')).
		$mod->Lang('title_searchable_help')));

	  $feu = cmsms()->GetModuleInstance('FrontEndUsers');
	  if ($feu === null)
		{
		array_push($adv,array($mod->Lang('title_feu_binding'),
			$mod->Lang('title_install_feu')));	
		}
	else
		{
		array_push($adv,array($mod->Lang('title_feu_binding'),
			$mod->CreateInputHidden($formDescriptor, 'fbrp_opt_feu_bind','0').
			$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_feu_bind',
			'1',$this->GetOption('feu_bind','0')).
			$mod->Lang('title_feu_bind_help')));
		}
		
	  $openssl = cmsms()->GetModuleInstance('OpenSSL');
	  if ($openssl === null && !function_exists('mcrypt_encrypt'))
		{
		array_push($adv,array($mod->Lang('title_encryption_functions'),
            $mod->Lang('title_install_crypto')));
        
		}
	else
		{
		if ($openssl !== null)
         {
		    $keys = $openssl->getKeyList();
		    $certs = $openssl->getCertList();
		    }
		array_push($adv,array($mod->Lang('title_encrypt_database_data'),
			   $mod->CreateInputHidden($formDescriptor, 'fbrp_opt_crypt','0').
            		$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_crypt',
            		'1',$this->GetOption('crypt','0')).
					$mod->Lang('title_encrypt_database_long')));
		array_push($adv,array($mod->Lang('title_encrypt_sortfields'),
			   $mod->CreateInputHidden($formDescriptor, 'fbrp_opt_hash_sort','0').
            		$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_hash_sort',
            		'1',$this->GetOption('hash_sort','0')).
                  $mod->Lang('title_encrypt_sortfields_help')));
		array_push($adv,array($mod->Lang('title_encryption_keyfile'),
            $mod->CreateInputText($formDescriptor, 'fbrp_opt_keyfile',
            		$this->GetOption('keyfile',''),40,255)));

      $cryptlibs = array();
      if ($openssl !== null)
         {
         $cryptlibs[$mod->Lang('openssl')]='openssl';
         }
      if (function_exists('mcrypt_encrypt'))
         {
         $cryptlibs[$mod->Lang('mcrypt')]='mcrypt';
         }

		array_push($adv,array($mod->Lang('title_crypt_lib'),
            $mod->CreateInputDropdown($formDescriptor,'fbrp_opt_crypt_lib',
            $cryptlibs,-1,$this->GetOption('crypt_lib'))));



      if ($openssl !== null)
         {
         array_push($adv,array($mod->Lang('choose_crypt'),$mod->Lang('choose_crypt_long')));

		   array_push($adv,array($mod->Lang('title_crypt_cert'),
					$mod->CreateInputDropdown($formDescriptor, 'fbrp_opt_crypt_cert', $certs,
						-1,$this->GetOption('crypt_cert'))));
		    array_push($adv,array($mod->Lang('title_private_key'),
				$mod->CreateInputDropdown($formDescriptor, 'fbrp_opt_private_key', $keys,
					-1,$this->GetOption('private_key')).$mod->Lang('title_ensure_cert_key_match')));
         }
		}

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

	function PostPopulateAdminForm(&$mainArray, &$advArray)
	{
		$mod = $this->form_ptr->module_ptr;
		$this->HiddenDispositionFields($mainArray, $advArray);
	}


	function DisposeForm($returnid)
	{
		$form = $this->form_ptr;
		list($res,$msg) = $form->StoreResponse(($this->Value?$this->Value:-1),$this->approvedBy,$this);
		if ($this->GetOption('searchable','0') == '1')
			{
			$form->AddToSearchIndex($this->Value);
			}
		return array($res, $msg);
	}


  function PostFieldSaveProcess(&$params)
  {
	$reindex = false;
	$prev_indices = explode(':',$params['fbrp_previous_indices']);
	for ($i=1;$i<6;$i++)
		{
		if ($this->GetOption('sortfield'.$i) != $prev_indices[$i-1])
			{
			$reindex = true;
			}
		}
	if (! $reindex)
		{
		return;
		}
	$form = $this->form_ptr;
	$form->ReindexResponses();
  }
  

	function getHashedSortFieldVal($sortFieldNumber)
   {
      $v = $this->getSortFieldVal($sortFieldNumber);
      if (strlen($v) > 4)
         {
         $v = substr($v,0,4). md5(substr($v,4));
         }
      return $v;
   }
	
	function getSortFieldList()
	{
		$form = $this->form_ptr;
		$ret = array();
		for ($i=1;$i<6;$i++)
			{
			if ($this->GetOption('sortfield'.$i,'-1') != '-1')
				{
				$afield = $form->GetFieldById($this->GetOption('sortfield'.$i));
				if ($afield !== false)
               {
				   $ret[$i] = $afield->GetName();
               }
				}
			}
		return $ret;
	}

	function getSortFieldVal($sortFieldNumber)
	{
		$form = $this->form_ptr;
		$val = "";
		if ($this->GetOption('sortfield'.$sortFieldNumber,'-1') != '-1')
			{
			$afield = $form->GetFieldById($this->GetOption('sortfield'.$sortFieldNumber));
         if ($afield !== false)
            {
            $val = $afield->GetHumanReadableValue();
            }
			}
		if (strlen($val) > 80)
			{
			$val = substr($val,0,80);
			}
		return $val;
	}

}

?>
]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionFromEmailAddressField.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(dirname(__FILE__).'/DispositionEmailBase.class.php');

class fbDispositionFromEmailAddressField extends fbDispositionEmailBase {

	function fbDispositionFromEmailAddressField(&$form_ptr, &$params)
	{
      $this->fbDispositionEmailBase($form_ptr, $params);
      $mod = $form_ptr->module_ptr;
		$this->Type = 'DispositionFromEmailAddressField';
      $this->IsDisposition = true;
		$this->DisplayInForm = true;
		$this->ValidationTypes = array(
			$mod->Lang('validation_none')=>'none',
            $mod->Lang('validation_email_address')=>'email',
            );
	$this->modifiesOtherFields = true;
	$this->NonRequirableField = false;	
	}

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

		if ($this->GetOption('html5','0') == '1')
		{
                        $val = $this->Value[0];
                        $html5 = ' placeholder="'.$this->GetOption('default').'"';
		        if ($this->IsRequired()) {
		                $html5 .= ' required';
		        }
                }
                else
                {
                        $val = $this->Value[0] ? $this->Value[0] : $this->GetOption('default');
                        if($this->GetOption('clear_default','0') == 1)
                        {
                                $js .= ' onfocus="if(this.value==this.defaultValue) this.value=\'\';" onblur="if(this.value==\'\') this.value=this.defaultValue;"';
                        }
                }
		$retstr = $mod->fbCreateInputText($id, 'fbrp__'.$this->Id.'[]',
			htmlspecialchars($val, ENT_QUOTES),
            		25, 128, $js.$html5.$this->GetCSSIdTag('_1'),'email');

 		if ($this->GetOption('send_user_copy','n') == 'c')
			{
			$retstr .= $mod->CreateInputCheckbox($id, 'fbrp__'.$this->Id.'[]', 1,
					(isset($this->Value[1])? $this->Value[1] :0 ),$this->GetCSSIdTag('_2'));
			$retstr .= '<label for="'.$this->GetCSSId('_2').'" class="label">'.$this->GetOption('send_user_label',
				$mod->Lang('title_send_me_a_copy')).'</label>';
			}
		return $retstr;
	}

	function GetCSSId($suffix='')
	{
		$alias = $this->GetAlias();
		if (empty($alias))
			{
			$cssid = 'fbrp__'.$this->Id;
			}
		else
			{
			$cssid = $alias;
			}

		if (empty($suffix))
			{
			$cssid .= '_1';
			}
		else
			{
			$cssid .= $suffix;
			}
		return $cssid;
	}

   function HasValue($deny_blank_responses=false)
   {
   	return ($this->Value[0] !== false && !empty($this->Value[0]));
   }

  	function GetValue()
  	{
    	return $this->Value[0];
  	}

  	# removed by Jo Morg: this is part of the problem with emails validation
//   function SetValue($valStr)
//   {
//      if (! is_array($valStr))
//         {
//         	 
//         $this->Value = array($valStr);
//         }
//      else
//         {
//         $this->Value = $valStr;
//         }
//   }

	function GetHumanReadableValue($as_string=true)
	{
		if (is_array($this->Value))
			{
			return $this->Value[0];
			}
		else
			{
			return $this->Value;
			}
	}

	function DisposeForm($returnid)
	{
      if ($this->HasValue() != false && 
			(
				$this->GetOption('send_user_copy','n') == 'a'
				||
				($this->GetOption('send_user_copy','n') == 'c' && isset($this->Value[1]) && $this->Value[1] == 1)
			)
		 )
			{
			return $this->SendForm($this->Value[0],$this->GetOption('email_subject'));
			}
	  else
		{
        return array(true,'');
        }
	}


	function StatusInfo()
	{
		return $this->TemplateStatus();
	}

	function PrePopulateAdminForm($formDescriptor)
	{
		$mod = $this->form_ptr->module_ptr;
		list($main,$adv) = $this->PrePopulateAdminFormBase($formDescriptor);
		array_unshift($adv, array($mod->Lang('title_field_default_value'),$mod->CreateInputText($formDescriptor, 'fbrp_opt_default',$this->GetOption('default'),25,1024)));
		array_unshift($adv, array($mod->Lang('title_clear_default'),$mod->CreateInputHidden($formDescriptor,'fbrp_opt_clear_default','0').$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_clear_default','1',$this->GetOption('clear_default','0')).'<br />'.$mod->Lang('title_clear_default_help')));

		$opts = array($mod->Lang('option_never')=>'n',$mod->Lang('option_user_choice')=>'c',$mod->Lang('option_always')=>'a');
		array_push($main,array($mod->Lang('title_send_usercopy'),
			$mod->CreateInputDropdown($formDescriptor, 'fbrp_opt_send_user_copy', $opts, -1, $this->GetOption('send_user_copy','n'))));
		array_push($main,array($mod->Lang('title_send_usercopy_label'),
			$mod->CreateInputText($formDescriptor, 'fbrp_opt_send_user_label', $this->GetOption('send_user_label',
				$mod->Lang('title_send_me_a_copy')),25,125)));
		$hopts = array($mod->Lang('option_from')=>'f',$mod->Lang('option_reply')=>'r',$mod->Lang('option_both')=>'b');
		array_push($main,array($mod->Lang('title_headers_to_modify'),
			$mod->CreateInputDropdown($formDescriptor, 'fbrp_opt_headers_to_modify', $hopts, -1, $this->GetOption('headers_to_modify','f'))));
		return array('main'=>$main,'adv'=>$adv);
	}

	function PostPopulateAdminForm(&$mainArray, &$advArray)
	{
		$mod = $this->form_ptr->module_ptr;
		$this->RemoveAdminField($mainArray, $mod->Lang('title_email_from_address'));
	}


	function ModifyOtherFields()
	{
		$mod = $this->form_ptr->module_ptr;
		$others = $this->form_ptr->GetFields();
		$htm = $this->GetOption('headers_to_modify','f');
		if ($this->Value !== false)
			{
			for($i=0;$i<count($others);$i++)
				{
				$replVal = '';
				if ($others[$i]->IsDisposition() &&
               is_subclass_of($others[$i],'fbDispositionEmailBase'))
					{
					if ($htm == 'f' || $htm == 'b')
                  {
					    $others[$i]->SetOption('email_from_address',$this->Value[0]);
					   }
               if ($htm == 'r' || $htm == 'b')
                  {
					    $others[$i]->SetOption('email_reply_to_address',$this->Value[0]);
                  }
					}
				}
			}
	}

	function Validate()
	{

  		$this->validated = true;
  		$this->validationErrorText = '';
		$result = true;
		$message = '';
		$mod = $this->form_ptr->module_ptr;
		if ($this->ValidationType != 'none')
			{
		      if (!empty($this->Value[0]) &&  $this->Value !== false &&
		            ! preg_match(($mod->GetPreference('relaxed_email_regex','0')==0?$mod->email_regex:$mod->email_regex_relaxed), $this->Value[0]))
		         {
		         $this->validated = false;
		         $this->validationErrorText = $mod->Lang('please_enter_an_email',$this->Name);
		         }
			}
		return array($this->validated, $this->validationErrorText);
	}
}

?>
]]></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;

    $gCms = cmsms();
    $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');
    $displayvalues = $this->GetOptionRef('destination_value');

    $fields = array();
    for( $i = 0; $i < count($displaynames); $i++ )
      {
	$label = '';
	$ctrl = new stdClass();
	$ctrl->name = '<label for="'.$this->GetCSSId('_'.$i).'">'.$displaynames[$i].'</label>';
	$ctrl->title = $displaynames[$i];
	$ctrl->input = $mod->CreateInputCheckbox($id,
						 'fbrp__'.$this->Id.'[]', 
						 $displayvalues[$i],
                         (is_array($this->Value) && in_array($displayvalues[$i],$this->Value))?$displayvalues[$i]:'-1',
						 $this->GetCSSIdTag('_'.$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 $onevalue )
	  {
	    if( empty($onevalue) ) continue;
	    
	    $tmp[] = $onevalue;
	  } // foreach
      } // if

    if ($as_string)
      {
	$tmp = join($form->GetAttr('list_delimiter',','),$tmp);
      }
    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->form_ptr->createSampleTemplate(false,false,false,true);
      } 
    $header .= "\n";

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

    // Begin output to files
    if( is_array($this->Value) )
      {
	$displayfiles = $this->GetOptionRef('destination_filename');
	$displayvalues = $this->GetOptionRef('destination_value');

	foreach( $this->Value as $onevalue )
	  {
	    // I dunno why it's empty sometimes, but...
	    if( empty($onevalue) ) continue;
	    
	    $idx = array_search($onevalue,$displayvalues);
	    
	    $tmp = $displayfiles[$idx];
	    // get the filename
	    $filespec = $dir.
	      preg_replace("/[^\w\d\.]|\.\./", "_", $tmp);
	    
	    $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 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);
  }

}

?>
]]></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->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','');
		$html5 = '';

		if ($this->GetOption('html5','0') == '1'&& $this->IsRequired()) 
		{
			$html5 = ' required';
		}
		// 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, $html5.$js.$this->GetCSSIdTag());
	}



    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)
	{
   		$gCms = cmsms();
		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)
	{
      $this->HiddenDispositionFields($mainArray, $advArray);
	}

	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)));
    		$gCms = cmsms();
    		$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');
			}
	        return array($ret,$message);
    }

}
?>
]]></data>
	</file>
	<file>
	  <filename>/classes/DispositionUniqueFile.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/* 
   FormBuilder. Copyright (c) 2005-2010 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 fbDispositionUniqueFile extends fbFieldBase
{

	function fbDispositionUniqueFile(&$form_ptr, &$params)
	{
		$this->fbFieldBase($form_ptr, $params);
		$mod = $form_ptr->module_ptr;
		$this->Type = 'DispositionUniqueFile';
		$this->IsDisposition = true;
		$this->NonRequirableField = true;
		$this->DisplayInForm = false;
		$this->sortable = false;

		$this->IsComputedOnSubmission = true;
	}

	function ComputeOrder()
	{
		return $this->GetOption('order','1');
	}

	function Compute()
	{
		$config = cmsms()->GetConfig();
		$mod=$this->form_ptr->module_ptr;
		$form=$this->form_ptr;
		$form->setFinishedFormSmarty();

		$filespec = $this->GetOption('filespec','');
		if ($filespec == '')
		{
			$filespec = 'form_submission_'.date("Y-m-d_His").'.txt';
		}
		$evald_filename = preg_replace("/[^\w\d\.]|\.\./", "_", $mod->ProcessTemplateFromData($filespec));
		$filespec = $this->GetOption('fileroot',$config['uploads_path']).'/'.$evald_filename;
		if (strpos($filespec,$config['root_path']) !== FALSE)
		{
			$relurl = str_replace($config['root_path'],'',$filespec);
		}
		$url = $config['root_url'].$relurl;
		$url = str_replace("\\", "/", $url);
		$this->SetValue(array($filespec, $url, $relurl, $evald_filename));
	}

	function StatusInfo()
	{
		$mod=$this->form_ptr->module_ptr;
		return $this->GetOption('filespec',$mod->Lang('unspecified'));
	}

	function DisposeForm($returnid)
	{
		$config = cmsms()->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'));
		}

		$form->setFinishedFormSmarty();

		$filespec = $this->GetOption('filespec','');
		if ($filespec == '')
		{
			$filespec = 'form_submission_'.date("Y-m-d_His").'.txt';
		}
		$evald_filename = preg_replace("/[^\w\d\.]|\.\./", "_", $mod->ProcessTemplateFromData($filespec));

		$filespec = $this->GetOption('fileroot',$config['uploads_path']).'/'.$evald_filename;

		$line = '';
		if ($this->GetOption('file_type','false') == 0)
		{ // If File Type is "TXT"
			// Check if first time, write header
			if (! file_exists($filespec))
			{
				$header = $this->GetOption('file_header','');

				if($header != '')
				{
					$header = $mod->ProcessTemplateFromData($header);
				}
			}

			// Make newline  
			$template = $this->GetOption('file_template','');
			if ($template == '')
			{
				$template = $form->createSampleTemplate();
			}
			$line = $template;

			$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";
			}

			// Get footer
			$footer = $this->GetOption('file_footer','');

			if($footer != '')
			{
				$footer = $mod->ProcessTemplateFromData($footer);
			}

			// Write file
			if(file_exists($filespec))
			{
				$rows = file($filespec);
				$fp = fopen($filespec, 'w');

				foreach($rows as $oneline)
				{
					if(substr($footer, 0, strlen($oneline)) == $oneline)
					{
						break;
					}
					fwrite($fp,$oneline);
				}
			}
			else
			{
				$fp = fopen($filespec, 'w');
			}

			fwrite($fp,$header.$newline.$footer);
			fclose($fp);
		}
		else if ($this->GetOption('file_type','false') == 1)
		{ // If File Type is "RTF"
			$header = $this->GetOption('file_header','');
			if ($header != '') {
				$header = $mod->ProcessTemplateFromData($header);
			}
			$header = preg_replace('/(\r\n)/', '\par$1', $header);
			if ($this->GetOption('rtf_template_type') == 0)
			{ // If the RTF Template Type is Basic
				$template = $this->GetOption('file_template','');
				if ($template == '') {
					$template = $form->createSampleTemplate();
				}
				$template = $mod->ProcessTemplateFromData($template);
				$template = preg_replace('/(\r\n)/', '\par$1', $template);
			}
			else if ($this->GetOption('rtf_template_type') == 1)
			{ // If the RTF Template Type is Advanced
				$template = file_get_contents(dirname(__FILE__).'/../templates/'.$this->GetOption('rtf_file_template','RTF_TemplateAdvanced.rtf'));

				// To avoid the Smarty Parser eating the RTF Tags (which also use curly braces), we need to swap the curly braces temporarily
				// to parse "Smarty" tags in the RTF Template. To use Smarty tags in the template, we'll have to use a unique enclosure of 
				// percent sign and square bracket (%[TAG]%) instead of curly braces.
				$search = array("{", "}", "%[", "]%");
				$replace = array("<RTF_TAG>", "</RTF_TAG>", "{", "}");
				$template = str_replace($search, $replace, $template);
				$template = $mod->ProcessTemplateFromData($template);
				$search = array("<RTF_TAG>", "</RTF_TAG>");
				$replace = array("{", "}");
				$template = str_replace($search, $replace, $template);
			}
			$footer = $this->GetOption('file_footer','');
			if ($footer != '') {
				$footer = $mod->ProcessTemplateFromData($footer);
			}
			$footer = preg_replace('/(\r\n)/', '\par$1', $footer);

			if ($this->GetOption('rtf_template_type') == 0)
			{ // Basic
				$rtf_template = file_get_contents(dirname(__FILE__).'/../templates/'.$this->GetOption('rtf_file_template','RTF_TemplateBasic.rtf'));
				$search = array("%%HEADER%%", "%%FIELDS%%", "%%FOOTER%%");
				$replace = array($header, $template, $footer);
				$rtf_content = str_replace($search, $replace, $rtf_template);
			}
			else if ($this->GetOption('rtf_template_type') == 1)
			{ // Advanced
				$search = array("%%HEADER%%", "%%FOOTER%%");
				$replace = array($header, $footer);
				$rtf_content = str_replace($search, $replace, $template);
			}

			$put = file_put_contents($filespec, $rtf_content);
		}

		if (strpos($filespec,$config['root_path']) !== FALSE)
		{
			$relurl = str_replace($config['root_path'],'',$filespec);
		}
		$url = $config['root_url'].$relurl;
		$url = str_replace("\\", "/", $url);

		$this->SetValue(array($filespec, $url, $relurl, $evald_filename));

		$mod->ReturnFileLock();
		return array(true,'');
	}

	function SetValue($valStr)
	{
		//error_log($this->GetName().':'.print_r($valStr,true));
		$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
		{
			if (is_array($valStr))
			{
				for ($i=0;$i<count($valStr);$i++)
				{
					while ($valStr[$i] != $fm->unmy_htmlentities($valStr[$i]))
					{
						$valStr[$i] = $fm->unmy_htmlentities($valStr[$i]);
					}
				}
				$this->Value = $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);
			}
		}
	}

	function GetHumanReadableValue($as_string=true)
	{
		$mod = $this->form_ptr->module_ptr;
		if ($as_string && is_array($this->Value) && isset($this->Value[1]))
		{
			return $this->Value[1];
		}
		else
		{
			return $this->Value;
		}
	}

	function PrePopulateAdminForm($formDescriptor)
	{
		$mod = $this->form_ptr->module_ptr;
		$config = cmsms()->GetConfig();
		$file_type = $this->GetOption('file_type','false');
		$rtf_template_type = $this->GetOption('rtf_template_type','false');

		$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;
		$parmMain['opt_file_footer']['is_oneline']=true;
		$parmMain['opt_file_footer']['is_footer']=true;

		array_push($main,array($mod->Lang('title_file_root'),
			$mod->CreateInputText($formDescriptor, 'fbrp_opt_fileroot',
				$this->GetOption('fileroot',$config['uploads_path']),80,255).'<br />'.
				$mod->Lang('title_file_root_help')));

		array_push($main,array($mod->Lang('title_file_name'),
			array($mod->CreateInputText($formDescriptor, 'fbrp_opt_filespec',
					$this->GetOption('filespec',''),80,255),
				$this->form_ptr->AdminTemplateHelp($formDescriptor,$parmMain))));

		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')));

		// array("Text displayed in option tag" => "Value of option tag");
		$file_type_list = array("TXT"=>0,
			"RTF"=>1);
		array_push($adv,array($mod->Lang('title_file_type'),
			$mod->CreateInputDropdown($formDescriptor,
					'fbrp_opt_file_type',$file_type_list,
					$file_type)));

		array_push($adv,array($mod->Lang('title_rtf_file_template'),
			array($mod->CreateInputText($formDescriptor, 'fbrp_opt_rtf_file_template', $this->GetOption('rtf_file_template','RTF_TemplateBasic.rtf'), 50, 255),
				$mod->Lang('help_rtf_file_template'))));

		$rtf_template_type_list = array("Basic"=>0,
			"Advanced"=>1);
		array_push($adv,array($mod->Lang('title_rtf_template_type'),
			array($mod->CreateInputDropdown($formDescriptor,
					'fbrp_opt_rtf_template_type',$rtf_template_type_list,
					$rtf_template_type),
				$mod->Lang('help_rtf_template_type')
			)));

		array_push($adv,array($mod->Lang('title_unique_file_template'),
			array($mod->CreateTextArea(false, $formDescriptor, $this->GetOption('file_template',''), 'fbrp_opt_file_template', 'module_fb_area_wide', '','','',11,26),
				$mod->Lang('help_unique_file_template')."\n".
						$this->form_ptr->AdminTemplateHelp($formDescriptor,$parmMain))));

		array_push($adv,array($mod->Lang('title_file_header'),
			array($mod->CreateTextArea(false, $formDescriptor, $this->GetOption('file_header',''),'fbrp_opt_file_header', 'module_fb_area_short'),
				$mod->Lang('help_file_header_template'))));

		array_push($adv,array($mod->Lang('title_file_footer'),
			array($mod->CreateTextArea(false, $formDescriptor, $this->GetOption('file_footer',''), 'fbrp_opt_file_footer', 'module_fb_area_short'),
				$mod->Lang('help_file_footer_template'))));

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

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

}

?>
]]></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->IsEmailDisposition = 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'];
    } elseif (isset($params['fbrp_set_from_form'])) {
	
		$this->HideLabel = 0;
    }
	
    if (isset($params['fbrp_required'])) {
	
		$this->Required = $params['fbrp_required'];
    } elseif (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;
		}
    }

	// Check value setup against $params
    if (isset($params['fbrp__'.$this->Id]) && (is_array($params['fbrp__'.$this->Id]) || strlen($params['fbrp__'.$this->Id]) > 0)) {
	
	   $this->SetValue($params['fbrp__'.$this->Id]);
    }
		
  } // end of __construct()

  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 '';
  }

  // Sends logic along with field, also allows smarty logic
  // Dosen't need override in most cases
  function GetFieldLogic() 
  {
	$mod = $this->form_ptr->module_ptr;
	$code = $this->GetOption('field_logic','');
	
	if(!empty($code)) {
	
		return $mod->ProcessTemplateFromData($code);
	}
  }
  
  // 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 GetVariableName()
  {
    $maxvarlen = 24;
    $string = strtolower(preg_replace('/\s+/','_',$this->Name));
    $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 GetCSSIdTag($suffix='')
  {
      return ' id="'.$this->GetCSSId($suffix).'"';
  }

  function GetCSSId($suffix='')
  {
	$alias = $this->GetAlias();
	if (empty($alias))
      {
      $cssid = 'fbrp__'.$this->Id;
      if ($this->HasMultipleFormComponents())
         {
         $cssid .= '_1';
         }
      }
   else
      {
      $cssid = $alias;
      }
   $cssid .= $suffix;
   return $cssid;
  }

  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 IsEmailDisposition()
  {
    return $this->IsEmailDisposition;
  }

  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);
  }


  // Base backended fields configuration
  function PrePopulateBaseAdminForm($formDescriptor,$disposeOnly=0)
  {
    $mod = $this->form_ptr->module_ptr;
	
	// Do the field type check
    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);
    }
		
	// Init main tab	
    $main = array(
				array($mod->Lang('title_field_name'),$mod->CreateInputText($formDescriptor, 'fbrp_field_name', $this->GetName(), 50)),
				array($mod->Lang('title_field_type'),$typeInput)
			);

	// Init advanced tab
    $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_helptext'),$mod->CreateTextArea(false, $formDescriptor, $this->GetOption('helptext',''), 'fbrp_opt_helptext','module_fb_area_short')));
			array_push($adv,array($mod->Lang('title_field_javascript'),$mod->CreateTextArea(false, $formDescriptor, $this->GetOption('javascript',''), 
								'fbrp_opt_javascript','module_fb_area_short','','', '', '80', '15','','js').'<br />'.$mod->Lang('title_field_javascript_long')));
			array_push($adv,array($mod->Lang('title_field_logic'),$mod->CreateTextArea(false, $formDescriptor, $this->GetOption('field_logic',''), 
								'fbrp_opt_field_logic','module_fb_area_short','','', '', '80', '15').'<br />'.$mod->Lang('title_field_logic_long')));
			array_push($adv,array($mod->Lang('title_html5'),$mod->CreateInputHidden($formDescriptor,'fbrp_opt_html5','0').$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_html5','1',$this->GetOption('html5','0'))));
		}
	
    } 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()
  {
  }

  // override me as necessary
  function PostFieldSaveProcess(&$params)
  {
  }


  // new method as of Oct 09 that should have been here all along...
  function RemoveAdminField(&$array, $fieldname)
  {
		$reqIndex = -1;
    	for ($i=0;$i<count($array);$i++)
      		{
			   if ($array[$i]->title == $fieldname)
	  			   {
	    		   $reqIndex = $i;
	  			   }
      		}
    	if ($reqIndex != -1)
      		{
			   array_splice($array, $reqIndex,1);
      		}
  }

  function CheckForAdvancedTab(&$advArray)
   {
    if (count($advArray) == 0)
      {
	   $advArray[0]->title = $mod->Lang('tab_advanced');
	   $advArray[0]->input = $mod->Lang('title_no_advanced_options');
      }
   }

  // clear fields unused by invisible dispositions
  function HiddenDispositionFields(&$mainArray, &$advArray, $hideReq=true)
  {
	$mod = $this->form_ptr->module_ptr;

	// remove the "required" field
    if ($hideReq) {
      $this->RemoveAdminField($mainArray, $mod->Lang('title_field_required'));
    }
	
    // remove the "hide name" field
    $this->RemoveAdminField($advArray, $mod->Lang('title_hide_label'));
	
    // remove the "css" field
    $this->RemoveAdminField($advArray, $mod->Lang('title_field_css_class'));
	
    // hide "javascript"
    $this->RemoveAdminField($advArray, $mod->Lang('title_field_javascript'));
	
    // hide "logic"
    $this->RemoveAdminField($advArray, $mod->Lang('title_field_logic'));	
	
    // hide "help text"
    $this->RemoveAdminField($advArray, $mod->Lang('title_field_helptext'));

    $this->CheckForAdvancedTab($advArray);
  }
	

  // 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 me!
  function GetAllHumanReadableValues()
  {
		
	$mod = $this->form_ptr->module_ptr;	
	if(in_array('option_value',$this->GetOptionNames())) {
		
		if(count($this->GetOption('option_value')) > 0) {
		
			return $this->GetOption('option_value');
		}
	}
	
	return false;
  }	


  // override this if you have some unusual format for values,
  // especially if "false" is a valid value!
  function HasValue($deny_blank_responses=false)
  {
    if ($this->GetFieldType() == 'TextField' || $this->GetFieldType() == 'TextAreaField')
    {
      // fields with defaults
      $def = $this->GetOption('default', '');
      
      if( $this->Value !== false && ($def == '' || $this->Value != $def) )
      {
        if( $deny_blank_responses && !is_array($this->Value) && preg_match('/^\s+$/',$this->Value) )
        {
          return false;
        }
        
      return true;
      }
    }
    #elseif ($this->Value !== false && ( is_array($this->Value) && strlen( implode('', $this->Value) ) > 0))
    # ^ This wouldn't work: a value can't simultaneously be and not be an array... (JM)
    # so no fix to bug #7371 yet (JM)
    elseif ($this->Value !== false) 
    {
      if ($deny_blank_responses && (!is_array($this->Value) && preg_match('/^\s+$/', $this->Value)))
      {
        return false;
      }
      
      return true;
    }

    return 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)
  {

  //error_log($this->GetName().':'.print_r($valStr,true));
    $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);
    }
  }

  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($returnid)
  {
    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\tdisplay_in_submission=\"".$this->DisplayInSubmission."\"";
	$xmlstr .= ">\n";
	$xmlstr .= "\t\t\t<field_name><![CDATA[".$this->Name."]]></field_name>\n";
	$xmlstr .= "\t\t\t<options>\n".$this->OptionsAsXML()."\t\t\t</options>\n";
	if ($exportValues)
		{
			$xmlstr .= "\t\t\t<human_readable_value><![CDATA[".
            $this->GetHumanReadableValue().
            "]]></human_readable_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><![CDATA[".$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];
	}
      return false;
    }

	
  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[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwNiBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDYgYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCgpjbGFzcyBmYkZpZWxkc2V0RW5kIGV4dGVuZHMgZmJGaWVsZEJhc2UgewoKICBmdW5jdGlvbiBmYkZpZWxkc2V0RW5kKCYkZm9ybV9wdHIsICYkcGFyYW1zKQogIHsKICAgICR0aGlzLT5mYkZpZWxkQmFzZSgkZm9ybV9wdHIsICRwYXJhbXMpOwogICAgJG1vZCA9ICRmb3JtX3B0ci0+bW9kdWxlX3B0cjsKICAgICR0aGlzLT5UeXBlID0gJ0ZpZWxkc2V0RW5kJzsKICAgICR0aGlzLT5EaXNwbGF5SW5Gb3JtID0gdHJ1ZTsKICAgICR0aGlzLT5EaXNwbGF5SW5TdWJtaXNzaW9uID0gZmFsc2U7CiAgICAkdGhpcy0+Tm9uUmVxdWlyYWJsZUZpZWxkID0gdHJ1ZTsKICAgICR0aGlzLT5WYWxpZGF0aW9uVHlwZXMgPSBhcnJheSgpOyAgICAKICAgICR0aGlzLT5IYXNMYWJlbCA9IDA7CiAgICAkdGhpcy0+TmVlZHNEaXYgPSAwOwogICAgJHRoaXMtPnNvcnRhYmxlID0gZmFsc2U7CiAgfQoKICBmdW5jdGlvbiBHZXRGaWVsZElucHV0KCRpZCwgJiRwYXJhbXMsICRyZXR1cm5pZCkKICB7CiAgICByZXR1cm4gJzwvZmllbGRzZXQ+JzsKICB9CgogIGZ1bmN0aW9uIFN0YXR1c0luZm8oKQogIHsKICAgIHJldHVybiAnJzsKICB9CgogIGZ1bmN0aW9uIEdldEh1bWFuUmVhZGFibGVWYWx1ZSgkYXNfc3RyaW5nPXRydWUpCiAgewogICAgLy8gdGhlcmUncyBub3RoaW5nIGh1bWFuIHJlYWRhYmxlIGFib3V0IGEgZmllbGRzZXQuCiAgICAkcmV0ID0gJ1tFbmQgRmllbGRzZXQ6ICcuJHRoaXMtPlZhbHVlLiddJzsKCWlmICgkYXNfc3RyaW5nKQoJCXsKCQlyZXR1cm4gJHJldDsKCQl9CgllbHNlCgkJewoJCXJldHVybiBhcnJheSgkcmV0KTsKCQl9CiAgfQoJCiAgZnVuY3Rpb24gUHJlUG9wdWxhdGVBZG1pbkZvcm0oJGZvcm1EZXNjcmlwdG9yKQogIHsKICAgICRtb2QgPSAkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CiAgICAkbWFpbiA9IGFycmF5KCk7CiAgICAkYWR2ID0gYXJyYXkoKTsKICAgIHJldHVybiBhcnJheSgnbWFpbic9PiRtYWluLCdhZHYnPT4kYWR2KTsKICB9CgoJZnVuY3Rpb24gUG9zdFBvcHVsYXRlQWRtaW5Gb3JtKCYkbWFpbkFycmF5LCAmJGFkdkFycmF5KQoJewoJCSRtb2QgPSAkdGhpcy0+Zm9ybV9wdHItPm1vZHVsZV9wdHI7CiAgICAgICR0aGlzLT5SZW1vdmVBZG1pbkZpZWxkKCRhZHZBcnJheSwgJG1vZC0+TGFuZygndGl0bGVfZmllbGRfamF2YXNjcmlwdCcpKTsKICAgICR0aGlzLT5DaGVja0ZvckFkdmFuY2VkVGFiKCRhZHZBcnJheSk7Cgl9CgoKfQoKPz4K]]></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[<?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 fbFileUploadField extends fbFieldBase {

  public function __construct(&$form_ptr, &$params)
  {
    parent::__construct($form_ptr, $params);
    $mod = $form_ptr->module_ptr;
    $this->Type = 'FileUploadField';
    //    $this->DisplayType = $mod->Lang('field_type_file_upload');
    $this->ValidationTypes = array(
    $mod->Lang('validation_none')=>'none');
    $this->sortable = false;
  }

  public function GetFieldInput($id, &$params, $returnid)
  {
    $mod = $this->form_ptr->module_ptr;
    $js = $this->GetOption('javascript','');
    $txt = '';
	$html5 = '';

	if ($this->GetOption('html5','0') == '1'&& $this->IsRequired()) 
	{
		$html5 = ' required';
	}    
    # unless someone explains me why this should even be here
    # it will be definitly removed on a future version
    # Jo Morg
//    if($this->Value != '')
//    {
//      $txt .= $this->GetHumanReadableValue()."<br />";  // Value line
//    }
//    $txt .= $mod->CreateFileUploadInput($id,'fbrp__'.$this->Id,$js.$this->GetCSSIdTag()); // Input line
//    if($this->Value != '')
//    {
//      $txt .= $mod->CreateInputCheckbox($id, 'fbrp_delete__'.$this->Id, -1).'&nbsp;'.$mod->Lang('delete')."<br />"; // Delete line
//    }
###################################################################
    $txt .= $mod->CreateFileUploadInput($id,'fbrp__'.$this->Id,$html5.$js.$this->GetCSSIdTag()); // Input line
    // Extras
    if ($this->GetOption('show_details','0') == '1')
    {
      $ms = $this->GetOption('max_size');
      if ($ms != '')
      {
        $txt .= ' '.$mod->Lang('maximum_size').': '.$ms.'kb';
      }
      $exts = $this->GetOption('permitted_extensions');
      if ($exts != '')
      {
        $txt .= ' '.$mod->Lang('permitted_extensions') . ': '.$exts;
      }
    }
    return $txt;
  }

  public function Load($id, &$params, $loadDeep=false)
  {
    $mod = $this->form_ptr->module_ptr;
    parent::Load($id,$params,$loadDeep);

    if( isset( $_FILES ) && isset( $_FILES[$mod->module_id.'fbrp__'.$this->Id] ) && $_FILES[$mod->module_id.'fbrp__'.$this->Id]['size'] > 0 )
    {
      // Okay, a file was uploaded
      $this->SetValue($_FILES[$mod->module_id.'fbrp__'.$this->Id]['name']);
    }
  }

  function GetHumanReadableValue($as_string=true)
  {
    if ($this->GetOption('suppress_filename', '0') != '0')
    {
      return '';
    }
    
    $mod = $this->form_ptr->module_ptr;
    
    if ($as_string && is_array($this->Value) && isset($this->Value[1]))
    {
      return $this->Value[0];
    }
    else
    {
      return $this->Value;
    }
  }

  public function StatusInfo()
  {
    $mod = $this->form_ptr->module_ptr;
    $ms = $this->GetOption('max_size','');
    $exts = $this->GetOption('permitted_extensions','');
    $ret = '';
    if ($ms != '')
    {
      $ret .= $mod->Lang('maximum_size').': '.$ms.'kb, ';
    }
    if ($exts != '')
    {
      $ret .= $mod->Lang('permitted_extensions') . ': '.$exts.', ';
    }
    if ($this->GetOption('file_destination','') != '')
    {
      $ret .= $this->GetOption('file_destination','');
    }
    if ($this->GetOption('allow_overwrite','0') != '0')
    {
      $ret .= ' '.$mod->Lang('overwrite');
    }
    else
    {
      $ret .= ' '.$mod->Lang('nooverwrite');
    }
    return $ret;
  }


  public function PrePopulateAdminForm($formDescriptor)
  {
    $mod = $this->form_ptr->module_ptr;
    $ms = $this->GetOption('max_size');
    $exts = $this->GetOption('permitted_extensions');
    $show = $this->GetOption('show_details','0');
    $sendto_uploads = $this->GetOption('sendto_uploads','false');
    $uploads_category = $this->GetOption('uploads_category');
    $uploads_destpage = $this->GetOption('uploads_destpage');

    $main = array(
    array($mod->Lang('title_maximum_size'),
    $mod->CreateInputText($formDescriptor,
                'fbrp_opt_max_size', $ms, 5, 5).
      ' '.$mod->Lang('title_maximum_size_long')),
    array($mod->Lang('title_permitted_extensions'),
    $mod->CreateInputText($formDescriptor,
                'fbrp_opt_permitted_extensions',
    $exts,25,80).'<br/>'.
    $mod->Lang('title_permitted_extensions_long')),
    array($mod->Lang('title_show_limitations'),
    $mod->CreateInputHidden($formDescriptor,'fbrp_opt_show_details','0').
    $mod->CreateInputCheckbox($formDescriptor,
              'fbrp_opt_show_details', '1', $show).
      ' '.$mod->Lang('title_show_limitations_long')),
    array($mod->Lang('title_allow_overwrite'),
    $mod->CreateInputHidden($formDescriptor,'fbrp_opt_allow_overwrite','0').
    $mod->CreateInputCheckbox($formDescriptor,
              'fbrp_opt_allow_overwrite', '1', $this->GetOption('allow_overwrite','0')).
      ' '.$mod->Lang('title_allow_overwrite_long'))
    );

    $uploads = $mod->GetModuleInstance('Uploads');
    $sendto_uploads_list = array($mod->Lang('no')=>0,
    $mod->Lang('yes')=>1);
    $adv = array();

    $file_rename_help = $mod->Lang('file_rename_help'). $this->form_ptr->fieldValueTemplate().
    '<tr><td>$ext</td><td>'.$mod->Lang('original_file_extension').'</td></tr></table>';

    array_push($adv,array($mod->Lang('title_file_rename'),
    $mod->CreateInputText($formDescriptor,'fbrp_opt_file_rename',
    $this->GetOption('file_rename',''),60,255).
    $file_rename_help));
    array_push($adv, array($mod->Lang('title_suppress_filename'),
    $mod->CreateInputHidden($formDescriptor,'fbrp_opt_suppress_filename','0').
    $mod->CreateInputCheckbox($formDescriptor,
            'fbrp_opt_suppress_filename', '1', 
    $this->GetOption('suppress_filename','0'))));
      
    array_push($adv, array($mod->Lang('title_suppress_attachment'),
    $mod->CreateInputHidden($formDescriptor,'fbrp_opt_suppress_attachment',0).
    $mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_suppress_attachment', 1, $this->GetOption('suppress_attachment',1))));
      
    array_push($main, array($mod->Lang('title_remove_file_from_server'),
    $mod->CreateInputHidden($formDescriptor,'fbrp_opt_remove_file','0').
    $mod->CreateInputCheckbox($formDescriptor,
                  'fbrp_opt_remove_file', '1', 
    $this->GetOption('remove_file','0')).
    $mod->Lang('help_ignored_if_upload')));
    array_push($main, array($mod->Lang('title_file_destination'),
    $mod->CreateInputText($formDescriptor,'fbrp_opt_file_destination',
    $this->GetOption('file_destination', cmsms()->config['uploads_path']),60,255).
    $mod->Lang('help_ignored_if_upload')));

    if( $uploads )
    {
      $categorylist = $uploads->getCategoryList();
      array_push($adv,array($mod->Lang('title_sendto_uploads'),
      $mod->CreateInputDropdown($formDescriptor,
                 'fbrp_opt_sendto_uploads',$sendto_uploads_list,
      $sendto_uploads)));

      array_push($adv,array($mod->Lang('title_uploads_category'),
      $mod->CreateInputDropdown($formDescriptor,
                 'fbrp_opt_uploads_category',$categorylist,'',
      $uploads_category)));
      array_push($adv,array($mod->Lang('title_uploads_destpage'),
      $mod->CreatePageDropdown($formDescriptor,
                'opt_uploads_destpage',$uploads_destpage)));
    }


    return array('main'=>$main,'adv'=>$adv);
  }

  public function PostDispositionAction()
  {
    if ($this->GetOption('remove_file','0') == '1')
    {
      $filepath = cms_join_path($this->GetOption('file_destination'), $this->Value);
      if (file_exists($filepath))
      {
        unlink($filepath);
      }
    }
  }

  public function Validate()
  {
    $this->validated = true;
    $this->validationErrorText = '';
    $ms = $this->GetOption('max_size');
    $exts = $this->GetOption('permitted_extensions','');
    $mod = $this->form_ptr->module_ptr;
    //$fullAlias = $this->GetValue(); -- Stikki modifys: Now gets correct alias
    $fullAlias = $mod->module_id.'fbrp__'.$this->Id;
    if ($_FILES[$fullAlias]['size'] < 1 && ! $this->Required)
    {
      return array(true,'');
    }
    if ($_FILES[$fullAlias]['size'] < 1 && $this->Required )
    {
      $this->validated = false;
      $this->validationErrorText = $mod->Lang('required_field_missing');
    }
    else if ($ms != '' && $_FILES[$fullAlias]['size'] > ($ms * 1024))
    {
      $this->validationErrorText = $mod->Lang('file_too_large'). ' '.$ms.'kb';//($ms * 1024).'kb'; // Stikki mods
      $this->validated = false;
    }
    else if ($exts != '')
    {
      $match = false;
      $legalExts = explode(',',$exts);
      foreach ($legalExts as $thisExt)
      {
        if (preg_match('/\.'.trim($thisExt).'$/i',$_FILES[$fullAlias]['name']))
        {
          $match = true;
        }
        else if (preg_match('/'.trim($thisExt).'/i',$_FILES[$fullAlias]['type']))
        {
          $match = true;
        }
      }
      if (! $match)
      {
        $this->validationErrorText = $mod->Lang('illegal_file_type');
        $this->validated = false;
      }
    }
    return array($this->validated, $this->validationErrorText);
  }
}
?>
]]></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 $module_params = -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, $loadResp=false)
  {
    $this->module_ptr = $module_ptr;
    $this->module_params = $params;
    $this->Fields = array();
    $this->Attrs = array();
    $this->formState = 'new';
		
	// Stikki adding: $id overwrite possible with $param
    if ((!isset($this->module_ptr->module_id) || empty($this->module_ptr->module_id)) && isset($params['module_id'])) {
	
		$this->module_ptr->module_id = $params['module_id'];
    }	 
	  
    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, $loadResp);
    }
	
    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'),
	);
  } // end of __construct()

  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;
  }

// dump params
  function DebugDisplay($params=array())
  {
    $tmp = $this->module_ptr;
    $this->module_ptr = '[mdptr]';

   if (isset($params['FORM']))
		{
		$fpt = $params['FORM'];
		$params['FORM'] = '[form_pointer]';
		}

    $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 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]).val(|TEMPLATE|).change();
}
/* ]]> */
</script>";
	$jsCode .= "<input type=\"button\" value=\"".
$button_text."\" onclick=\"javascript:populate".$fldAlias."(this.form)\" />";
  return $jsCode;
  }


	function fieldValueTemplate()
	{
		$mod = $this->module_ptr;
		$ret = '<table class="module_fb_legend"><tr><th colspan="2">'.$mod->Lang('help_variables_for_computation').'</th></tr>';
		$ret .= '<tr><th>'.$mod->Lang('help_php_variable_name').'</th><th>'.$mod->Lang('help_form_field').'</th></tr>';
		$odd = false;
		$others = $this->GetFields();
		for($i=0;$i<count($others);$i++)
			{
			// Removed by Stikki: BUT WHY?
			//if (!$others[$i]->HasMultipleFormComponents())
				//{
				$ret .= '<tr><td class="'.($odd?'odd':'even').'">$fld_'.$others[$i]->GetId().'</td><td class="'.($odd?'odd':'even').'">' .$others[$i]->GetName() . '</td></tr>';
				//}
			$odd = ! $odd;
			}
		return $ret;
	}

  function createSampleTemplate($htmlish=false,$email=true, $oneline=false,$header=false,$footer=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 />";
				}
			else
				{
				$ret .= $thisVal.': '.$thisKey;
				}
			$ret .= "\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>';
			}
		}
		
	elseif ($footer)
		 {
		 $ret .= '------------------------------------------\nEOF\n';
		 return $ret;
		 }			
		
    $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();
		}
		
	  $ret .= '{if $'.$fldref.' != "" && $'.$fldref.' != "'.$this->GetAttr('unspecified',$mod->Lang('unspecified')).'" }';
	  $fldref = '{$'.$fldref.'}';
	  
	  if ($htmlish)
     	  {
  		  $ret .= '<strong>'.$others[$i]->GetName() . '</strong>: ' . $fldref. "<br />";
  		  }
  	  elseif ($oneline && !$header)
		  {
		  $ret .= $fldref. '{$TAB}';
		  }
	  elseif ($oneline && $header)
		 {
		 $ret .= $others[$i]->GetName().'{$TAB}';
		 }	 
	  else
  	  	  {
	      $ret .= $others[$i]->GetName() . ': ' .$fldref;
	      }
	  	$ret .= "{/if}\n";
		}
      }	  
	  
	 /* Stikki says: Don't see any use for this, correct me if i'm wrong.
    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').
	    '">{$'.$others[$i]->GetVariableName().
	    '} / {$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']);
		$is_footer = (isset($val['is_footer']) && $val['is_footer']);
		
		if ($html_button)
			{
			$button_text = $mod->Lang('title_create_sample_html_template');
			}
		elseif ($is_header)
			{
			$button_text = $mod->Lang('title_create_sample_header_template');
			}
		elseif ($is_footer)
			{
			$button_text = $mod->Lang('title_create_sample_footer_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, $is_footer);
			$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, $is_footer);
		$sample = preg_replace('/\'/',"\\'",$sample);
		$sample = preg_replace('/\n/',"\\n'+\n'", $sample);
		$sampleTemplateCode .= preg_replace('/\|TEMPLATE\|/',"'".$sample."'",
	    $this->createSampleTemplateJavascript($key, $button_text));
		}

    $sampleTemplateCode = preg_replace('/ID/',$formDescriptor, $sampleTemplateCode);
    $ret .= '<tr><td colspan="2">'.$sampleTemplateCode.'</td></tr>';
    $ret .= '</table>';
	
    return $ret;
  }


  function Validate()
  {
    $gCms = cmsms();
    $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;
      }

      $deny_space_validation = ($this->module_ptr->GetPreference('blank_invalid','0') == '1');

      if ($this->Fields[$i]->IsRequired() && $this->Fields[$i]->HasValue($deny_space_validation) === 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);
        }
      }
    }

    $usertagops = $gCms->GetUserTagOperations();
    $udt = $this->GetAttr('validate_udt','');
    $unspec = $this->GetAttr('unspecified',$this->module_ptr->Lang('unspecified'));

    if( $validated == true && !empty($udt) && "-1" != $udt )
    {
      $parms = $params; 
      $others = $this->GetFields();
      for($i=0;$i < count($others);$i++)
      {
        $replVal = '';
        if ($others[$i]->DisplayInSubmission())
        {
          $replVal = $others[$i]->GetHumanReadableValue();
          if ($replVal == '')
          {
            $replVal = $unspec;
          }
        }
        $name = $others[$i]->GetVariableName();
        $parms[$name] = $replVal;
        $id = $others[$i]->GetId();
        $parms['fld_'.$id] = $replVal;
        $alias = $others[$i]->GetAlias();
        if (!empty($alias))
        {
          $parms[$alias] = $replVal;
        }
      }
      $res = $usertagops->CallUserTag($udt,$parms);
      if ($res[0] != true)
      {  
        array_push($message,$res[1]);
        $validated = false;  
      }
    }  
    
    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,$suppress_email=false)
  {
    // 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())
	  {
		if (! ($suppress_email && $this->Fields[$i]->IsEmailDisposition()))
			{
		    $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)
  { 

	// Check if form id given
    $mod = $this->module_ptr;
    
    # minor fix to remove core dependency
    $replacement_inc = cms_join_path($mod->GetModulePath(),'includes', 'replacement.inc');
    include ($replacement_inc);
    
    if ($this->Id == -1)
      {
		return "<!-- no form -->\n";
      }
	  
	// Check if show full form
    if ($this->loaded != 'full')
      {
		$this->Load($this->Id,$params,true);
      }

	// Usual crap
    $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);
    $mod->smarty->assign('actionid',$id);

	// Build hidden
    $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 (isset($params['response_id']))
      {
	  $hidden .= $mod->CreateInputHidden($id,'response_id',$params['response_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);
      }
	  
	  
	  
	// Start building fields
    $fields = array();
    $prev = 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();
			
			// Ryan's ugly fix for Bug 4307
			// We should figure out why this field wasn't populating its Smarty variable
			if ($thisField->GetFieldType() == 'FileUploadField')
				{
				$mod->smarty->assign('fld_'.$thisField->GetId(),$thisField->GetHumanReadableValue());
				$hidden .= $mod->CreateInputHidden($id,
					$testIndex,
					$this->unmy_htmlentities($thisField->GetHumanReadableValue()));
				$thisAtt = $thisField->GetHumanReadableValue(false);
				$mod->smarty->assign('test_'.$thisField->GetId(), $thisAtt);
				$mod->smarty->assign('value_fld'.$thisField->GetId(), $thisAtt[0]);
				}
			
	    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.'[]',
						       $this->unmy_htmlentities($val));
		  }
	      }
	    else
	      {
		$hidden .= $mod->CreateInputHidden($id,
						   $testIndex,
						   $this->unmy_htmlentities($params[$testIndex]));
	      }
	      
      if ($formPageCount < $this->Page && $this->Fields[$i]->DisplayInSubmission())
         {
         $oneset = new stdClass();
         $oneset->value = $this->Fields[$i]->GetHumanReadableValue();

         $mod->smarty->assign($this->Fields[$i]->GetName(),$oneset);

	      if ($this->Fields[$i]->GetAlias() != '')
            {
		      $mod->smarty->assign($this->Fields[$i]->GetAlias(),$oneset);
		      }

	      array_push($prev,$oneset);
         }
	    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->helptext = $thisField->GetOption('helptext');
	$oneset->field_helptext_id = 'fbrp_ht_'.$thisField->GetID();
//	$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()) && ($thisField->GetOption('fbr_edit','0') == '0' || $params['in_admin'] != 1) )
	  {
	    $oneset->hide_name = 1;
	  }
	$oneset->has_label = $thisField->HasLabel();
	$oneset->needs_div = $thisField->NeedsDiv();
	$oneset->name = $thisField->GetName();
	$oneset->input = $this->unmy_htmlentities( $thisField->GetFieldInput($id, $params, $returnid) );
	$oneset->logic = $thisField->GetFieldLogic();
	$oneset->values = $thisField->GetAllHumanReadableValues();
	$oneset->smarty_eval = $thisField->GetSmartyEval()?1:0;
	
	$oneset->multiple_parts = $thisField->HasMultipleFormComponents()?1:0;
	$oneset->label_parts = $thisField->LabelSubComponents()?1:0;
	$oneset->type = $thisField->GetDisplayType();
	$oneset->input_id = $thisField->GetCSSId();

	// Added by Stikki STARTS
	$name_alias = $thisField->GetName();
	$name_alias = str_replace($toreplace, $replacement, $name_alias);
	$name_alias = strtolower($name_alias);
	$name_alias = preg_replace('/[^a-z0-9]+/i','_',$name_alias);

    $mod->smarty->assign($name_alias,$oneset);
	// Added by Stikki ENDS
	
	if ($thisField->GetAlias() != '')
		{
		$mod->smarty->assign($thisField->GetAlias(),$oneset);
		$oneset->alias = $thisField->GetAlias();
		}
	else
		{
		$oneset->alias = $name_alias;
		}

	$fields[$oneset->input_id] = $oneset;
	//array_push($fields,$oneset);
      }
	  
    $mod->smarty->assign_by_ref('fb_hidden',$hidden);
    $mod->smarty->assign_by_ref('fields',$fields);
    $mod->smarty->assign_by_ref('previous',$prev);

    $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("'.$id.'fbrp_submit");
           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','<input class="cms_submit fbsubmit_prev" name="'.$id.'fbrp_prev" id="'.$id.'fbrp_prev" value="'.$this->GetAttr('prev_button_text').'" type="submit" '.$js.' />');						
      }
    else
      {
	$mod->smarty->assign('prev','');
      }

    if ($this->Page < $formPageCount)
      {

	$mod->smarty->assign('submit','<input class="cms_submit fbsubmit_next" name="'.$id.'fbrp_submit" id="'.$id.'fbrp_submit" value="'.$this->GetAttr('next_button_text').'" type="submit" '.$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')));
         #this should work with Captcha 0.4.6 and higher (JM)
         $cptcneedsinput = method_exists($captcha, 'NeedsInputField') ? $captcha->NeedsInputField() : true;
         if($cptcneedsinput) $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','<input class="cms_submit fbsubmit" name="'.$id.'fbrp_submit" id="'.$id.'fbrp_submit" value="'.$this->GetAttr('submit_button_text').'" type="submit" '.$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, $loadResp=false)
  {

    $mod = $this->module_ptr;

	//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;
	$loadResp = true;
      }

    if ($loadDeep)
      {
	  if ($loadResp)
		{
	// 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)
		$fbf = $mod->GetFormBrowserField($formId);
		if ($fbf != false)
			{
			// if we're binding to FEU, get the FEU ID, see if there's a response for
			// that user. If so, load it. Otherwise, bring up an empty form.
			if ($fbf->GetOption('feu_bind','0')=='1')
				{
				$feu = $mod->GetModuleInstance('FrontEndUsers');
				if ($feu == false)
					{
					debug_display("FAILED to instatiate FEU!");
					return;
					}
				if (!isset($_COOKIE['cms_admin_user_id']))
					{
					// Fix for Bug 5422. Adapted from Mike Hughesdon's code.
					$response_id = $mod->GetResponseIDFromFEUID($feu->LoggedInId(), $formId);
					if ($response_id !== false)
						{
						$check = $this->module_ptr->dbHandle->GetOne('select count(*) from '.cms_db_prefix().
							'module_fb_formbrowser where fbr_id=?',array($response_id));
						if ($check == 1)
							{
							$params['response_id'] = $response_id;
							}
						}
					}
				}
			}
	if (isset($params['response_id']))
	  {
	    $loadParams = array('response_id'=>$params['response_id']);
			$loadTypes = array();
	    $this->LoadResponseValues($loadParams, $loadTypes);
	    foreach ($loadParams as $thisParamKey=>$thisParamValue)
	      {
		if (! isset($params[$thisParamKey]))
		  {
				if ($this->GetFormState() == 'update' && $loadTypes[$thisParamKey] == 'CheckboxField')
				{
					$params[$thisParamKey] = '';
				}
				else
				{
					$params[$thisParamKey] = $thisParamValue;
				}
		  }
	      }
	  }
	}
	$sql = 'SELECT * FROM '.cms_db_prefix().'module_fb_field WHERE form_id=? ORDER BY order_by';
	$result = $this->module_ptr->dbHandle->GetArray($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']), $values);
		}
	elseif (isset($params['xml_string']) && ! empty($params['xml_string']))
		{
		xml_parse_into_struct($parser, $params['xml_string'], $values);
		}
	else
		{
		return false;
		}
	xml_parser_free($parser);
	$elements = array();
	$stack = array();
	$fieldMap = array();
	foreach ( $values 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]);
			}
		}
//debug_display($elements);
	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 (isset($params['fbrp_import_formalias']) && !empty($params['fbrp_import_formalias']))
      {
      $this->SetAlias($params['fbrp_import_formalias']);
      }
   else if ($this->inXML($formAttrs['alias']))
		{
		$this->SetAlias($formAttrs['alias']);
		}
   if (isset($params['fbrp_import_formname']) && !empty($params['fbrp_import_formname']))
      {
      $this->SetName($params['fbrp_import_formname']);
      }
	$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')
			{
			$curname =  $this->GetName();
			if (empty($curname))
            {
			   $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'], '');
			//debug_display($className);
		    $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']);
					}
				if ($thisOpt['name'] == 'options')
					{
					foreach ($thisOpt['children'] as $thisOption)
							{
							$newField->OptionFromXML($thisOption);
							}
					}
				}
			$newField->Store(true);
         array_push($this->Fields,$newField);
			$fieldMap[$oldId] = $newField->GetId();
			}
		}

   // clean up references
   
	if (isset($params['fbrp_xml_file']) && ! empty($params['fbrp_xml_file']))
		{
		// need to update mappings in templates.
		$tmp = $this->updateRefs($this->GetAttr('form_template',''), $fieldMap);
		$this->SetAttr('form_template',$tmp);
		$tmp = $this->updateRefs($this->GetAttr('submit_response',''), $fieldMap);
		$this->SetAttr('submit_response',$tmp);

		// need to update mappings in field templates.
      $options = array('email_template','file_template');
		foreach($this->Fields as $fid=>$thisField)
         {
         $changes = false;
         foreach ($options as $to)
            {
            $templ = $thisField->GetOption($to,'');
            if (!empty($templ))
               {
               $tmp = $this->updateRefs($templ, $fieldMap);
               $thisField->SetOption($to,$tmp);
               $changes = true;
               }
            }
		   // need to update mappings in FormBrowser sort fields
         if ($thisField->GetFieldType() == 'DispositionFormBrowser')
            {
            for ($i=1;$i<6;$i++)
               {
               $old = $thisField->GetOption('sortfield'.$i);
               if (isset($fieldMap[$old]))
                  {
                  $thisField->SetOption('sortfield'.$i,$fieldMap[$old]);
                  $changes = true;
                  }
               }
            }
         if ($changes)
            {
            $thisField->Store(true);
            }
         }
         
      $this->Store();
   	}
	
	return true;	
  }


  function updateRefs($text, &$fieldMap)
   {
      foreach ($fieldMap as $k=>$v)
         {
         $text = preg_replace('/([\{\b\s])\$fld_'.$k.'([\}\b\s])/','$1\$fld_'.$v.'$2',$text);
         }
      return $text;
   }

  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)
  {
  
	$db = $this->module_ptr->dbHandle;
	$params = $this->module_params;
  
	// Check if new or old form
	$res = FALSE;
	$j = "";
	$new = FALSE;
	if ($this->Id == -1)
	{
		$this->Id = $db->GenID(cms_db_prefix().'module_fb_form_seq');
		$new = TRUE;
	}
	while(!$res && $j < 10)
	{
		$adj_alias = $this->Alias.$j; 
		if ($new) {
			$sql = "INSERT INTO ".cms_db_prefix()."module_fb_form (form_id, name, alias) VALUES (?, ?, ?)";
			$res = $db->Execute($sql, array($this->Id, $this->Name, $adj_alias));
		} else {
			$sql = "UPDATE ".cms_db_prefix()."module_fb_form set name=?, alias=? where form_id=?";
			$res = $db->Execute($sql, array($this->Name, $adj_alias, $this->Id));
		}
		$j++;
	}
	if( !$res )
	  {
	    die('FATAL SQL ERROR: '.$db->ErrorMsg().'<br/>QUERY: '.$db->sql);
	  }

    // Save out the attrs
    $sql = "DELETE FROM ".cms_db_prefix()."module_fb_form_attr WHERE form_id=?";
    $res = $db->Execute($sql, array($this->Id));
	
    foreach ($this->Attrs as $thisAttrKey=>$thisAttrValue) {
	
		$formAttrId = $db->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 = $db->Execute($sql, array($formAttrId, $this->Id, $thisAttrKey, $thisAttrValue));
	
		if ($thisAttrKey == 'form_template') {
		
			$this->module_ptr->SetTemplate('fb_'.$this->Id,$thisAttrValue);
		}
    }
	
	// Update field position
	$order_list = false;
	if (isset($params['fbrp_sort']))
		{
		$order_list = explode(',',$params['fbrp_sort']);
		}
		
	if(is_array($order_list) && count($order_list) > 0) {
		
		$count = 1;
		$sql = "UPDATE ".cms_db_prefix()."module_fb_field SET order_by=? WHERE field_id=?";

		foreach ($order_list as $onefldid) {
	
			$fieldid = substr($onefldid,5);
			$db->Execute($sql, array($count, $fieldid));
			$count++;
		}
	}
	
	// Reload everything
	$this->Load($this->Id,$params,true);
	
    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 cms_join_path(dirname(__FILE__), $classFile);
    // class names are prepended with "fb" to prevent namespace clash.
    return ( 'fb'.$type );
  }

  function AddEditForm($id, $returnid, $tab, $message='')
  {
    $gCms = cmsms();
    $mod = $this->module_ptr;
	$config = $mod->GetConfig();
  
  

	if(!empty($message)) $mod->smarty->assign('message',$mod->ShowMessage($message));
    $mod->smarty->assign('formstart', $mod->CreateFormStart($id, 'admin_store_form', $returnid));
    $mod->smarty->assign('formid', $mod->CreateInputHidden($id, 'form_id', $this->Id));
    
# fixes for CMSMS 2 compatibility (JM)  
  if( !formbuilder_utils::is_CMS2() )
  {
    $mod->smarty->assign('tab_start',$mod->StartTabHeaders().
              $mod->SetTabHeader('maintab',$mod->Lang('tab_main'),('maintab' == $tab)?true:false).
              $mod->SetTabHeader('submittab',$mod->Lang('tab_submit'),('submittab' == $tab)?true:false).
              $mod->SetTabHeader('symboltab',$mod->Lang('tab_symbol'),('symboltab' == $tab)?true:false).
              $mod->SetTabHeader('captchatab',$mod->Lang('tab_captcha'),('captchatab' == $tab)?true:false).
              $mod->SetTabHeader('udttab',$mod->Lang('tab_udt'),('udttab' == $tab)?true:false).
              $mod->SetTabHeader('templatelayout',$mod->Lang('tab_templatelayout'),('templatelayout' == $tab)?true:false).
              $mod->SetTabHeader('submittemplate',$mod->Lang('tab_submissiontemplate'),('submittemplate' == $tab)?true:false).
              $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('udttab_start',$mod->StartTab("udttab"));
    $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('title_load_template',$mod->Lang('title_load_template'));
	$modLink = $mod->CreateLink($id, 'admin_get_template', $returnid, '', array(), '', true);
	$mod->smarty->assign('security_key',CMS_SECURE_PARAM_NAME.'='.$_SESSION[CMS_USER_KEY]);
	
	$templateList = array($mod->Lang('select_source_template')=>'',$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="jQuery(this).fb_get_template(\''.$mod->Lang('template_are_you_sure').'\',\''.$modLink.'\');"'));
	$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',1) != 0 )
      {
	  $mod->smarty->assign('title_field_alias',
			     $mod->Lang('title_field_alias_short'));
      }

    $mod->smarty->assign('back', $mod->CreateLink($id, 'defaultadmin', '', $mod->Lang('back_top'), array()));

    $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_must_save_order',
			 $mod->Lang('title_must_save_order'));


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

       
//JM
$admintheme = cms_utils::get_theme_object();
//

    $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->Lang('title_submit_help'));
	$mod->smarty->assign('title_submit_response_help', $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('fb_hidden', $mod->CreateInputHidden($id, 'fbrp_form_op',$mod->Lang('updated')).
									$mod->CreateInputHidden($id, 'fbrp_sort','','class="fbrp_sort"'));
	$mod->smarty->assign('adding',0);
	$mod->smarty->assign('save_button', $mod->CreateInputSubmit($id, 'fbrp_submit', $mod->Lang('save')));
	$mod->smarty->assign('submit_button', $mod->CreateInputHidden($id, 'active_tab', '', 'id="fbr_atab"').
		$mod->CreateInputSubmit($id, 'fbrp_submit', $mod->Lang('save_and_continue'),'onclick="jQuery(this).fb_set_tab()"'));
	
	$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();
		$oneset->id = $thisField->GetID();

	    if (!$thisField->DisplayInForm() || $thisField->IsNonRequirableField())
	      {
		$no_avail = $mod->Lang('not_available');
		if($admintheme->themeName == 'NCleanGrey') {

		  $oneset->disposition = '<img src="'.$config['root_url'].'/modules/'.$mod->GetName().'/images/stop.gif" width="20" height="20" alt="'.$no_avail.'" title="'.$no_avail.'" />';
		} else {
		  
		  $oneset->disposition = '<img src="'.$config['root_url'].'/modules/'.$mod->GetName().'/images/stop.gif" width="16" height="16" alt="'.$no_avail.'" title="'.$no_avail.'" />';
		}
	      }
	    else if ($thisField->IsRequired())
	      {
		$oneset->disposition = $mod->CreateLink($id, 'admin_update_field_required', '', $admintheme->DisplayImage('icons/system/true.gif','true','','','systemicon'), array('form_id'=>$this->Id,'fbrp_active'=>'off','field_id'=>$thisField->GetId()),'', '', '', 'class="true" onclick="jQuery(this).fb_admin_update_field_required(); return false;"');
	      }
	    else
	      {
		$oneset->disposition = $mod->CreateLink($id, 'admin_update_field_required', '', $admintheme->DisplayImage('icons/system/false.gif','false','','','systemicon'), array('form_id'=>$this->Id,'fbrp_active'=>'on','field_id'=>$thisField->GetId()),'', '', '', 'class="false" onclick="jQuery(this).fb_admin_update_field_required(); return false;"');
	      }
		  
	    $oneset->field_status = $thisField->StatusInfo();
	    $oneset->editlink = $mod->CreateLink($id, 'admin_add_edit_field', '', $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', '', $admintheme->DisplayImage('icons/system/delete.gif',$mod->Lang('delete'),'','','systemicon'), array('field_id'=>$thisField->GetId(),'form_id'=>$this->Id),'', '', '', 'onclick="jQuery(this).fb_delete_field(\''.$mod->Lang('are_you_sure_delete_field',htmlspecialchars($thisField->GetName())).'\'); return false;"');

		/* Removed By Stikki, reinstated by SjG with Javascript to hide it if Javascript's enabled. */
		if ($count > 1)
			{
			$oneset->up = $mod->CreateLink($id, 'admin_update_field_order', '', $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', '', $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;';
			}

	    ($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,$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));

	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->CreateInputHidden($id, 'fbrp_sort','','id="fbrp_sort"'));
	$mod->smarty->assign('adding',1);
      }

	$mod->smarty->assign('cancel_button', $mod->CreateInputSubmit($id, 'fbrp_cancel', $mod->Lang('cancel')));		
    $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,256));
    $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,256));
    $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_predisplay_udt',
                         $mod->Lang('title_form_predisplay_udt'));
    $mod->smarty->assign('title_form_predisplay_each_udt',
                         $mod->Lang('title_form_predisplay_each_udt'));
    {
      $usertagops = $gCms->GetUserTagOperations();
      $usertags = $usertagops->ListUserTags();
      $usertaglist = array();
      $usertaglist[$mod->lang('none')] = -1;
      foreach( $usertags as $key => $value )
        {
  	  $usertaglist[$value] = $key;
        }
      $mod->smarty->assign('input_form_predisplay_udt',
            $mod->CreateInputDropdown($id,'fbrp_forma_predisplay_udt',$usertaglist,-1,
                                      $this->GetAttr('predisplay_udt',-1)));
      $mod->smarty->assign('input_form_predisplay_each_udt',
            $mod->CreateInputDropdown($id,'fbrp_forma_predisplay_each_udt',$usertaglist,-1,
                                      $this->GetAttr('predisplay_each_udt',-1)));

    }
    $mod->smarty->assign('title_form_validate_udt',
                         $mod->Lang('title_form_validate_udt'));
    {
      $usertagops = $gCms->GetUserTagOperations();
      $usertags = $usertagops->ListUserTags();
      $usertaglist = array();
      $usertaglist[$mod->lang('none')] = -1;
      foreach( $usertags as $key => $value )
        {
  	  $usertaglist[$value] = $key;
        }
      $mod->smarty->assign('input_form_validate_udt',
            $mod->CreateInputDropdown($id,'fbrp_forma_validate_udt',$usertaglist,-1,
                                      $this->GetAttr('validate_udt',-1)));
    }

    $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','module_fb_area_wide','fb_form_template',
				'', '', '80', '15','','html'));

	$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',
				'', '', '80', '15','','js').
				'<br />'.$mod->Lang('title_submit_javascript_long'));

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

	$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));
  
  # fixes for CMSMS 2 compatibility (JM)
  # we need this to get (at least) the lang method on the template {$frmbld->Lang('string')}
  $mod->smarty->assign('frmbld', $mod);
    
  if( formbuilder_utils::is_CMS2() )
  {
    return $mod->ProcessTemplate('AddEditForm2.tpl');
  }

	return $mod->ProcessTemplate('AddEditForm.tpl');
  }

	// Add new field
    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;
		
    if(!empty($message)) $mod->smarty->assign('message',$mod->ShowMessage($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());
    
    #### JM fixes for CMSMS 2
    if( !formbuilder_utils::is_CMS2() )
    {
          $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 if($aefield->GetFieldType() != '')
      {
	$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')));
      }

	$mod->smarty->assign('cancel',$mod->CreateInputSubmit($id, 'fbrp_cancel', $mod->Lang('cancel')));	  
	  
    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);
    
    # fixes for CMSMS 2 compatibility (JM)
    # we need this to get (at least) the lang method on the template {$frmbld->Lang('string')}
    $mod->smarty->assign('frmbld', $mod);
     
    if( formbuilder_utils::is_CMS2() )
    {
      return $mod->ProcessTemplate('AddEditField2.tpl');
    }
    
    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;
	$ret = false;
	for ($i=0;$i<count($this->Fields);$i++)
		{
		if ($this->Fields[$i]->GetId() == $field_id)
	    	{
			$index = $i;
			}
		}
	if ($index != -1)
		{
	  	$ret = $this->Fields[$index];
		}
	return $ret;
    }


  function &GetFieldByAlias($field_alias)
    {
	$index = -1;
	$ret = false;
	for ($i=0;$i<count($this->Fields);$i++)
		{
		if ($this->Fields[$i]->GetAlias() == $field_alias)
	    	{
			$index = $i;
			}
		}
	if ($index != -1)
		{
	  	$ret = $this->Fields[$index];
		}
	return $ret;
    }

  function &GetFieldByName($field_name)
    {
	$index = -1;
	$ret = false;
	for ($i=0;$i<count($this->Fields);$i++)
		{
		if ($this->Fields[$i]->GetName() == $field_name)
	    	{
			$index = $i;
			}
		}
	if ($index != -1)
		{
	  	$ret = $this->Fields[$index];
		}
	return $ret;
    }


  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();
      }
  }

  // FormBrowser >= 0.3 Response load method. This populates the Field values directly
  // (as opposed to LoadResponseValues, which places the values into the $params array)
  function LoadResponse($response_id)
  {
	$mod = $this->module_ptr;
	$db = $this->module_ptr->dbHandle;
		
	$oneset = new StdClass();
	$res = $db->Execute('SELECT response, form_id FROM '.cms_db_prefix().
					'module_fb_formbrowser WHERE fbr_id=?', array($response_id));

	if ($res && $row=$res->FetchRow())
		{
		$oneset->xml = $row['response'];
		$oneset->form_id = $row['form_id'];
		}
	if ($oneset->form_id != $this->GetId())
		{
		return false;
		}
	$fbField = $this->GetFormBrowserField();
	if ($fbField == false)
		{
		// error handling goes here.
		echo($mod->Lang('error_has_no_fb_field'));
		}
	$mod->HandleResponseFromXML($fbField, $oneset);

	list($fnames, $aliases, $vals) = $mod->ParseResponseXML($oneset->xml, false);
	$this->ResetFields();
	foreach ($vals as $id=>$val)
		{
		//error_log("setting value of field ".$id." to be ".$val);
		$index = $this->GetFieldIndexFromId($id);
		if($index != -1 &&  is_object($this->Fields[$index]) )
			{
			$this->Fields[$index]->SetValue($val);
			}
		}
	return true;
  }

	// Check if FormBroweiser field exists
	function GetFormBrowserField()
	{
		$fields = $this->GetFields();
		$fbField = false;
		foreach($fields as $thisField)
			{
			if ($thisField->GetFieldType() == 'DispositionFormBrowser')
				{
				$fbField = $thisField;
				}
			}
		if ($fbField == false)
			{
			// error handling goes here.
			return false;	
			}
		return $fbField;		
	}


  function ReindexResponses()
  {
	@set_time_limit(0);
	$mod = $this->module_ptr;
	$db = $this->module_ptr->dbHandle;
	$responses = array();
	$res = $db->Execute('SELECT fbr_id FROM '.cms_db_prefix().'module_fb_formbrowser WHERE form_id=?', array($this->Id));
	while ($res && $row=$res->FetchRow())
		{
		array_push($responses,$row['fbr_id']);
		}
	$fbr_field = $this->GetFormBrowserField();
	foreach($responses as $this_resp)
		{
		if ($this->LoadResponse($this_resp))
			{
			$this->StoreResponse($this_resp,'',$fbr_field);
			}
		}
  }


  // FormBrowser >= 0.3 Response load method. This populates the $params array for later processing/combination
  // (as opposed to LoadResponse, which places the values into the Field values directly)
  function LoadResponseValues(&$params, &$types)
  {
	$mod = $this->module_ptr;
	$db = $this->module_ptr->dbHandle;
	$oneset = new StdClass();
	$form_id = -1;
	$res = $db->Execute('SELECT response, form_id FROM '.cms_db_prefix().'module_fb_formbrowser WHERE fbr_id=?', array($params['response_id']));

	if ($res && $row=$res->FetchRow())
		{
		$oneset->xml = $row['response'];
		$form_id = $row['form_id'];
		}
	// loaded a response -- at this point, we check that the response
	// is for the correct form_id!
	if ($form_id != $this->GetId())
		{
		return false;
		}
	$fbField = $mod->GetFormBrowserField($form_id);
	if ($fbField == false)
		{
		// error handling goes here.
		echo($mod->Lang('error_has_no_fb_field'));
		}
	$mod->HandleResponseFromXML($fbField, $oneset);
	list($fnames, $aliases, $vals) = $mod->ParseResponseXML($oneset->xml, false);
	$types = $mod->ParseResponseXMLType($oneset->xml);
	foreach ($vals as $id=>$val)
		{
		if (isset($params['fbrp__'.$id]) &&
			! is_array($params['fbrp__'.$id]))
			{
			$params['fbrp__'.$id] = array($params['fbrp__'.$id]);
			array_push($params['fbrp__'.$id], $val);
			}
		elseif (isset($params['fbrp__'.$id]))
			{
			array_push($params['fbrp__'.$id], $val);
			}
		else
			{
			$params['fbrp__'.$id] = $val;
			}
		}
	return true;
  }

  // FormBrowser < 0.3 Response load method  
  function LoadResponseValuesOld(&$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;
      }
  }   

  // Validation stuff action.validate.php
  function CheckResponse($form_id, $response_id, $code)
  {
    $db = $this->module_ptr->dbHandle;
    $sql = 'SELECT secret_code FROM ' . cms_db_prefix(). 'module_fb_formbrowser WHERE form_id=? AND fbr_id=?';
    if($result = $db->GetRow($sql, array($form_id,$response_id)))
      {
	if ($result['secret_code'] == $code)
	  {
	    return true;
	  }
      }
    return false;
  }

  // Master response inputter
  function StoreResponse($response_id=-1,$approver='',&$formBuilderDisposition)
  {
	$mod = $this->module_ptr;
    $db = $this->module_ptr->dbHandle;
    $fields = $this->GetFields();
	$newrec = false;
	
	$crypt = false;
	$hash_fields = false;
	$sort_fields = array();
	
	// Check if form has Database fields, do init
	if (is_object($formBuilderDisposition) &&
      ($formBuilderDisposition->GetFieldType()=='DispositionFormBrowser' ||
       $formBuilderDisposition->GetFieldType()=='DispositionDatabase'))
		{
		$crypt = ($formBuilderDisposition->GetOption('crypt','0') == '1');
		$hash_fields = ($formBuilderDisposition->GetOption('hash_sort','0') == '1');
		for ($i=0;$i<5;$i++)
			{
			$sort_fields[$i] = $formBuilderDisposition->getSortFieldVal($i+1);
			}
		}

	// If new field
	if ($response_id == -1)
		{
		if (is_object($formBuilderDisposition) && $formBuilderDisposition->GetOption('feu_bind','0') == '1')
			{
			$feu = $mod->GetModuleInstance('FrontEndUsers');
			if ($feu == false)
				{
				debug_display("FAILED to instatiate FEU!");
				return;
				}
			$feu_id = $feu->LoggedInId();
			}
		else
			{
			$feu_id = -1;
			}			
		$response_id = $db->GenID(cms_db_prefix(). 'module_fb_formbrowser_seq');	
	    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);
				}
			}
		$newrec = true;
		}
	else
		{
		$feu_id = $mod->getFEUIDFromResponseID($response_id);
		}
		
	// Convert form to XML
	$xml = $this->ResponseToXML();
	
	// Do the actual adding
	if (! $crypt)
		{
		$output = $this->StoreResponseXML(
			$response_id,
			$newrec,
			$approver,
			isset($sort_fields[0])?$sort_fields[0]:'',
			isset($sort_fields[1])?$sort_fields[1]:'',
			isset($sort_fields[2])?$sort_fields[2]:'',
			isset($sort_fields[3])?$sort_fields[3]:'',
			isset($sort_fields[4])?$sort_fields[4]:'',
			$feu_id,
			$xml);
		}
	elseif (! $hash_fields)
		{
		list($res, $xml) = $mod->crypt($xml,$formBuilderDisposition);
		if (! $res)
			{
			return array(false, $xml);
			}
		$output = $this->StoreResponseXML(
			$response_id,
			$newrec,
			$approver,
			isset($sort_fields[0])?$sort_fields[0]:'',
			isset($sort_fields[1])?$sort_fields[1]:'',
			isset($sort_fields[2])?$sort_fields[2]:'',
			isset($sort_fields[3])?$sort_fields[3]:'',
			isset($sort_fields[4])?$sort_fields[4]:'',
			$feu_id,
			$xml);
		}
	else
		{
		list($res, $xml) = $mod->crypt($xml,$formBuilderDisposition);
		if (! $res)
			{
			return array(false, $xml);
			}
		$output = $this->StoreResponseXML(
			$response_id,
			$newrec,
			$approver,
			isset($sort_fields[0])?$mod->getHashedSortFieldVal($sort_fields[0]):'',
			isset($sort_fields[1])?$mod->getHashedSortFieldVal($sort_fields[1]):'',
			isset($sort_fields[2])?$mod->getHashedSortFieldVal($sort_fields[2]):'',
			isset($sort_fields[3])?$mod->getHashedSortFieldVal($sort_fields[3]):'',
			isset($sort_fields[4])?$mod->getHashedSortFieldVal($sort_fields[4]):'',
			$feu_id,
			$xml);
		}
	//return array(true,''); Stikki replaced: instead of true, return actual data, didn't saw any side effects.
	return $output;
  }

  // Converts form to XML
  function &ResponseToXML()
  {
  	$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";
   return $xml;
  }

  // Inserts parsed XML data to database
  function StoreResponseXML($response_id=-1,$newrec=false,$approver='',$sortfield1,
   $sortfield2,$sortfield3,$sortfield4,$sortfield5, $feu_id,$xml)
  {
    $db = $this->module_ptr->dbHandle;
    $secret_code = '';

    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, feuid, response) VALUES (?,?,?,?,?,?,?,?,?,?,?)';
		$res = $db->Execute($sql,
			array($response_id,
				$this->GetId(),
				$this->clean_datetime($db->DBTimeStamp(time())),
				$secret_code,
				$sortfield1,$sortfield2,$sortfield3,$sortfield4,$sortfield5,
				$feu_id,
				$xml
			));
      }
    else if ($approver != '')
      {
		$sql = 'UPDATE ' . cms_db_prefix().
			'module_fb_formbrowser 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);
  }   

	// Some stupid date function
	function clean_datetime($dt)
	{
    return substr($dt,1,strlen($dt)-2);
	}
  
  // When downloading form.
  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 GetFormBrowsersForForm()
	{
		$db = $this->module_ptr->dbHandle;
		$fbr = $this->module_ptr->GetModuleInstance('FormBrowser');
		$browsers = array();
		if ($fbr != FALSE)
			{
			$res = $db->Execute('SELECT browser_id from '. cms_db_prefix(). 'module_fbr_browser where form_id=?',
				array($this->GetId()));
			while ($res && $row=$res->FetchRow())
				{
				array_push($browsers, $row['browser_id']);
				}
	      	}
		return $browsers;
	}

  function AddToSearchIndex($response_id)
	{	
	// find browsers keyed to this
	$browsers = $this->GetFormBrowsersForForm();
	if (count($browsers) < 1)
		{
		return;
		}
	
	$module =& $this->module_ptr->GetModuleInstance('Search');
    if ($module != FALSE)
      {
		$submitstring = '';
		foreach ($this->Fields as $thisField)
			{
			if ($thisField->DisplayInSubmission())
				{
				$submitstring .= ' '.$thisField->GetHumanReadableValue($as_string=true);
				}
			}
		foreach ($browsers as $thisBrowser)
			{
			$module->AddWords( 'FormBrowser', $response_id, 'sub_'.$thisBrowser, $submitstring, null);	
			}
      }
	}

  function setFinishedFormSmarty($htmlemail=false)
	{
		$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(); // what is this doing here? (Jo Morg)
			if ($theFields[$i]->DisplayInSubmission())
		  		{
		    		$replVal = $theFields[$i]->GetHumanReadableValue();
            
            // this should no longer be necessary but let it stay just in case (JoMorg)        
            if( is_array($replVal) )
            {
              $replVal = $replVal[0]; 
            }

		    		if ($htmlemail)
		        		{
						// allow <BR> as delimiter or in content
						$replVal = preg_replace('/<br(\s)*(\/)*>/i','|BR|',$replVal);
						$replVal = preg_replace('/[\n\r]+/','|BR|',$replVal);
	            		$replVal = htmlspecialchars($replVal);
						$replVal = preg_replace('/\|BR\|/','<br />',$replVal);
	            		}
		    		if ($replVal == '')
		      			{
						$replVal = $unspec;
		      			}
		  		}
		
		 	$mod->smarty->assign($theFields[$i]->GetVariableName(),$replVal);
		 	$mod->smarty->assign('fld_'.$theFields[$i]->GetId(),$replVal);
			$fldobj = $theFields[$i]->ExportObject();
		 	$mod->smarty->assign($theFields[$i]->GetVariableName().'_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()
	{
		$gCms = cmsms();
		$theFields = $this->GetFields();
		$mod = $this->module_ptr;
    
		// build rename map
		$mapId = array();
		$eval_string = false;
		for($j=0;$j<count($theFields);$j++)
			{
	    $mapId[$theFields[$j]->GetId()] = $j;
      }

	    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 = $mod->module_id.'fbrp__'.$theFields[$i]->Id;
	      		if( isset( $_FILES[$_id] ) && $_FILES[$_id]['size'] > 0 )
	        		{
	    			$thisFile =& $_FILES[$_id];
						$thisExt = substr($thisFile['name'],strrpos($thisFile['name'],'.'));
	
						if ($theFields[$i]->GetOption('file_rename','') == '')
							{
							$destination_name = $thisFile['name'];
							}
						else
							{
				    	$flds = array();
				    	$destination_name = $theFields[$i]->GetOption('file_rename');
				    	preg_match_all('/\$fld_(\d+)/', $destination_name, $flds);
							foreach ($flds[1] as $tF)
	                {
	                if (isset($mapId[$tF]))
	                    {
	                    $ref = $mapId[$tF];
	                    $destination_name = str_replace('$fld_'.$tF,
	                         $theFields[$ref]->GetHumanReadableValue(),$destination_name);
	                    }
	                }
							$destination_name = str_replace('$ext',$thisExt,$destination_name);
							}
	
	    			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;
							  $parms['input_destname'] = $destination_name;
								if ($theFields[$i]->GetOption('allow_overwrite','0') == '1')
									{
									$parms['input_replace'] = 1;	
									}
	        			$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 ($parms['category_id'], 'getfile', $uploads_destpage, '',
							array ('upload_id' => $res[1]), '', true);

						$url = str_replace('admin/moduleinterface.php?','index.php?',$url);
	
						$theFields[$i]->ResetValue();
	        			$theFields[$i]->SetValue($url);
	      				}
	    			else
	      				{
	        			// Handle the upload ourselves
						$src = $thisFile['tmp_name'];						
						$dest_path = $theFields[$i]->GetOption('file_destination',$gCms->config['uploads_path']);						
						
						// validated message before, now do it for the file itself
						$valid = true;
					    $ms = $theFields[$i]->GetOption('max_size');
					    $exts = $theFields[$i]->GetOption('permitted_extensions','');
					    if ($ms != '' && $thisFile['size'] > ($ms * 1024))
							{
							$valid = false;
							}
					    else if ($exts != '')
							{
							$match = false;
							$legalExts = explode(',',$exts);
							foreach ($legalExts as $thisExt)
								{
								if (preg_match('/\.'.trim($thisExt).'$/i',$thisFile['name']))
									{
									$match = true;
									}
								else if (preg_match('/'.trim($thisExt).'/i',$thisFile['type']))
									{
									$match = true;
									}
								}
							if (! $match)
								{
								$valid = false;
								}
							}
						if (! $valid)
							{
							unlink($src);
							audit(-1, $mod->GetName(), $mod->Lang('illegal_file',array($thisFile['name'],$_SERVER['REMOTE_ADDR'])));
		      				return array(false, '');
							}
						$dest = $dest_path.DIRECTORY_SEPARATOR.$destination_name;
						if (file_exists($dest) && $theFields[$i]->GetOption('allow_overwrite','0')=='0')
							{
							unlink($src);
							return array(false,$mod->Lang('file_already_exists', array($destination_name)));
							}
						if (! move_uploaded_file($src,$dest))
							{
							audit(-1, $mod->GetName(), $mod->Lang('submit_error',''));
		      				return array(false, $mod->Lang('uploads_error',''));
							}
						else
							{
							if (strpos($dest_path,$gCms->config['root_path']) !== FALSE)
							{
                #render a properlly formed relative path (JoMorg)
								$url = str_replace($gCms->config['root_path'] . DIRECTORY_SEPARATOR, '/', $dest_path) . '/' . $destination_name;
                
							}
							else
							{
								$url = $mod->Lang('uploaded_outside_webroot', $destination_name);
							}
              
              $tmp =  explode('/', $destination_name);
              $filename =  array_pop($tmp);
               
							$theFields[$i]->ResetValue();
							$theFields[$i]->SetValue(array($filename,$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[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]]></data>
	</file>
	<file>
	  <filename>/classes/FromEmailNameField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/FromEmailSubjectField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/HiddenField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/classes/LinkField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/ModuleInterfaceField.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[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]]></data>
	</file>
	<file>
	  <filename>/classes/PageBreakField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/PasswordAgainField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/PasswordField.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[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]]></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/SiteAdminField.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[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]]></data>
	</file>
	<file>
	  <filename>/classes/TextField.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 fbTextField extends fbFieldBase {

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

	}

	function GetFieldInput($id, &$params, $returnid)
	{
		$mod = $this->form_ptr->module_ptr;
		$js = $this->GetOption('javascript','');
		$ro = '';
		$html5 = '';
		
		if ($this->GetOption('readonly','0') == '1')
		{
			$ro = ' readonly';
		}
		if ($this->GetOption('html5','0') == '1')
		{
                        $val = $this->Value;
                        $html5 = ' placeholder="'.$this->GetOption('default').'"';
		        if ($this->IsRequired()) {
		                $html5 .= ' required';
		        }
                }
                else
                {
                        $val = $this->Value ? $this->Value : $this->GetOption('default');
                        if($this->GetOption('clear_default','0') == 1)
                        {
                                $js .= ' onfocus="if(this.value==this.defaultValue) this.value=\'\';" onblur="if(this.value==\'\') this.value=this.defaultValue;"';
                        }
                }
		return $mod->fbCreateInputText($id, 'fbrp__'.$this->Id,
			htmlspecialchars($val, ENT_QUOTES), $this->GetOption('length')<25?$this->GetOption('length'):25,
			$this->GetOption('length'), $js.$html5.$ro.$this->GetCSSIdTag());
	}

	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);
		}
		
		if ($this->GetOption('readonly','0') == '1') {
        
			$ret .= ", ".$mod->Lang('title_read_only');
        }
		 
		return $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_read_only'),$mod->CreateInputHidden($formDescriptor, 'fbrp_opt_readonly','0').
						$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_readonly','1',$this->GetOption('readonly','0')))
		);

		$adv = array(
			array($mod->Lang('title_field_regex'),$mod->CreateInputText($formDescriptor, 'fbrp_opt_regex',$this->GetOption('regex'),25,1024).'<br />'.$mod->Lang('title_regex_help')),
			array($mod->Lang('title_field_default_value'),$mod->CreateInputText($formDescriptor, 'fbrp_opt_default',$this->GetOption('default'),25,1024)),
			array($mod->Lang('title_clear_default'),$mod->CreateInputHidden($formDescriptor,'fbrp_opt_clear_default','0').
						$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_clear_default','1',$this->GetOption('clear_default','0')).'<br />'.$mod->Lang('title_clear_default_help'))	
		);
		
		return array('main'=>$main,'adv'=>$adv);
	}


	function Validate()
	{
		$this->validated = true;
		$this->validationErrorText = '';
		$mod = $this->form_ptr->module_ptr;
		switch ($this->ValidationType)
		  {
		  	   case 'none':
		  	       break;
		  	   case 'numeric':
				  if ($this->Value !== false) $this->Value = trim($this->Value);
                  if ($this->Value !== false &&
                      ! preg_match("/^([\d\.\,])+$/i", $this->Value))
                      {
                      $this->validated = false;
                      $this->validationErrorText = $mod->Lang('please_enter_a_number',$this->Name);
                      }
		  	       break;
		  	   case 'integer':
				  if ($this->Value !== false) $this->Value = trim($this->Value);
                  if ($this->Value !== false &&
                  	! preg_match("/^([\d])+$/i", $this->Value) ||
                      intval($this->Value) != $this->Value)
                    {
                    $this->validated = false;
                    $this->validationErrorText = $mod->Lang('please_enter_an_integer',$this->Name);
                    }
		  	       break;
		  	   case 'email':
				   				if ($this->Value !== false) $this->Value = trim($this->Value);
                  if (
                  			$this->Value !== false 
//                  			&& ! preg_match(($mod->GetPreference('relaxed_email_regex','0')==0?$mod->email_regex:$mod->email_regex_relaxed), $this->Value)
												&& !email_validator::is_email($this->Value)
                      )
                    {
                    $this->validated = false;
                    $this->validationErrorText = $mod->Lang('please_enter_an_email',$this->Name);
                    }
		  	       break;
		  	   case 'usphone':
				  if ($this->Value !== false) $this->Value = trim($this->Value);
                  if ($this->Value !== false &&
                      ! preg_match('/^([0-9][\s\.-]?)?(\(?[0-9]{3}\)?|[0-9]{3})[\s\.-]?([0-9]{3}[\s\.-]?[0-9]{4}|[a-zA-Z0-9]{7})(\s?(x|ext|ext.)\s?[a-zA-Z0-9]+)?$/',
                       $this->Value))
                    {
                    $this->validated = false;
                    $this->validationErrorText = $mod->Lang('please_enter_a_phone',$this->Name);
                    }
		  	       break;
		  	   case 'regex_match':
                  if ($this->Value !== false &&
                      ! preg_match($this->GetOption('regex','/.*/'), $this->Value))
                    {
                    $this->validated = false;
                    $this->validationErrorText = $mod->Lang('please_enter_valid',$this->Name);
                    }
		  	   	   break;
		  	   case 'regex_nomatch':
                  if ($this->Value !== false &&
                       preg_match($this->GetOption('regex','/.*/'), $this->Value))
                    {
                    $this->validated = false;
                    $this->validationErrorText = $mod->Lang('please_enter_valid',$this->Name);
                    }
		  	   	   break;
		  }
		  
		if ($this->GetOption('length',0) > 0 && strlen($this->Value) > $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/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->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;
		$js = $this->GetOption('javascript','');
		$sibling_id = $this->GetOption('siblings','');
		$hidebuttons = $this->GetOption('hidebuttons','');

		if (! is_array($this->Value)) 
		{

			$vals = 1;
			$this->Value = array($this->Value);
		} 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 || $pts[2] == $sibling_id)
				{					
					// add row
					$this->Value[$vals]='';
					$vals++;
				}
			}
			else if (substr($pKey,0,9) == 'fbrp_FeD_')
			{	
				$pts = explode('_',$pKey);
				if ($pts[2] == $this->Id || $pts[2] == $sibling_id)
				{				
					// delete row
					if (isset($this->Value[$pts[3]]))
					{
					
						array_splice($this->Value, $pts[3], 1);
					}
					$vals--;
				}
			}
		}

		// Input fields
		$ret = array();
		for ($i=0;$i<$vals;$i++)
		{
		
			$thisRow = new stdClass();

			$thisRow->input = $mod->fbCreateInputText($id, 'fbrp__'.$this->Id.'[]',$this->Value[$i],$this->GetOption('length')<25?$this->GetOption('length'):25,
							$this->GetOption('length'),$js.$this->GetCSSIdTag('_'.$i));
			
			if(!$hidebuttons)
			{
				$thisRow->op = $mod->fbCreateInputSubmit($id, 'fbrp_FeD_'.$this->Id.'_'.$i, $this->GetOption('del_button','X'), $this->GetCSSIdTag('_del_'.$i).($vals==1?' disabled="disabled"':''));
			}

			array_push($ret, $thisRow);
		}
		
		// Add button
		$thisRow = new stdClass();
		
		if(!$hidebuttons)
		{
			$thisRow->op = $mod->fbCreateInputSubmit($id, 'fbrp_FeX_'.$this->Id.'_'.$i, $this->GetOption('add_button','+'), $this->GetCSSIdTag('_add_'.$i));
		}
		
		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'),$mod->CreateInputText($formDescriptor, 'fbrp_opt_regex',$this->GetOption('regex'),25,255).'<br />'.$mod->Lang('title_regex_help')),
			array($mod->Lang('title_field_siblings'),$mod->CreateInputDropdown($formDescriptor, 'fbrp_opt_siblings',$this->GetFieldSiblings(),-1,$this->GetOption('siblings','')).'<br />'.$mod->Lang('title_field_siblings_help')),
			array($mod->Lang('title_field_hidebuttons'),$mod->CreateInputHidden($formDescriptor,'fbrp_opt_hidebuttons',0).
						$mod->CreateInputCheckbox($formDescriptor, 'fbrp_opt_hidebuttons',1,$this->GetOption('hidebuttons',0)).$mod->Lang('title_field_hidebuttons_help'))				
		);
		
		return array('main'=>$main,'adv'=>$adv);
	}

	function LabelSubComponents()
	{
		return false;
	}	

	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)
			                  && !email_validator::is_email($this->Value)
		                  )
                    {
                    $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);
	}
	
	// Gets all mirror fields of this field
	function GetFieldSiblings() 
	{
		$mod = $this->form_ptr->module_ptr;
		$form = $this->form_ptr;
		$siblings = array();
		
		$siblings[$mod->Lang('select_one')] = '';
	
		for ($i=0; $i < count($form->Fields); $i++) {
	
			$thisField = &$form->Fields[$i];
	
			if ($thisField->GetFieldType() == 'TextFieldExpandable' && $thisField->GetId() != $this->GetId()) {
		
				$siblings[$thisField->GetName()] = $thisField->GetId();
				
			}
		}
		
		return $siblings;
	
	}
	
}

?>
]]></data>
	</file>
	<file>
	  <filename>/classes/TimePickerField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/UniqueIntegerField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHAKLyogCiAgIEZvcm1CdWlsZGVyLiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOCBTYW11ZWwgR29sZHN0ZWluIDxzamdAY21zbW9kdWxlcy5jb20+CiAgIE1vcmUgaW5mbyBhdCBodHRwOi8vZGV2LmNtc21hZGVzaW1wbGUub3JnL3Byb2plY3RzL2Zvcm1idWlsZGVyCiAgIAogICBBIE1vZHVsZSBmb3IgQ01TIE1hZGUgU2ltcGxlLCBDb3B5cmlnaHQgKGMpIDIwMDggYnkgVGVkIEt1bHAgKHdpc2h5QGNtc21hZGVzaW1wbGUub3JnKQogIFRoaXMgcHJvamVjdCdzIGhvbWVwYWdlIGlzOiBodHRwOi8vd3d3LmNtc21hZGVzaW1wbGUub3JnCiovCgpjbGFzcyBmYlVuaXF1ZUludGVnZXJGaWVsZCBleHRlbmRzIGZiRmllbGRCYXNlIAp7CgoJZnVuY3Rpb24gZmJVbmlxdWVJbnRlZ2VyRmllbGQoJiRmb3JtX3B0ciwgJiRwYXJhbXMpCgl7CgkJJHRoaXMtPmZiRmllbGRCYXNlKCRmb3JtX3B0ciwgJHBhcmFtcyk7CgkJJG1vZCA9ICRmb3JtX3B0ci0+bW9kdWxlX3B0cjsKCQkkdGhpcy0+VHlwZSA9ICdVbmlxdWVJbnRlZ2VyRmllbGQnOwoJCSR0aGlzLT5EaXNwbGF5SW5Gb3JtID0gdHJ1ZTsKCQkkdGhpcy0+Tm9uUmVxdWlyYWJsZUZpZWxkID0gdHJ1ZTsKCQkkdGhpcy0+VmFsaWRhdGlvblR5cGVzID0gYXJyYXkoKTsKCQkkdGhpcy0+c29ydGFibGUgPSBmYWxzZTsKCX0KCgoJZnVuY3Rpb24gR2V0RmllbGRJbnB1dCgkaWQsICYkcGFyYW1zLCAkcmV0dXJuaWQpCgl7CgkJJG1vZCA9ICR0aGlzLT5mb3JtX3B0ci0+bW9kdWxlX3B0cjsKCQlpZiAoJHRoaXMtPlZhbHVlICE9PSBmYWxzZSkgewoKCQkJJHJldCA9ICRtb2QtPkNyZWF0ZUlucHV0SGlkZGVuKCRpZCwgJ2ZicnBfXycuJHRoaXMtPklkLCAkdGhpcy0+VmFsdWUpOwoJCQlpZiAoJHRoaXMtPkdldE9wdGlvbignc2hvd190b191c2VyJywnMCcpID09ICcxJykgewoKCQkJCSRyZXQgLj0gJHRoaXMtPlZhbHVlOwoJCQl9CgkJCgkJfSBlbHNlIGlmICgkdGhpcy0+R2V0T3B0aW9uKCd1c2VfcmFuZG9tX2dlbmVyYXRvcicsJzAnKSA9PSAnMScpIHsKCgkJCSR0aW1lcyA9ICR0aGlzLT5HZXRPcHRpb24oJ251bWJlcnNfdG9fZ2VuZXJhdGUnLCc1JykgPyAkdGhpcy0+R2V0T3B0aW9uKCdudW1iZXJzX3RvX2dlbmVyYXRlJywnNScpIDogNTsKCQkJJG51bWJlciA9ICR0aGlzLT5nZW5lcmF0ZV9udW1iZXJzKDAsOSwkdGltZXMpOwoJCQkkcmV0ID0gJG1vZC0+Q3JlYXRlSW5wdXRIaWRkZW4oJGlkLCAnZmJycF9fJy4kdGhpcy0+SWQsJG51bWJlcik7CgkJCWlmICgkdGhpcy0+R2V0T3B0aW9uKCdzaG93X3RvX3VzZXInLCcwJykgPT0gJzEnKSB7CQkJCgkJCQkKCQkJCSRyZXQgLj0gJG51bWJlcjsJCQoJCQl9CgkJCgkJfSBlbHNlIHsKCgkJCSRkYiA9ICRtb2QtPmRiSGFuZGxlOwoJCQkkc2VxID0gJGRiLT5HZW5JRChjbXNfZGJfcHJlZml4KCkuICdtb2R1bGVfZmJfdW5pcXVlZmllbGRfc2VxJyk7CgkJCSRyZXQgPSAkbW9kLT5DcmVhdGVJbnB1dEhpZGRlbigkaWQsICdmYnJwX18nLiR0aGlzLT5JZCwkc2VxKTsKCQkJaWYgKCR0aGlzLT5HZXRPcHRpb24oJ3Nob3dfdG9fdXNlcicsJzAnKSA9PSAnMScpIHsKCQkJCgkJCQkkcmV0IC49ICRzZXE7CgkJCX0KCQl9CgoJCXJldHVybiAkcmV0OwoJfQoKCWZ1bmN0aW9uIFByZVBvcHVsYXRlQWRtaW5Gb3JtKCRmb3JtRGVzY3JpcHRvcikKCXsKCQkkbW9kID0gJHRoaXMtPmZvcm1fcHRyLT5tb2R1bGVfcHRyOwoKCQkkbWFpbiA9IGFycmF5KAoJCQlhcnJheSgkbW9kLT5MYW5nKCd0aXRsZV9zaG93X3RvX3VzZXInKSwgJG1vZC0+Q3JlYXRlSW5wdXRIaWRkZW4oJGZvcm1EZXNjcmlwdG9yLCdmYnJwX29wdF9zaG93X3RvX3VzZXInLCcwJykuCgkJCQkJCSRtb2QtPkNyZWF0ZUlucHV0Q2hlY2tib3goJGZvcm1EZXNjcmlwdG9yLCAnZmJycF9vcHRfc2hvd190b191c2VyJywgJzEnLCR0aGlzLT5HZXRPcHRpb24oJ3Nob3dfdG9fdXNlcicsJzAnKSkpLAkJCQkKCQkJYXJyYXkoJG1vZC0+TGFuZygndGl0bGVfdXNlX3JhbmRvbV9nZW5lcmF0b3InKSwgJG1vZC0+Q3JlYXRlSW5wdXRIaWRkZW4oJGZvcm1EZXNjcmlwdG9yLCdmYnJwX29wdF91c2VfcmFuZG9tX2dlbmVyYXRvcicsJzAnKS4KCQkJCQkJJG1vZC0+Q3JlYXRlSW5wdXRDaGVja2JveCgkZm9ybURlc2NyaXB0b3IsICdmYnJwX29wdF91c2VfcmFuZG9tX2dlbmVyYXRvcicsICcxJywkdGhpcy0+R2V0T3B0aW9uKCd1c2VfcmFuZG9tX2dlbmVyYXRvcicsJzAnKSkpLAkKCQkJYXJyYXkoJG1vZC0+TGFuZygndGl0bGVfbnVtYmVyc190b19nZW5lcmF0ZScpLCRtb2QtPkNyZWF0ZUlucHV0VGV4dCgkZm9ybURlc2NyaXB0b3IsJ2ZicnBfb3B0X251bWJlcnNfdG9fZ2VuZXJhdGUnLCR0aGlzLT5HZXRPcHRpb24oJ251bWJlcnNfdG9fZ2VuZXJhdGUnLCc1JyksMjUsMjUpKQkJCQkJCQoJCSk7CgkJCQkKCQkkYWR2ID0gYXJyYXkoKTsKCQkKCQlyZXR1cm4gYXJyYXkoJ21haW4nPT4kbWFpbiwnYWR2Jz0+JGFkdik7Cgl9CgkKCXByaXZhdGUgZnVuY3Rpb24gZ2VuZXJhdGVfbnVtYmVycygkbWluLCAkbWF4LCAkdGltZXMpCgl7CgkJJG91dHB1dCA9ICcnOwoJCSRhcnJheSA9IHJhbmdlKCRtaW4sICRtYXgpOwoJCXNyYW5kICgoZG91YmxlKW1pY3JvdGltZSgpKjEwMDAwKTsKCQlmb3IoJHggPSAwOyAkeCA8ICR0aW1lczsgJHgrKykgewoJCQoJCQkkaSA9IHJhbmQoMSwgY291bnQoJGFycmF5KSktMTsKCQkJJG91dHB1dCAuPSAkYXJyYXlbJGldOwoJCX0KCQkKCQlyZXR1cm4gJG91dHB1dDsKCX0JCgp9Cgo/Pgo=]]></data>
	</file>
	<file>
	  <filename>/classes/UserTagField.class.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/classes/YearPullDownField.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
# Author: Samuel Goldstein, Morten Poulsen
#-------------------------------------------------------------------------
# CMS Made Simple is (c) 2004 - 2011 by Ted Kulp (wishy@cmsmadesimple.org)
# CMS Made Simple is (c) 2011 - 2014 by The CMSMS Dev Team
# This project's homepage is: http://www.cmsmadesimple.org
# The module's homepage is: http://dev.cmsmadesimple.org/projects/formbuilder
#-------------------------------------------------------------------------
# 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;
	#### JoMorg
	# deprecated since 0.8.1
	var $email_regex;
	# deprecated since 0.8.1
	var $email_regex_relaxed;
	#### JoMorg end
	
	var $dbHandle;

	function __construct()
	{
		parent::__construct();

		$this->module_ptr = &$this;
		$this->dbHandle =  $this->GetDb();
		$this->module_id = '';
		#### JoMorg
		# deprecated since 0.8.1
		$this->email_regex = "/^([\w\d\.\-\_])+\@([\w\d\.\-\_]+)\.(\w+)$/i";
		$this->email_regex_relaxed="/^([\w\d\.\-\_])+\@([\w\d\.\-\_])+$/i";
		#### JoMorg end
		
		require_once dirname(__FILE__).'/classes/Form.class.php';
		require_once dirname(__FILE__).'/classes/FieldBase.class.php';		
	}
	
	function initialize()
	{
		$dir=opendir(dirname(__FILE__).'/classes');
		$this->field_types = array();
		while($filespec=readdir($dir))
		{
			if( !endswith($filespec,'.php') ) continue;
			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);
	}

	function AllowAutoInstall() { return FALSE; }
	function AllowAutoUpgrade() { return FALSE; }
	function GetName() { return 'FormBuilder'; }
	function GetFriendlyName() { return $this->Lang('friendlyname'); }
	function GetVersion() { return '0.8.1'; }
	function GetAuthor() { return 'Morten Poulsen'; }
	function GetAuthorEmail() { return 'morten@poulsen.org'; }
	function GetAdminDescription($lang = 'en_US') { return $this->Lang('admindesc'); }
	function GetChangeLog() { return file_get_contents(dirname(__FILE__).'/changelog.inc'); }
	function IsPluginModule() { return true; }
	function HasAdmin() { return true; }
	function VisibleToAdminUser() { return $this->CheckPermission('Modify Forms'); }
	function LazyLoadAdmin() { return false; }
	function AdminStyle()
	{
		$output = '';
		
		$fn = dirname(__FILE__).'/includes/admin.css';
		$output .= @file_get_contents($fn);
		
		return $output;
	}

	function GetHeaderHTML()
	{
		$config = cmsms()->GetConfig();
		$tmpl = '';

		if( version_compare($GLOBALS['CMS_VERSION'],'1.9') < 0 )
		{
		    $tmpl .= '<script type="text/javascript" src="'.$config['root_url'].'/modules/'.$this->GetName().'/includes/jquery-1.4.2.min.js"></script>';
		}
		$tmpl .= '<script type="text/javascript" src="'.$config['root_url'].'/modules/'.$this->GetName().'/includes/jquery.tablednd.js"></script>';		
		$tmpl .= '<script type="text/javascript" src="'.$config['root_url'].'/modules/'.$this->GetName().'/includes/fb_jquery_functions.js"></script>';
		$tmpl .= '<script type="text/javascript" src="'.$config['root_url'].'/modules/'.$this->GetName().'/includes/fb_jquery.js"></script>';
		
        return $this->ProcessTemplateFromData($tmpl);
	}
	
	function SetParameters()
	{
		$this->RegisterModulePlugin();
		$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='')
	{
		$smarty = cmsms()->GetSmarty();
		
		$this->module_id = $id;
		parent::DoAction($name,$id,$params,$returnid);
	}

	function GetDependencies() { return array('CMSMailer'=>'1.73'); }
	function MinimumCMSVersion() { return '1.11'; }
	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')
	{
		$db = $this->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)
	{
		$db = $this->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'];
		}
		return -1;
	}

	function GetFormNameFromID($form_id)
	{
		$db = $this->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);
		return new fbForm($this, $params, $loadDeep);
	}

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

	function GetHelp() 
	{
		$smarty = cmsms()->GetSmarty();
		$smarty->assign('mod', $this);
		
		return $this->ProcessTemplate('help_text.tpl'); 
	}
	
	function GetResponse($form_id,$response_id,$field_list=array(), $dateFmt='d F y')
	{
		$names = array();
		$values = array();
		$db = $this->GetDb();
		$fbField = $this->GetFormBrowserField($form_id);
		if ($fbField == false)
		{
			// error handling goes here.
			echo($this->Lang('error_has_no_fb_field'));
		}

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

		$oneset = new stdClass();
		if ($dbresult && $row = $dbresult->FetchRow())
		{
			$oneset->id = $row['fbr_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->user_approved_date = (empty($row['user_approved'])?'':$db->UnixTimeStamp($row['user_approved'])); 
			$oneset->admin_approved_date = (empty($row['admin_approved'])?'':$db->UnixTimeStamp($row['admin_approved']));
			$oneset->submitted_date = $db->UnixTimeStamp($row['submitted']);
			$oneset->xml = $row['response'];
			$oneset->fields = array();
			$oneset->names = array();
			$oneset->fieldsbyalias = array();
		}

		$populate_names = true;
		$this->HandleResponseFromXML($fbField, $oneset);
		list($fnames, $aliases, $vals) = $this->ParseResponseXML($oneset->xml);

		foreach ($fnames as $id=>$name)
			{
			if (isset($field_list[$id]) && $field_list[$id] > -1)
				{
				$oneset->values[$field_list[$id]]=$vals[$id];
				$oneset->names[$field_list[$id]]=$fnames[$id];
				}
			if (isset($aliases[$id]))
				{
				$oneset->fieldsbyalias[$aliases[$id]] = $vals[$id];
				}
			}
		return $oneset;
	}

	function ParseResponseXML($xmlstr, $human_readable_values = true)
	{
		$names = array();
		$aliases = array();
		$vals = array();
		$xml = new SimpleXMLElement($xmlstr);
		foreach ($xml->field as $xmlfield)
			{
			if ($human_readable_values)
				{
				if (isset($xmlfield['display_in_submission']) && $xmlfield['display_in_submission'] == '1')
					{
					$id = (int)$xmlfield['id'];
					$names[$id] = ((string)$xmlfield->field_name);
					$vals[$id] = ((string)$xmlfield->human_readable_value);
					if (isset($xmlfield->options))
						{
						foreach ($xmlfield->options->option as $to)
							{
							if ($to['name'] == 'field_alias')
								{
								$aliases[$id]=((string)$to);
								}
							}
						}
					}
				}
			else
				{
				$id = (int)$xmlfield['id'];
				$arrTypes = $xmlfield->xpath('options/value'); 
				if (count($arrTypes) > 1)
					{
					$vals[$id] = array();
					foreach($arrTypes as $tv)
						{
						array_push($vals[$id],(string)$tv);
						}
					}
				else
					{
					$vals[$id] = (string)$xmlfield->options->value;
					}
				}
			}
		return array($names, $aliases, $vals);
	}

	// New function as part of fix for Bug 5702 from Mike Hughesdon.
	function ParseResponseXMLType($xmlstr)
	{
		$types = array();
		$xml = new SimpleXMLElement($xmlstr);
		foreach ($xml->field as $xmlfield)
		{
			$id = (int)$xmlfield['id'];
			$types['fbrp__'.$id] = (string)$xmlfield['type'];
		}
		return $types;
	}

	function GetFormBrowserField($form_id)
	{
		$db = $this->GetDb();
		$sql = 'SELECT * FROM ' . cms_db_prefix().'module_fb_field WHERE form_id=? and type=?';
		$rs = $this->module_ptr->dbHandle->Execute($sql, array($form_id,'DispositionFormBrowser'));
		$result = array();
		if (! $rs || $rs->RecordCount() == 0)
			{
			return false;
			}
		$thisRes = $rs->GetArray();
		$params = array();
		$aeform = new fbForm($this,$params,false);

		$className = $aeform->MakeClassName($thisRes[0]['type'], '');
		// create the field object
		$field = $aeform->NewField($thisRes[0]);
		return $field;		
	}
	
	
	function HandleResponseFromXML(&$fbField, &$responseObj)
	{
		$crypt = $fbField->GetOption('crypt','0');
		if ($crypt == '1')
			{
			$cryptlib = $fbField->GetOption('crypt_lib');
			$keyfile = $fbField->GetOption('keyfile');
			if ($cryptlib == 'openssl')
				{
				$openssl = $this->GetModuleInstance('OpenSSL');
				$pkey = $fbField->GetOption('private_key');
				$openssl->Reset();
				$openssl->load_private_keyfile($pkey,$keyfile);
				}
			else
				{
				if (file_exists($keyfile))
			    	{
			        $keyfile = file_get_contents($keyfile);
			        }
				}
			}

		if ($crypt == '1')
			{
			if ($cryptlib == 'openssl')
				{
				$responseObj->xml = $openssl->decrypt_from_payload($responseObj->xml);
				if ($responseObj->xml == false)
					{
					debug_display($openssl->openssl_errors());
					}
				}
			else
				{
				$responseObj->xml = $this->fbdecrypt($responseObj->xml,$keyfile);
				}
			}
	}

	function GetSortedResponses($form_id, $start_point, $number=100, $admin_approved=false, $user_approved=false, $field_list=array(), $dateFmt='d F y', &$params)
	{
		$db = $this->GetDb();
		$names = array();
		$values = array();
		$sql = 'FROM '.cms_db_prefix().
				'module_fb_formbrowser WHERE form_id=?';
		$sqlparms = array($form_id);
		if ($user_approved)
		{
			$sql .= ' and user_approved is not null';
		}
		if ($admin_approved)
		{
			$sql .= ' and admin_approved is not null';
		}
		if( (! empty($params['fbrp_response_search'])) && (is_array($params['fbrp_response_search'])) )
		{
			$sql .= ' AND resp_id IN ('. implode(',', $params['fbrp_response_search']) .')';
		}
		if (isset($params['filter_field']) && substr($params['filter_field'],0,5) =='index')
			{
			$idxfld = intval(substr($params['filter_field'],5));
			$sql .= ' AND index_key_'.$idxfld.'=?';
			array_push($sqlparms,$params['filter_value']);
			}
		if (! isset($params['fbrp_sort_field']) || $params['fbrp_sort_field']=='submitdate' || empty($params['fbrp_sort_field']))
		{
			if (isset($params['fbrp_sort_dir']) && $params['fbrp_sort_dir'] == 'a')
			{
				$sql .= ' order by submitted asc';
			}
			else
			{
				$sql .= ' order by submitted desc';
			}
		}
		else if (isset($params['fbrp_sort_field']))
			{
			if (isset($params['fbrp_sort_dir']) && $params['fbrp_sort_dir'] == 'd')
				{
					$sql .= ' order by index_key_'.(int)$params['fbrp_sort_field'].' desc';
				}
				else
				{
					$sql .= ' order by index_key_'.(int)$params['fbrp_sort_field'].' asc';
				}
			}

		$dbcount = $db->Execute('SELECT COUNT(*) as num '.$sql,$sqlparms);

		$records = 0;
		if ($dbcount && $row = $dbcount->FetchRow())
		{
			$records = $row['num'];
		}

		if ($number > -1)
			{
			$dbresult = $db->SelectLimit('SELECT * '.$sql, $number, $start_point, $sqlparms);
			}
		else
			{
			$dbresult = $db->Execute('SELECT * '.$sql, $sqlparms);
			}
			
		while ($dbresult && $row = $dbresult->FetchRow())
		{
			$oneset = new stdClass();
			$oneset->id = $row['fbr_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->user_approved_date = (empty($row['user_approved'])?'':$db->UnixTimeStamp($row['user_approved'])); 
			$oneset->admin_approved_date = (empty($row['admin_approved'])?'':$db->UnixTimeStamp($row['admin_approved'])); 
			$oneset->submitted_date = $db->UnixTimeStamp($row['submitted']);

			$oneset->xml = $row['response'];
			$oneset->fields = array();
			$oneset->fieldsbyalias = array();
			array_push($values,$oneset);
		}
		$fbField = $this->GetFormBrowserField($form_id);
		if ($fbField == false)
			{
			// error handling goes here.
			echo($this->Lang('error_has_no_fb_field'));
			}
		
		$populate_names = true;
		$mapfields = (count($field_list) > 0);
		for ($i=0;$i<count($values);$i++)
		{
			$this->HandleResponseFromXML($fbField, $values[$i]);
			list($fnames, $aliases, $vals) = $this->ParseResponseXML($values[$i]->xml);
			foreach ($fnames as $id=>$name)
				{
				if ($mapfields)
					{
					if (isset($field_list[$id]) && $field_list[$id] > -1)
						{
						if ($populate_names)
							{
							$names[$field_list[$id]] = $name;
							}
						$values[$i]->fields[$field_list[$id]]=$vals[$id];
						}
					if (isset($aliases[$id]))
						{
						$values[$i]->fieldsbyalias[$aliases[$id]] = $vals[$id];
						}
					}
				else
					{
					if ($populate_names)
						{
						$names[$id] = $name;
						}
					$values[$i]->fields[$id]=$vals[$id];
					if (isset($aliases[$id]))
						{
						$values[$i]->fieldsbyalias[$aliases[$id]] = $vals[$id];
						}
					}
				}
			$populate_names = false;
		}
		return array($records, $names, $values);
	}

	// writes all records into a flat file.
	function WriteSortedResponsesToFile($form_id, $filespec, $striptags=true, $dateFmt='d F y', &$params)
	{
		$db = $this->GetDb();
		$names = array();
		$values = array();
		$sql = 'FROM '.cms_db_prefix().
				'module_fb_formbrowser WHERE form_id=?';

		if (! isset($params['fbrp_sort_field']) || $params['fbrp_sort_field']=='submitdate' || empty($params['fbrp_sort_field']))
		{
			if (isset($params['fbrp_sort_dir']) && $params['fbrp_sort_dir'] == 'd')
			{
				$sql .= ' order by submitted desc';	
			}
			else
			{
				$sql .= ' order by submitted asc';
			}
		}
		else if (isset($params['fbrp_sort_field']))
			{
			if (isset($params['fbrp_sort_dir']) && $params['fbrp_sort_dir'] == 'd')
				{
					$sql .= ' order by index_key_'.(int)$params['fbrp_sort_field'].' desc';	
				}
				else
				{
					$sql .= ' order by index_key_'.(int)$params['fbrp_sort_field'].' asc';
				}
			}

		$fbField = $this->GetFormBrowserField($form_id);
		if ($fbField == false)
			{
			// error handling goes here.
			echo($this->Lang('error_has_no_fb_field'));
			}

		$fh = fopen($filespec, 'w+');
		if ($fh === false)
			{
			return false;
			}

		$dbresult = $db->Execute('SELECT * '.$sql, array($form_id));

		$populate_names = true;
		while ($dbresult && $row = $dbresult->FetchRow())
		{
			$oneset = new stdClass();
			$oneset->id = $row['fbr_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->xml = $row['response'];
			$this->HandleResponseFromXML($fbField, $oneset);
			list($fnames, $aliases, $vals) = $this->ParseResponseXML($oneset->xml);
			if ($populate_names)
				{
				if ($striptags)
		         	{
					foreach ($fnames as $id=>$name)
						{
		            	$fnames[$i] = strip_tags($fnames[$i]);
		            	}
		         	}
				fputs ($fh, $this->Lang('title_submit_date')."\t".
					$this->Lang('title_approval_date')."\t".
					$this->Lang('title_user_approved')."\t".
					implode("\t",$fnames)."\n");
				$populate_names = false;
				}
			fputs ($fh,$oneset->submitted . "\t");
			fputs ($fh,$oneset->admin_approved . "\t");
			fputs ($fh,$oneset->user_approved . "\t");
			foreach ($vals as $tv)
				{
				if ($striptags)
	               {
	               $tv = strip_tags($tv);
	               }
				fputs ($fh,preg_replace('/[\n\t\r]/',' ',$tv));
				fputs ($fh,"\t");
				}
			fputs($fh,"\n");
		}
		fclose($fh);
		return true;
	}

	function GetSortableFields($form_id)
	{
		$ret = array();
		$parm = array('form_id'=>$form_id);
		$aeform = new fbForm($this, $parm, true);
		$fbField = $aeform->GetFormBrowserField();
		if ($fbField == false)
			{
			// error handling goes here.
			return $ret;
			}
		return $fbField->getSortFieldList();
	}

  function GetFEUIDFromResponseID($response_id)
	{
	$db = $this->GetDb();
    $sql = 'SELECT feuid FROM ' . cms_db_prefix().
      'module_fb_formbrowser where fbr_id=?';
    if($result = $db->GetRow($sql, array($response_id)))
      {
	    return $result['feuid'];
      }
    return -1;
	}

  function GetResponseIDFromFEUID($feu_id, $form_id=-1)
	{
	$db = $this->GetDb();

	// Fix for Bug 5422. Adapted from Mike Hughesdon's code.
	$sql = 'SELECT fbr_id FROM ' . cms_db_prefix().
			'module_fb_formbrowser where feuid=?';
	if ($form_id != -1)
	{
		$sql .= ' and form_id = '.$form_id.' ORDER BY submitted DESC';
	}

    if($result = $db->GetRow($sql, array($feu_id)))
      {
	    return $result['fbr_id'];
      }
    return false;
 	}

	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')
	{
		$db = $this->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()
	{
		$db = $this->GetDb();
		$sql = "DELETE from ".cms_db_prefix().'module_fb_flock';
		$rs = $db->Execute($sql);
	}

	function GetFileLock()
	{
		$db = $this->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();
		$defaultid = '';
		if( $markdefault )
		{
			$contentops = cmsms()->GetContentOperations();
			$defaultid = $contentops->GetDefaultPageID();
		}
		
		// get a list of the pages used by this template
		$mypages = array();

		if ($this->GetPreference('mle_version','0') == '1')
			{
			global $mleblock;
			$q = "SELECT content_id,content_name$mleblock as content_name FROM ".
				cms_db_prefix()."content WHERE type = ? AND active = 1";	
			}
		else
			{
			$q = "SELECT content_id,content_name FROM ".cms_db_prefix().
				"content WHERE type = ? AND active = 1";
			}
		$dbresult = $db->Execute( $q, array('content') );
		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 (isset($_SERVER['QUERY_STRING']) && strpos($_SERVER['QUERY_STRING'],'exportxml') !== false)
		{
			return true;
		}
		elseif (isset($_SERVER['QUERY_STRING']) && strpos($_SERVER['QUERY_STRING'],'admin_get_template') !== false)
		{
			return true;
		}
		return false;
	}

   function crypt($string, $dispositionField)
   {
   if ($dispositionField->GetOption('crypt_lib') == 'openssl')
      {
	   $openssl = $this->GetModuleInstance('OpenSSL');
	   if ($openssl === FALSE)
		    {
		    return array(false,$this->Lang('title_install_openssl'));
		    }
	   $openssl->Reset();
	   if (! $openssl->load_certificate($dispositionField->GetOption('crypt_cert')))
		   {
		   return array(false,$openssl->openssl_errors());
		   }
	   $enc = $openssl->encrypt_to_payload($string);
	   }
    else
      {
      $kf = $dispositionField->GetOption('keyfile');
      if (file_exists($kf))
         {
         $key = file_get_contents($kf);
         }
      else
         {
         $key = $kf;
         }
      $enc = $this->fbencrypt($string,$key);
      }
    return array(true,$enc);
   }


  function getHashedSortFieldVal($val)
	{
	if (strlen($val) > 4)
		{
		$val = substr($val,0,4). md5(substr($val,4));
		}
	return $val;
	}
   
	function GetActiveTab(&$params)
		{
		if (FALSE == empty($params['active_tab']))
			{
		    return $params['active_tab'];
		  	}
		else
			{
			return 'maintab';
			}
	}
  
   function fbencrypt($string,$key)
      {
      $key = substr(md5($key),0,24);
      $td = mcrypt_module_open ('tripledes', '', 'ecb', '');
      $iv = mcrypt_create_iv (mcrypt_enc_get_iv_size ($td), MCRYPT_RAND);
      mcrypt_generic_init ($td, $key, $iv);
      $enc = base64_encode(mcrypt_generic ($td, $string));
      mcrypt_generic_deinit ($td);
      mcrypt_module_close ($td);
      return $enc;
      }

   function fbdecrypt($crypt,$key)
      {
      $crypt = base64_decode($crypt);
      $td = mcrypt_module_open ('tripledes', '', 'ecb', '');
      $key = substr(md5($key),0,24);
      $iv = mcrypt_create_iv (mcrypt_enc_get_iv_size ($td), MCRYPT_RAND);
      mcrypt_generic_init ($td, $key, $iv);
      $plain = mdecrypt_generic ($td, $crypt);
      mcrypt_generic_deinit ($td);
      mcrypt_module_close ($td);
      return $plain;
      }

  function fbCreateInputText($id, $name, $value='', $size='10', $maxlength='255', $addttext='', $type='text')
	{
  	$value = cms_htmlentities($value);
  	$id = cms_htmlentities($id);
  	$name = cms_htmlentities($name);
  	$size = cms_htmlentities($size);
  	$maxlength = cms_htmlentities($maxlength);

  	$value = str_replace('"', '&quot;', $value);

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

	function fbCreateInputSubmit($id, $name, $value='', $addttext='', $image='', $confirmtext='')
	{
		$id = cms_htmlentities($id);
		$name = cms_htmlentities($name);
		$image = cms_htmlentities($image);
		$config = cmsms()->GetConfig();
		$text = '<input name="'.$id.$name.'" value="'.$value.'" type=';
		if ($image != '')
		{
			$text .= '"image"';
			$img = $config['root_url'] . '/' . $image;
			$text .= ' src="'.$img.'"';
		}
		else
		{
			$text .= '"submit"';
		}
		if ($confirmtext != '' )
		  {
			$text .= ' onclick="return confirm(\''.$confirmtext.'\');"';
		  }
		if ($addttext != '')
		{
			$text .= ' '.$addttext;
		}
		$text .= ' />';
		return $text . "\n";
	}


  function DeleteFromSearchIndex(&$params)
	{
		$aeform = new fbForm($this, $params, true);
		
		// find browsers keyed to this
		$browsers = $aeform->GetFormBrowsersForForm();
		if (count($browsers) < 1)
			{
			return;
			}

		$module =& $this->module_ptr->GetModuleInstance('Search');
	    if ($module != FALSE)
	      {
			foreach ($browsers as $thisBrowser)
				{
				$module->DeleteWords( 'FormBrowser', $params['response_id'], 'sub_'.$thisBrowser);	
				}
	      }
	}

  function RegisterTinyMCEPlugin() {
    
    $config=$this->GetConfig();
    $plugin = "
	tinymce.create('tinymce.plugins.formpicker', {
        createControl: function(n, cm) {
            switch (n) {
                 case 'formpicker':
                    var c = cm.createMenuButton('formpicker', {
                        title : '" . $this->GetFriendlyName() . "',
                        image : '" . $config["root_url"] . "/modules/FormBuilder/images/info-small.gif',
                        icons : false
                        });

                        c.onRenderMenu.add(function(c, m) {
                ";
    $forms = $this->GetForms();
    
    foreach ($forms as $form) {     
        $plugin .= "
            m.add({
                title : '" . $form['name'] . "',
                onclick : function() {
                  tinyMCE.activeEditor.execCommand('mceInsertContent', false, '&#123;FormBuilder form=\"".$form["alias"]."\"&#125;');
                }
      });
      ";
    }



    $plugin .= "
                });
              // Return the new menu button instance
              return c;
            }

          return null;
       }
});
";
 return array(array('formpicker', $plugin, $this->GetFriendlyName()));
  }


} // End of Class

#
# EOF
#
?>]]></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>/images/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/images/info-large.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[R0lGODlhFAAUAOZoAHm4/367/326/3q4/3W2/3e3/3u5/3O1/////ozB/Hy6/67U/Xi3/+bx/n+6/Hy5/3a3/3a2/+Hv/vT5/oS+/1ak/W6y/qvR/e31/2Cq/mSr/Fil/H66/2Cp/GSs/GWt/nKz/IrA/Guv/JDE//j7/4C6/Pr8/3O1/t7t/lal/Wqv/pHE/Guw/mSs/lel/GSt/t/u/l6p/FWk/Fyn/Ie+/Nnr/vf7/2Gr/ff6/2yx/lWk/Xi4/1im/b7c/ZDD/OXx/qbP/WGq/bnZ/VGi/KPN/Wiu/n65/IG7/KXP/4jA/3K0/+v0/nW1/5zL/3S1/4zC//L4/rva/myx/6vS/tbp/rzb/4G8//r8/vz+/qnR/5/M/9vs/rXX/+71/oa//3S2/9Pn/pLF/+jy/orB/63U/5rJ/3K1/3q5/////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAGgALAAAAAAUABQAAAf/gGiCgxhCKyVGIRcwg42NPSIyNyosLxUdRDaOgjhHOhEBAgpnCgEDQR4ojiYgRQEGAAAEAhAAAwEnGxKNPi0BsbJcS1FMsQIHGiSCNUO/sQwFYghUTsABGUBoDTQWD8AABWFTXgXAAwMxDQszsN8HEBTl3wEpCwkuHN8FTRITFLXABHxI4ICHM1kjfmCZYEVerAc5HBQ8uMMAhQk/GDD4BtHBvXzACIxBAEZKhG8CE6xrF+tAGQRVsmj5Yq3etm7AlJBBAKXLCAKxzqVDw+ygGSRXtiQ5YA3boF4HDTyRFRCZMkGsXMHaQWCjLVy6HHX6FEqBAgGmUKnahAaSJEqWDDBpYiuo0KFEizYFAgA7]]></data>
	</file>
	<file>
	  <filename>/images/info-small.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[R0lGODlhDAAMAOZNAHm4/3W2/3y6/367/3e3/326/3u5/3+7/3i4/4a+/XO1/4S9/fP5/3+6/Hq4/3a2/+/3/u31/5vJ/Y/D/WKq/bLW/7XX/XK0/2at/GWt/t7u/mSs/Mbg/s/m/tXo/pHE/cni/qHM/YjA/5TG/Wyx/pDD/abP/W2x/mKr/YnA/9rr/oS+/6fQ/97t/m2x/4e//3G0/43C/2+y/na3/8vj/szk/o/D/325/JrJ/efy/m2y/4e+/Yi//c7l/nS1/4m//dnr/sLe/rbY/WKs/bnZ/cji/+Lw/qvS/YC7/5LF//j7/2au/nCz/v///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAE0ALAAAAAAMAAwAAAeAgE2CDEILNyFGgopBGwEIPgQoOIo0GQcIKRVIBQElTQwYBwAKLBAvBAVLHhYyBgAEAjYPAAACIzsBDgQrGkAXtAMJCw8OAAFFNTrACUdMrjAdPUkBtRMRFKIKKjkxMwIuIE1EJAMIIgMBBQANiiZDBgYFAicNSopNLRI/PB8cioEAOw==]]></data>
	</file>
	<file>
	  <filename>/images/stop.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[R0lGODlhFAAUAOZ/AI0AAJQAAf36+tsCFP729/79/deRlPujq8tydO1zfd2Xm+QFGvzBx65NTaMAAe4OJdoAC/bp6ecPI/V6hv4qQPHg4eQAFP4sQv7q7KkAA9oABsmKivo4Tfe4va4DDPkiOdurrPESKf4nPf8oP+EADfvx8vrl570ABbEAA//M0Z0nJ5kAAf3u78QABcgADP0kO/OXn6tHR54eH/YgNp4AAfUYL+/c3ORVYdaKjv3i5bweKPyqs/cnPf1NYPomPcImMK4/P9UAA/Lc3f10guMcLumQlv/u8LZBRbVPULtSVfbCxvjf4fLJzP3m6NWXmMNGTs9IUeG5utpJV/rIzfxse9+2tu4RJ/ZSY/5QYv1fb8VvcdRucv7p68FSVu6bofRib74FEukJIPUbMv8jOuAsPejLy70lL7YACOTBweUyQ+8bMP7k5+9DU8AeKd4YKtY9SOvV1e/S0+zX1/GTmvSXn+9hcOptdcA2PPbs7PabpPyWof5xgP53hf/+/v///////yH5BAEAAH8ALAAAAAAUABQAAAf/gH+Cgn5rO3tYPVQHOX6Dj4IYfBQiFJQfNSFfTZCCKRcjFC8UHBwzIVZhCx2QKWMXF1kMXAQEGAxsFgskrIJGoRcvep0FdCQWECZ/fkMfPh88NQeOkDAaLlJ+GGIzVxMhamF51IN9by4tSzsPD1N+EwsSFjDkgkwnJ0V1YRIsf30JSCyAMKdeCTAnoKRZQISAIIAaBmgoOEhAmzM/yAxw4/ChnSAuUCigJkAHCjM3IAzwV26LAw8ZRv4pAfOJFw0alEDqg8BBBgcK/sRx4ACHiRYn7vTZiYCGAxoGujwV4ifJihVOOvFcQYPriiNLIwRYEcBJAUh+tFwlW2FQFAABMQIAQYNHgIAIZZDEBQACUhUAgOHKkBEgMN96gio0MGw4ho1O5eRsiKFCRYwNcM4+CgQAOw==]]></data>
	</file>
	<file>
	  <filename>/images/xml_rss.gif</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[R0lGODlhJAAOAOYAAP/////9+f/9+v/68f/58P/45P/24//z3v7x2/7v2v7pvP7os/7muf7nqP7ktf7lr/7jo/7iq/7jmf7frv7gnv7cq/7fiv7cmf7YlP3be/3eZP3bYP3Vm/3aX/7Uj/3VfP3WWv3Qiv3Rgv3VWf3UWP3SXPzQY/3Mhf3PUPzLU/zKW/3FafzHRvzDU/zESv3DXfzAYvzAPPy8S/68N/64Mvy2Qvy4M/6xKfywOvywKfypMfuoJvypH/yjKfukHPuhFfucE/uaE/uZC/+WBf+VBPuVCf2TAvuRAPuSAf///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEHAEkALAAAAAAkAA4AAAf/gDdEREOFhoeIiYqHgjMbGpCRkpOUlZAdNIMkIJydnp+goZ+DKKWlDQWlGQUlpQUSphasKLKmtqWDLLq6KQALLAIGuwAAuwICJiwQxbvNLIMx0dIPAAoALtLEHzEqxCoxFADS49GDNufoNsQR6QABAzYMxC02FwDp+IM5+/w5BwAi+gHAAOAFAAcAZOQg2K/hIB4QI64AQABARB4AalQMUCMjDw8WL14c9KOkSQAIfACYcBIHDAAhcADA8SPETBw4dpgsOUiIT58VAAARwgGADp9GhQAQoiPpCWLEEvz0OQiJVas9glztUQSr1a5IenztQTbrVauDiBxZy7at27dwDd0SMZK2rt27ePPODQQAOw==]]></data>
	</file>
	<file>
	  <filename>/includes/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/includes/admin.css</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[dGFibGUubW9kdWxlX2ZiX3RhYmxlIHtmb250LXNpemU6IDEwcHg7IHdpZHRoOjEwMCU7IG1hcmdpbjogMDt9Ci5tb2R1bGVfZmJfYXJlYV93aWRlIHt3aWR0aDogMTAwJTt9Ci5tb2R1bGVfZmJfbGVnZW5ke2ZvbnQtc2l6ZTogOXB4OyBtYXJnaW46IDZweCAwOyBib3JkZXI6IDFweCBzb2xpZCBibGFjazt9Ci5tb2R1bGVfZmJfYXJlYV9zaG9ydCB7d2lkdGg6IDUwMHB4OyBoZWlnaHQ6IDEwMHB4O30KLm1vZHVsZV9mYl9saW5rIHt0ZXh0LWRlY29yYXRpb246IHVuZGVybGluZTt9Ci5tb2R1bGVfZmJfZmllbGRzZXQge21hcmdpbi1ib3R0b206MmVtO30KLm1vZHVsZV9mYnJfdGFibGUgdHIucm93MTpob3ZlciwgLm1vZHVsZV9mYnJfdGFibGUgdHIucm93Mjpob3ZlcntiYWNrZ3JvdW5kOiAjQ0NEQkREO30KLm9kZCB7YmFja2dyb3VuZC1jb2xvcjogI2ZmZjt0ZXh0LWFsaWduOmxlZnQ7dmVydGljYWwtYWxpZ25tZW50OiB0b3A7fQouZXZlbiB7YmFja2dyb3VuZC1jb2xvcjogI2RkZDt0ZXh0LWFsaWduOmxlZnQ7dmVydGljYWwtYWxpZ25tZW50OiB0b3A7fQouaW5wdXRoZWxwICB7IGNvbG9yOiAjMzg0NjU0OyBwYWRkaW5nOiAwOyBtYXJnaW46IDA7IHdpZHRoOiBhdXRvOyB0ZXh0LWFsaWduOmxlZnQ7IH0=]]></data>
	</file>
	<file>
	  <filename>/includes/Advanced_Contact_Form.xml</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?xml version="1.0" encoding="utf-8"?>
<form id="1"
	alias="advanced_contact">
		<form_name><![CDATA[Advanced Contact Form]]></form_name>
		<attribute key="use_captcha"><![CDATA[0]]></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="predisplay_each_udt"><![CDATA[-1]]></attribute>
		<attribute key="validate_udt"><![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="predisplay_udt"><![CDATA[-1]]></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 isset($fb_submission_error) && $fb_submission_error}
		<div class="error_message">{$fb_submission_error}</div>
		{if isset($fb_show_submission_errors) && $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 isset($fb_form_has_validation_errors) && $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 isset($captcha_error) && $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 != '' || $entry->valid == 0} class="
              		{if $entry->required == 1}required{/if}
              		{if $entry->css_class != ''} {$entry->css_class}{/if}
                    {if $entry->valid == 0} fb_invalid{/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 isset($entry->input[numloop]->op) && $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 isset($has_captcha) && $has_captcha == 1}
		<div class="captcha">{$graphic_captcha}{$title_captcha}<br />{if !empty($input_captcha)}{$input_captcha}{/if}</div>
	{/if}
	<div class="submit">{$prev}{$submit}</div>
	</div>
	{$fb_form_end}
{/if}
{$fb_form_footer}]]></attribute>
		<attribute key="redirect_page"><![CDATA[-1]]></attribute>
		<attribute key="submit_action"><![CDATA[text]]></attribute>
		<attribute key="css_class"><![CDATA[advancedcontactform]]></attribute>
		<attribute key="list_delimiter"><![CDATA[,]]></attribute>
		<attribute key="inline"><![CDATA[0]]></attribute>
		<attribute key="submit_javascript"><![CDATA[]]></attribute>
		<attribute key="next_button_text"><![CDATA[Continue...]]></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="captcha_wrong"><![CDATA[Captcha was not correct.]]></attribute>
	<field id="1"
		type="FieldsetStart"
		validation_type=""
		order_by="1"
		required="0"
		hide_label="0"
		display_in_submission="">
			<field_name><![CDATA[About You Fieldset]]></field_name>
			<options>
			<option name="legend"><![CDATA[About You]]></option>
			<option name="css_class"><![CDATA[]]></option>
			<option name="field_alias"><![CDATA[]]></option>
			<option name="helptext"><![CDATA[]]></option>
			<option name="javascript"><![CDATA[]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="2"
		type="FromEmailNameField"
		validation_type=""
		order_by="2"
		required="1"
		hide_label="0"
		display_in_submission="1">
			<field_name><![CDATA[Your Name]]></field_name>
			<options>
			<option name="css_class"><![CDATA[]]></option>
			<option name="field_alias"><![CDATA[users_name]]></option>
			<option name="helptext"><![CDATA[]]></option>
			<option name="javascript"><![CDATA[]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="3"
		type="DispositionFromEmailAddressField"
		validation_type="none"
		order_by="3"
		required="0"
		hide_label="0"
		display_in_submission="1">
			<field_name><![CDATA[Your Email Address]]></field_name>
			<options>
			<option name="email_subject"><![CDATA[Email from Site]]></option>
			<option name="email_from_name"><![CDATA[Form Builder]]></option>
			<option name="send_user_copy"><![CDATA[c]]></option>
			<option name="send_user_label"><![CDATA[Send me a copy of form]]></option>
			<option name="field_alias"><![CDATA[]]></option>
			<option name="javascript"><![CDATA[]]></option>
			<option name="html_email"><![CDATA[]]></option>
			<option name="email_template"><![CDATA[FormBuilder Submission
Form Name: {$sub_form_name}
Date of Submission: {$sub_date}
Your server: {$sub_host}
IP address of person using form: {$sub_source_ip}
URL of page containing form: {$sub_url}
FormBuilder version: {$fb_version}
Tab Character: {$TAB}

-------------------------------------------------
Your Name: {$fld_4}
Your Email Address: {$fld_43}
Email Again: {$fld_42}
Subject: {$fld_10}
Message: {$foo}
]]></option>
			<option name="email_encoding"><![CDATA[utf-8]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="4"
		type="FromEmailAddressAgainField"
		validation_type=""
		order_by="4"
		required="0"
		hide_label="0"
		display_in_submission="1">
			<field_name><![CDATA[Email Again]]></field_name>
			<options>
			<option name="field_to_validate"><![CDATA[Your Email Address]]></option>
			<option name="field_alias"><![CDATA[]]></option>
			<option name="css_class"><![CDATA[]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="5"
		type="FieldsetEnd"
		validation_type=""
		order_by="5"
		required="0"
		hide_label="0"
		display_in_submission="">
			<field_name><![CDATA[About You Fieldset End]]></field_name>
			<options>
			<option name="field_alias"><![CDATA[]]></option>
			<option name="css_class"><![CDATA[]]></option>
			<option name="helptext"><![CDATA[]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="6"
		type="PageBreakField"
		validation_type=""
		order_by="6"
		required=""
		hide_label="0"
		display_in_submission="1">
			<field_name><![CDATA[breaker]]></field_name>
			<options>
			<option name="field_alias"><![CDATA[]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="7"
		type="FieldsetStart"
		validation_type=""
		order_by="7"
		required="0"
		hide_label="0"
		display_in_submission="">
			<field_name><![CDATA[Contact Fieldset]]></field_name>
			<options>
			<option name="legend"><![CDATA[Contact]]></option>
			<option name="field_alias"><![CDATA[]]></option>
			<option name="css_class"><![CDATA[]]></option>
			<option name="helptext"><![CDATA[]]></option>
			<option name="javascript"><![CDATA[]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="8"
		type="StaticTextField"
		validation_type=""
		order_by="8"
		required="0"
		hide_label="0"
		display_in_submission="">
			<field_name><![CDATA[Greeting]]></field_name>
			<options>
			<option name="text"><![CDATA[Hello, {$users_name->value}!<br /> What is it you'd like to talk to us about?]]></option>
			<option name="field_alias"><![CDATA[]]></option>
			<option name="css_class"><![CDATA[]]></option>
			<option name="helptext"><![CDATA[]]></option>
			<option name="javascript"><![CDATA[]]></option>
			<option name="smarty_eval"><![CDATA[1]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="9"
		type="FromEmailSubjectField"
		validation_type=""
		order_by="9"
		required="0"
		hide_label="0"
		display_in_submission="1">
			<field_name><![CDATA[Subject]]></field_name>
			<options>
			<option name="css_class"><![CDATA[]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="10"
		type="TextAreaField"
		validation_type=""
		order_by="10"
		required="1"
		hide_label="0"
		display_in_submission="1">
			<field_name><![CDATA[Message]]></field_name>
			<options>
			<option name="rows"><![CDATA[5]]></option>
			<option name="cols"><![CDATA[60]]></option>
			<option name="css_class"><![CDATA[]]></option>
			<option name="field_alias"><![CDATA[message]]></option>
			<option name="default"><![CDATA[Enter Your Message Here]]></option>
			<option name="clear_default"><![CDATA[1]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="11"
		type="DispositionEmail"
		validation_type=""
		order_by="11"
		required="0"
		hide_label="0"
		display_in_submission="">
			<field_name><![CDATA[Send To]]></field_name>
			<options>
			<option name="email_subject"><![CDATA[Contact Form Submission]]></option>
			<option name="email_from_name"><![CDATA[Form Builder]]></option>
			<option name="email_from_address"><![CDATA[website@yourdomain.com]]></option>
			<option name="destination_address"><![CDATA[you@yourdomain.com]]></option>
			<option name="field_alias"><![CDATA[]]></option>
			<option name="html_email"><![CDATA[1]]></option>
			<option name="email_template"><![CDATA[<h1>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 />
<strong>FormBuilder version</strong>: {$fb_version}<br />
<strong>Tab Character</strong>: {$TAB}<br />

<hr />
{if $fld_2 != "" && $fld_2 != "[unspecified]" }<strong>Your Name</strong>: {$fld_2}<br />{/if}
{if $fld_3 != "" && $fld_3 != "[unspecified]" }<strong>Your Email Address</strong>: {$fld_3}<br />{/if}
{if $fld_4 != "" && $fld_4 != "[unspecified]" }<strong>Email Again</strong>: {$fld_4}<br />{/if}
{if $fld_9 != "" && $fld_9 != "[unspecified]" }<strong>Subject</strong>: {$fld_9}<br />{/if}
{if $message != "" && $message != "[unspecified]" }<strong>Message</strong>: {$message}<br />{/if}
{if $fld_11 != "" && $fld_11 != "[unspecified]" }<strong>Send To</strong>: {$fld_11}<br />{/if}
]]></option>
			<option name="email_encoding"><![CDATA[utf-8]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="12"
		type="FieldsetEnd"
		validation_type=""
		order_by="12"
		required="0"
		hide_label="0"
		display_in_submission="">
			<field_name><![CDATA[Contact Fieldset End]]></field_name>
			<options>
			<option name="field_alias"><![CDATA[]]></option>
			<option name="css_class"><![CDATA[]]></option>
			<option name="helptext"><![CDATA[]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
</form>
]]></data>
	</file>
	<file>
	  <filename>/includes/Contact_Form.xml</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?xml version="1.0" encoding="utf-8"?>
<form id="2"
	alias="contact">
		<form_name><![CDATA[Contact Form]]></form_name>
		<attribute key="submit_action"><![CDATA[text]]></attribute>
		<attribute key="css_class"><![CDATA[contactform]]></attribute>
		<attribute key="list_delimiter"><![CDATA[,]]></attribute>
		<attribute key="inline"><![CDATA[0]]></attribute>
		<attribute key="submit_javascript"><![CDATA[]]></attribute>
		<attribute key="next_button_text"><![CDATA[Continue...]]></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="use_captcha"><![CDATA[0]]></attribute>
		<attribute key="captcha_wrong"><![CDATA[Captcha was not correct.]]></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="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 isset($fb_submission_error) && $fb_submission_error}
		<div class="error_message">{$fb_submission_error}</div>
		{if isset($fb_show_submission_errors) && $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 isset($fb_form_has_validation_errors) && $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 isset($captcha_error) && $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 != '' || $entry->valid == 0} class="
              		{if $entry->required == 1}required{/if}
              		{if $entry->css_class != ''} {$entry->css_class}{/if}
                    {if $entry->valid == 0} fb_invalid{/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 isset($entry->input[numloop]->op) && $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 isset($has_captcha) && $has_captcha == 1}
		<div class="captcha">{$graphic_captcha}{$title_captcha}<br />{if !empty($input_captcha)}{$input_captcha}{/if}</div>
	{/if}
	<div class="submit">{$prev}{$submit}</div>
	</div>
	{$fb_form_end}
{/if}
{$fb_form_footer}]]></attribute>
		<attribute key="validate_udt"><![CDATA[-1]]></attribute>
		<attribute key="predisplay_udt"><![CDATA[-1]]></attribute>
		<attribute key="predisplay_each_udt"><![CDATA[-1]]></attribute>
	<field id="13"
		type="FieldsetStart"
		validation_type=""
		order_by="1"
		required="0"
		hide_label="0"
		display_in_submission="">
			<field_name><![CDATA[Contact Fieldset]]></field_name>
			<options>
			<option name="legend"><![CDATA[Contact]]></option>
			<option name="css_class"><![CDATA[]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="14"
		type="FromEmailNameField"
		validation_type=""
		order_by="2"
		required="0"
		hide_label="0"
		display_in_submission="1">
			<field_name><![CDATA[Your Name]]></field_name>
			<options>
			<option name="css_class"><![CDATA[]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="15"
		type="DispositionFromEmailAddressField"
		validation_type="none"
		order_by="3"
		required="0"
		hide_label="0"
		display_in_submission="1">
			<field_name><![CDATA[Your Email Address]]></field_name>
			<options>
			<option name="email_subject"><![CDATA[Email from Site]]></option>
			<option name="email_from_name"><![CDATA[Form Builder]]></option>
			<option name="send_user_copy"><![CDATA[c]]></option>
			<option name="send_user_label"><![CDATA[Send me a copy of form]]></option>
			<option name="field_alias"><![CDATA[]]></option>
			<option name="javascript"><![CDATA[]]></option>
			<option name="html_email"><![CDATA[]]></option>
			<option name="email_template"><![CDATA[FormBuilder Submission
Form Name: {$sub_form_name}
Date of Submission: {$sub_date}
Your server: {$sub_host}
IP address of person using form: {$sub_source_ip}
URL of page containing form: {$sub_url}
FormBuilder version: {$fb_version}
Tab Character: {$TAB}

-------------------------------------------------
Your Name: {$fld_14}
Your Email Address: {$fld_15}
Email Again: {$fld_16}
Subject: {$fld_17}
Message: {$foo}
]]></option>
			<option name="email_encoding"><![CDATA[utf-8]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="16"
		type="FromEmailAddressAgainField"
		validation_type=""
		order_by="4"
		required="0"
		hide_label="0"
		display_in_submission="1">
			<field_name><![CDATA[Email Again]]></field_name>
			<options>
			<option name="field_to_validate"><![CDATA[Your Email Address]]></option>
			<option name="field_alias"><![CDATA[]]></option>
			<option name="css_class"><![CDATA[]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="17"
		type="FromEmailSubjectField"
		validation_type=""
		order_by="5"
		required="0"
		hide_label="0"
		display_in_submission="1">
			<field_name><![CDATA[Subject]]></field_name>
			<options>
			<option name="css_class"><![CDATA[]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="18"
		type="TextAreaField"
		validation_type=""
		order_by="6"
		required="1"
		hide_label="0"
		display_in_submission="1">
			<field_name><![CDATA[Message]]></field_name>
			<options>
			<option name="rows"><![CDATA[5]]></option>
			<option name="cols"><![CDATA[60]]></option>
			<option name="css_class"><![CDATA[]]></option>
			<option name="field_alias"><![CDATA[message]]></option>
			<option name="default"><![CDATA[Enter Your Message Here]]></option>
			<option name="clear_default"><![CDATA[1]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="19"
		type="DispositionEmail"
		validation_type=""
		order_by="7"
		required="0"
		hide_label="0"
		display_in_submission="">
			<field_name><![CDATA[Send To]]></field_name>
			<options>
			<option name="email_subject"><![CDATA[Contact Form Submission]]></option>
			<option name="email_from_name"><![CDATA[Form Builder]]></option>
			<option name="email_from_address"><![CDATA[website@yourdomain.com]]></option>
			<option name="destination_address"><![CDATA[you@yourdomain.com]]></option>
			<option name="field_alias"><![CDATA[]]></option>
			<option name="html_email"><![CDATA[1]]></option>
			<option name="email_template"><![CDATA[]]></option>
			<option name="email_encoding"><![CDATA[utf-8]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="20"
		type="FieldsetEnd"
		validation_type=""
		order_by="8"
		required="0"
		hide_label="0"
		display_in_submission="">
			<field_name><![CDATA[fieldset end]]></field_name>
			<options>
			<option name="field_alias"><![CDATA[]]></option>
			<option name="css_class"><![CDATA[]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
</form>
]]></data>
	</file>
	<file>
	  <filename>/includes/default.css</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/includes/fb_cnf.inc</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHANCi8qKg0KKiBBZHZhbmNlZCBDb25maWcgRm9yIEZvcm1CdWlsZGVyIE1vZHVsZQ0KKi8NCi8qKg0KKiBUaGlzIGlzIGFuIGFkdmFuY2VkIGNvbmZpZ3VyYXRpb24gZmlsZQ0KKiBEb24ndCBtZXNzIHdpdGggdGhpcyB1bmxlc3MgeW91IGtub3cgd2hhdCB5b3UgYXJlIGRvaW5nDQoqIG9yIGV4cGxpY2l0bHkgdG9sZCB0byBkbyBzbyBieSBhIGRldmVsb3Blcg0KKi8NCg0KLyoqDQoqIFRoZXNlIHByZWZlcmVuY2VzIHdlcmUgcmVtb3ZlZCBmcm9tIHNldHRpbmdzIHNpbmNlIDAuOC4xDQoqIFNjaGVkdWxlZCBmb3IgcmVtb3ZhbCB1bmxlc3MgcHJvdmVuIHRvIGJlIG5lY2Vzc2VyeQ0KKi8NCg0KLyoqDQoqIEVuYWJsZSBGYXN0IEZpZWxkIEFkZCBQdWxsZG93bg0KKiANCiogQHZhciBib29sDQoqLw0KJGZiY2ZnWydzaG93X3ZlcnNpb24nXSAJCT0gRkFMU0U7DQoNCi8qKg0KKiBTaG93IEZvcm0gQnVpbGRlciBWZXJzaW9uDQoqIA0KKiBAdmFyIGJvb2wNCiovDQokZmJjZmdbJ2VuYWJsZV9mYXN0YWRkJ10gCT0gVFJVRTsNCg0KLyoqDQoqIFNob3cgRmllbGQgSURzDQoqIA0KKiBAdmFyIGJvb2wNCiovDQokZmJjZmdbJ3Nob3dfZmllbGRpZHMnXSAJPSBUUlVFOw0KDQovKioNCiogU2hvdyBGaWVsZCBJRHMNCiogDQoqIEB2YXIgYm9vbA0KKi8NCiRmYmNmZ1snc2hvd19maWVsZGFsaWFzZXMnXSAJPSBUUlVFOw0KPz4NCg==]]></data>
	</file>
	<file>
	  <filename>/includes/fb_jquery.js</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[alF1ZXJ5KGRvY3VtZW50KS5yZWFkeShmdW5jdGlvbigkKSB7CgoJJCgiLm1vZHVsZV9mYl90YWJsZSIpLnRhYmxlRG5EKHsKCQoJCW9uRHJhZ0NsYXNzOiAicm93MWhvdmVyIiwKCQlvbkRyb3A6IGZ1bmN0aW9uKHRhYmxlLCByb3cpIHsKCQkKCQkJCXZhciB0b3RhbHJvd3MgPSBqUXVlcnkoIi5tb2R1bGVfZmJfdGFibGUiKS5maW5kKCJ0Ym9keSB0ciIpLnNpemUoKTsKCQkJCQoJCQkJalF1ZXJ5KCIubW9kdWxlX2ZiX3RhYmxlIikuZmluZCgidGJvZHkgdHIiKS5yZW1vdmVDbGFzcygpOwoJCQkJalF1ZXJ5KCIubW9kdWxlX2ZiX3RhYmxlIikuZmluZCgidGJvZHkgdHI6bnRoLWNoaWxkKDJuKzEpIikuYWRkQ2xhc3MoInJvdzEiKTsKCQkJCWpRdWVyeSgiLm1vZHVsZV9mYl90YWJsZSIpLmZpbmQoInRib2R5IHRyOm50aC1jaGlsZCgybikiKS5hZGRDbGFzcygicm93MiIpOwoJCQkJCgkJCQl2YXIgcm93cyA9IHRhYmxlLnRCb2RpZXNbMF0ucm93czsKCQkJCXZhciBzb3J0c3RyID0gcm93c1swXS5pZDsKCQkJCWZvciAodmFyIGk9MTsgaTxyb3dzLmxlbmd0aDsgaSsrKSB7CgkJCQkJc29ydHN0ciArPSAiLCIrcm93c1tpXS5pZDsKCQkJCX0KCQkJCQoJCQkJJCgnLmZicnBfc29ydCcpLnZhbChzb3J0c3RyKTsKCQkJCS8vJCgnLnJlb3JkZXJtZXNzYWdlJykuc2hvdygpOwoJCX0KCX0pOwogICAgalF1ZXJ5KCIudXBkb3duIikuaGlkZSgpOwp9KTs=]]></data>
	</file>
	<file>
	  <filename>/includes/fb_jquery_functions.js</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/includes/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/includes/jquery-1.4.2.min.js</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[/*!
 * jQuery JavaScript Library v1.4.2
 * http://jquery.com/
 *
 * Copyright 2010, John Resig
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * Includes Sizzle.js
 * http://sizzlejs.com/
 * Copyright 2010, The Dojo Foundation
 * Released under the MIT, BSD, and GPL Licenses.
 *
 * Date: Sat Feb 13 22:33:48 2010 -0500
 */
(function(A,w){function ma(){if(!c.isReady){try{s.documentElement.doScroll("left")}catch(a){setTimeout(ma,1);return}c.ready()}}function Qa(a,b){b.src?c.ajax({url:b.src,async:false,dataType:"script"}):c.globalEval(b.text||b.textContent||b.innerHTML||"");b.parentNode&&b.parentNode.removeChild(b)}function X(a,b,d,f,e,j){var i=a.length;if(typeof b==="object"){for(var o in b)X(a,o,b[o],f,e,d);return a}if(d!==w){f=!j&&f&&c.isFunction(d);for(o=0;o<i;o++)e(a[o],b,f?d.call(a[o],o,e(a[o],b)):d,j);return a}return i?
e(a[0],b):w}function J(){return(new Date).getTime()}function Y(){return false}function Z(){return true}function na(a,b,d){d[0].type=a;return c.event.handle.apply(b,d)}function oa(a){var b,d=[],f=[],e=arguments,j,i,o,k,n,r;i=c.data(this,"events");if(!(a.liveFired===this||!i||!i.live||a.button&&a.type==="click")){a.liveFired=this;var u=i.live.slice(0);for(k=0;k<u.length;k++){i=u[k];i.origType.replace(O,"")===a.type?f.push(i.selector):u.splice(k--,1)}j=c(a.target).closest(f,a.currentTarget);n=0;for(r=
j.length;n<r;n++)for(k=0;k<u.length;k++){i=u[k];if(j[n].selector===i.selector){o=j[n].elem;f=null;if(i.preType==="mouseenter"||i.preType==="mouseleave")f=c(a.relatedTarget).closest(i.selector)[0];if(!f||f!==o)d.push({elem:o,handleObj:i})}}n=0;for(r=d.length;n<r;n++){j=d[n];a.currentTarget=j.elem;a.data=j.handleObj.data;a.handleObj=j.handleObj;if(j.handleObj.origHandler.apply(j.elem,e)===false){b=false;break}}return b}}function pa(a,b){return"live."+(a&&a!=="*"?a+".":"")+b.replace(/\./g,"`").replace(/ /g,
"&")}function qa(a){return!a||!a.parentNode||a.parentNode.nodeType===11}function ra(a,b){var d=0;b.each(function(){if(this.nodeName===(a[d]&&a[d].nodeName)){var f=c.data(a[d++]),e=c.data(this,f);if(f=f&&f.events){delete e.handle;e.events={};for(var j in f)for(var i in f[j])c.event.add(this,j,f[j][i],f[j][i].data)}}})}function sa(a,b,d){var f,e,j;b=b&&b[0]?b[0].ownerDocument||b[0]:s;if(a.length===1&&typeof a[0]==="string"&&a[0].length<512&&b===s&&!ta.test(a[0])&&(c.support.checkClone||!ua.test(a[0]))){e=
true;if(j=c.fragments[a[0]])if(j!==1)f=j}if(!f){f=b.createDocumentFragment();c.clean(a,b,f,d)}if(e)c.fragments[a[0]]=j?f:1;return{fragment:f,cacheable:e}}function K(a,b){var d={};c.each(va.concat.apply([],va.slice(0,b)),function(){d[this]=a});return d}function wa(a){return"scrollTo"in a&&a.document?a:a.nodeType===9?a.defaultView||a.parentWindow:false}var c=function(a,b){return new c.fn.init(a,b)},Ra=A.jQuery,Sa=A.$,s=A.document,T,Ta=/^[^<]*(<[\w\W]+>)[^>]*$|^#([\w-]+)$/,Ua=/^.[^:#\[\.,]*$/,Va=/\S/,
Wa=/^(\s|\u00A0)+|(\s|\u00A0)+$/g,Xa=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,P=navigator.userAgent,xa=false,Q=[],L,$=Object.prototype.toString,aa=Object.prototype.hasOwnProperty,ba=Array.prototype.push,R=Array.prototype.slice,ya=Array.prototype.indexOf;c.fn=c.prototype={init:function(a,b){var d,f;if(!a)return this;if(a.nodeType){this.context=this[0]=a;this.length=1;return this}if(a==="body"&&!b){this.context=s;this[0]=s.body;this.selector="body";this.length=1;return this}if(typeof a==="string")if((d=Ta.exec(a))&&
(d[1]||!b))if(d[1]){f=b?b.ownerDocument||b:s;if(a=Xa.exec(a))if(c.isPlainObject(b)){a=[s.createElement(a[1])];c.fn.attr.call(a,b,true)}else a=[f.createElement(a[1])];else{a=sa([d[1]],[f]);a=(a.cacheable?a.fragment.cloneNode(true):a.fragment).childNodes}return c.merge(this,a)}else{if(b=s.getElementById(d[2])){if(b.id!==d[2])return T.find(a);this.length=1;this[0]=b}this.context=s;this.selector=a;return this}else if(!b&&/^\w+$/.test(a)){this.selector=a;this.context=s;a=s.getElementsByTagName(a);return c.merge(this,
a)}else return!b||b.jquery?(b||T).find(a):c(b).find(a);else if(c.isFunction(a))return T.ready(a);if(a.selector!==w){this.selector=a.selector;this.context=a.context}return c.makeArray(a,this)},selector:"",jquery:"1.4.2",length:0,size:function(){return this.length},toArray:function(){return R.call(this,0)},get:function(a){return a==null?this.toArray():a<0?this.slice(a)[0]:this[a]},pushStack:function(a,b,d){var f=c();c.isArray(a)?ba.apply(f,a):c.merge(f,a);f.prevObject=this;f.context=this.context;if(b===
"find")f.selector=this.selector+(this.selector?" ":"")+d;else if(b)f.selector=this.selector+"."+b+"("+d+")";return f},each:function(a,b){return c.each(this,a,b)},ready:function(a){c.bindReady();if(c.isReady)a.call(s,c);else Q&&Q.push(a);return this},eq:function(a){return a===-1?this.slice(a):this.slice(a,+a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(R.apply(this,arguments),"slice",R.call(arguments).join(","))},map:function(a){return this.pushStack(c.map(this,
function(b,d){return a.call(b,d,b)}))},end:function(){return this.prevObject||c(null)},push:ba,sort:[].sort,splice:[].splice};c.fn.init.prototype=c.fn;c.extend=c.fn.extend=function(){var a=arguments[0]||{},b=1,d=arguments.length,f=false,e,j,i,o;if(typeof a==="boolean"){f=a;a=arguments[1]||{};b=2}if(typeof a!=="object"&&!c.isFunction(a))a={};if(d===b){a=this;--b}for(;b<d;b++)if((e=arguments[b])!=null)for(j in e){i=a[j];o=e[j];if(a!==o)if(f&&o&&(c.isPlainObject(o)||c.isArray(o))){i=i&&(c.isPlainObject(i)||
c.isArray(i))?i:c.isArray(o)?[]:{};a[j]=c.extend(f,i,o)}else if(o!==w)a[j]=o}return a};c.extend({noConflict:function(a){A.$=Sa;if(a)A.jQuery=Ra;return c},isReady:false,ready:function(){if(!c.isReady){if(!s.body)return setTimeout(c.ready,13);c.isReady=true;if(Q){for(var a,b=0;a=Q[b++];)a.call(s,c);Q=null}c.fn.triggerHandler&&c(s).triggerHandler("ready")}},bindReady:function(){if(!xa){xa=true;if(s.readyState==="complete")return c.ready();if(s.addEventListener){s.addEventListener("DOMContentLoaded",
L,false);A.addEventListener("load",c.ready,false)}else if(s.attachEvent){s.attachEvent("onreadystatechange",L);A.attachEvent("onload",c.ready);var a=false;try{a=A.frameElement==null}catch(b){}s.documentElement.doScroll&&a&&ma()}}},isFunction:function(a){return $.call(a)==="[object Function]"},isArray:function(a){return $.call(a)==="[object Array]"},isPlainObject:function(a){if(!a||$.call(a)!=="[object Object]"||a.nodeType||a.setInterval)return false;if(a.constructor&&!aa.call(a,"constructor")&&!aa.call(a.constructor.prototype,
"isPrototypeOf"))return false;var b;for(b in a);return b===w||aa.call(a,b)},isEmptyObject:function(a){for(var b in a)return false;return true},error:function(a){throw a;},parseJSON:function(a){if(typeof a!=="string"||!a)return null;a=c.trim(a);if(/^[\],:{}\s]*$/.test(a.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,"@").replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,"]").replace(/(?:^|:|,)(?:\s*\[)+/g,"")))return A.JSON&&A.JSON.parse?A.JSON.parse(a):(new Function("return "+
a))();else c.error("Invalid JSON: "+a)},noop:function(){},globalEval:function(a){if(a&&Va.test(a)){var b=s.getElementsByTagName("head")[0]||s.documentElement,d=s.createElement("script");d.type="text/javascript";if(c.support.scriptEval)d.appendChild(s.createTextNode(a));else d.text=a;b.insertBefore(d,b.firstChild);b.removeChild(d)}},nodeName:function(a,b){return a.nodeName&&a.nodeName.toUpperCase()===b.toUpperCase()},each:function(a,b,d){var f,e=0,j=a.length,i=j===w||c.isFunction(a);if(d)if(i)for(f in a){if(b.apply(a[f],
d)===false)break}else for(;e<j;){if(b.apply(a[e++],d)===false)break}else if(i)for(f in a){if(b.call(a[f],f,a[f])===false)break}else for(d=a[0];e<j&&b.call(d,e,d)!==false;d=a[++e]);return a},trim:function(a){return(a||"").replace(Wa,"")},makeArray:function(a,b){b=b||[];if(a!=null)a.length==null||typeof a==="string"||c.isFunction(a)||typeof a!=="function"&&a.setInterval?ba.call(b,a):c.merge(b,a);return b},inArray:function(a,b){if(b.indexOf)return b.indexOf(a);for(var d=0,f=b.length;d<f;d++)if(b[d]===
a)return d;return-1},merge:function(a,b){var d=a.length,f=0;if(typeof b.length==="number")for(var e=b.length;f<e;f++)a[d++]=b[f];else for(;b[f]!==w;)a[d++]=b[f++];a.length=d;return a},grep:function(a,b,d){for(var f=[],e=0,j=a.length;e<j;e++)!d!==!b(a[e],e)&&f.push(a[e]);return f},map:function(a,b,d){for(var f=[],e,j=0,i=a.length;j<i;j++){e=b(a[j],j,d);if(e!=null)f[f.length]=e}return f.concat.apply([],f)},guid:1,proxy:function(a,b,d){if(arguments.length===2)if(typeof b==="string"){d=a;a=d[b];b=w}else if(b&&
!c.isFunction(b)){d=b;b=w}if(!b&&a)b=function(){return a.apply(d||this,arguments)};if(a)b.guid=a.guid=a.guid||b.guid||c.guid++;return b},uaMatch:function(a){a=a.toLowerCase();a=/(webkit)[ \/]([\w.]+)/.exec(a)||/(opera)(?:.*version)?[ \/]([\w.]+)/.exec(a)||/(msie) ([\w.]+)/.exec(a)||!/compatible/.test(a)&&/(mozilla)(?:.*? rv:([\w.]+))?/.exec(a)||[];return{browser:a[1]||"",version:a[2]||"0"}},browser:{}});P=c.uaMatch(P);if(P.browser){c.browser[P.browser]=true;c.browser.version=P.version}if(c.browser.webkit)c.browser.safari=
true;if(ya)c.inArray=function(a,b){return ya.call(b,a)};T=c(s);if(s.addEventListener)L=function(){s.removeEventListener("DOMContentLoaded",L,false);c.ready()};else if(s.attachEvent)L=function(){if(s.readyState==="complete"){s.detachEvent("onreadystatechange",L);c.ready()}};(function(){c.support={};var a=s.documentElement,b=s.createElement("script"),d=s.createElement("div"),f="script"+J();d.style.display="none";d.innerHTML="   <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
var e=d.getElementsByTagName("*"),j=d.getElementsByTagName("a")[0];if(!(!e||!e.length||!j)){c.support={leadingWhitespace:d.firstChild.nodeType===3,tbody:!d.getElementsByTagName("tbody").length,htmlSerialize:!!d.getElementsByTagName("link").length,style:/red/.test(j.getAttribute("style")),hrefNormalized:j.getAttribute("href")==="/a",opacity:/^0.55$/.test(j.style.opacity),cssFloat:!!j.style.cssFloat,checkOn:d.getElementsByTagName("input")[0].value==="on",optSelected:s.createElement("select").appendChild(s.createElement("option")).selected,
parentNode:d.removeChild(d.appendChild(s.createElement("div"))).parentNode===null,deleteExpando:true,checkClone:false,scriptEval:false,noCloneEvent:true,boxModel:null};b.type="text/javascript";try{b.appendChild(s.createTextNode("window."+f+"=1;"))}catch(i){}a.insertBefore(b,a.firstChild);if(A[f]){c.support.scriptEval=true;delete A[f]}try{delete b.test}catch(o){c.support.deleteExpando=false}a.removeChild(b);if(d.attachEvent&&d.fireEvent){d.attachEvent("onclick",function k(){c.support.noCloneEvent=
false;d.detachEvent("onclick",k)});d.cloneNode(true).fireEvent("onclick")}d=s.createElement("div");d.innerHTML="<input type='radio' name='radiotest' checked='checked'/>";a=s.createDocumentFragment();a.appendChild(d.firstChild);c.support.checkClone=a.cloneNode(true).cloneNode(true).lastChild.checked;c(function(){var k=s.createElement("div");k.style.width=k.style.paddingLeft="1px";s.body.appendChild(k);c.boxModel=c.support.boxModel=k.offsetWidth===2;s.body.removeChild(k).style.display="none"});a=function(k){var n=
s.createElement("div");k="on"+k;var r=k in n;if(!r){n.setAttribute(k,"return;");r=typeof n[k]==="function"}return r};c.support.submitBubbles=a("submit");c.support.changeBubbles=a("change");a=b=d=e=j=null}})();c.props={"for":"htmlFor","class":"className",readonly:"readOnly",maxlength:"maxLength",cellspacing:"cellSpacing",rowspan:"rowSpan",colspan:"colSpan",tabindex:"tabIndex",usemap:"useMap",frameborder:"frameBorder"};var G="jQuery"+J(),Ya=0,za={};c.extend({cache:{},expando:G,noData:{embed:true,object:true,
applet:true},data:function(a,b,d){if(!(a.nodeName&&c.noData[a.nodeName.toLowerCase()])){a=a==A?za:a;var f=a[G],e=c.cache;if(!f&&typeof b==="string"&&d===w)return null;f||(f=++Ya);if(typeof b==="object"){a[G]=f;e[f]=c.extend(true,{},b)}else if(!e[f]){a[G]=f;e[f]={}}a=e[f];if(d!==w)a[b]=d;return typeof b==="string"?a[b]:a}},removeData:function(a,b){if(!(a.nodeName&&c.noData[a.nodeName.toLowerCase()])){a=a==A?za:a;var d=a[G],f=c.cache,e=f[d];if(b){if(e){delete e[b];c.isEmptyObject(e)&&c.removeData(a)}}else{if(c.support.deleteExpando)delete a[c.expando];
else a.removeAttribute&&a.removeAttribute(c.expando);delete f[d]}}}});c.fn.extend({data:function(a,b){if(typeof a==="undefined"&&this.length)return c.data(this[0]);else if(typeof a==="object")return this.each(function(){c.data(this,a)});var d=a.split(".");d[1]=d[1]?"."+d[1]:"";if(b===w){var f=this.triggerHandler("getData"+d[1]+"!",[d[0]]);if(f===w&&this.length)f=c.data(this[0],a);return f===w&&d[1]?this.data(d[0]):f}else return this.trigger("setData"+d[1]+"!",[d[0],b]).each(function(){c.data(this,
a,b)})},removeData:function(a){return this.each(function(){c.removeData(this,a)})}});c.extend({queue:function(a,b,d){if(a){b=(b||"fx")+"queue";var f=c.data(a,b);if(!d)return f||[];if(!f||c.isArray(d))f=c.data(a,b,c.makeArray(d));else f.push(d);return f}},dequeue:function(a,b){b=b||"fx";var d=c.queue(a,b),f=d.shift();if(f==="inprogress")f=d.shift();if(f){b==="fx"&&d.unshift("inprogress");f.call(a,function(){c.dequeue(a,b)})}}});c.fn.extend({queue:function(a,b){if(typeof a!=="string"){b=a;a="fx"}if(b===
w)return c.queue(this[0],a);return this.each(function(){var d=c.queue(this,a,b);a==="fx"&&d[0]!=="inprogress"&&c.dequeue(this,a)})},dequeue:function(a){return this.each(function(){c.dequeue(this,a)})},delay:function(a,b){a=c.fx?c.fx.speeds[a]||a:a;b=b||"fx";return this.queue(b,function(){var d=this;setTimeout(function(){c.dequeue(d,b)},a)})},clearQueue:function(a){return this.queue(a||"fx",[])}});var Aa=/[\n\t]/g,ca=/\s+/,Za=/\r/g,$a=/href|src|style/,ab=/(button|input)/i,bb=/(button|input|object|select|textarea)/i,
cb=/^(a|area)$/i,Ba=/radio|checkbox/;c.fn.extend({attr:function(a,b){return X(this,a,b,true,c.attr)},removeAttr:function(a){return this.each(function(){c.attr(this,a,"");this.nodeType===1&&this.removeAttribute(a)})},addClass:function(a){if(c.isFunction(a))return this.each(function(n){var r=c(this);r.addClass(a.call(this,n,r.attr("class")))});if(a&&typeof a==="string")for(var b=(a||"").split(ca),d=0,f=this.length;d<f;d++){var e=this[d];if(e.nodeType===1)if(e.className){for(var j=" "+e.className+" ",
i=e.className,o=0,k=b.length;o<k;o++)if(j.indexOf(" "+b[o]+" ")<0)i+=" "+b[o];e.className=c.trim(i)}else e.className=a}return this},removeClass:function(a){if(c.isFunction(a))return this.each(function(k){var n=c(this);n.removeClass(a.call(this,k,n.attr("class")))});if(a&&typeof a==="string"||a===w)for(var b=(a||"").split(ca),d=0,f=this.length;d<f;d++){var e=this[d];if(e.nodeType===1&&e.className)if(a){for(var j=(" "+e.className+" ").replace(Aa," "),i=0,o=b.length;i<o;i++)j=j.replace(" "+b[i]+" ",
" ");e.className=c.trim(j)}else e.className=""}return this},toggleClass:function(a,b){var d=typeof a,f=typeof b==="boolean";if(c.isFunction(a))return this.each(function(e){var j=c(this);j.toggleClass(a.call(this,e,j.attr("class"),b),b)});return this.each(function(){if(d==="string")for(var e,j=0,i=c(this),o=b,k=a.split(ca);e=k[j++];){o=f?o:!i.hasClass(e);i[o?"addClass":"removeClass"](e)}else if(d==="undefined"||d==="boolean"){this.className&&c.data(this,"__className__",this.className);this.className=
this.className||a===false?"":c.data(this,"__className__")||""}})},hasClass:function(a){a=" "+a+" ";for(var b=0,d=this.length;b<d;b++)if((" "+this[b].className+" ").replace(Aa," ").indexOf(a)>-1)return true;return false},val:function(a){if(a===w){var b=this[0];if(b){if(c.nodeName(b,"option"))return(b.attributes.value||{}).specified?b.value:b.text;if(c.nodeName(b,"select")){var d=b.selectedIndex,f=[],e=b.options;b=b.type==="select-one";if(d<0)return null;var j=b?d:0;for(d=b?d+1:e.length;j<d;j++){var i=
e[j];if(i.selected){a=c(i).val();if(b)return a;f.push(a)}}return f}if(Ba.test(b.type)&&!c.support.checkOn)return b.getAttribute("value")===null?"on":b.value;return(b.value||"").replace(Za,"")}return w}var o=c.isFunction(a);return this.each(function(k){var n=c(this),r=a;if(this.nodeType===1){if(o)r=a.call(this,k,n.val());if(typeof r==="number")r+="";if(c.isArray(r)&&Ba.test(this.type))this.checked=c.inArray(n.val(),r)>=0;else if(c.nodeName(this,"select")){var u=c.makeArray(r);c("option",this).each(function(){this.selected=
c.inArray(c(this).val(),u)>=0});if(!u.length)this.selectedIndex=-1}else this.value=r}})}});c.extend({attrFn:{val:true,css:true,html:true,text:true,data:true,width:true,height:true,offset:true},attr:function(a,b,d,f){if(!a||a.nodeType===3||a.nodeType===8)return w;if(f&&b in c.attrFn)return c(a)[b](d);f=a.nodeType!==1||!c.isXMLDoc(a);var e=d!==w;b=f&&c.props[b]||b;if(a.nodeType===1){var j=$a.test(b);if(b in a&&f&&!j){if(e){b==="type"&&ab.test(a.nodeName)&&a.parentNode&&c.error("type property can't be changed");
a[b]=d}if(c.nodeName(a,"form")&&a.getAttributeNode(b))return a.getAttributeNode(b).nodeValue;if(b==="tabIndex")return(b=a.getAttributeNode("tabIndex"))&&b.specified?b.value:bb.test(a.nodeName)||cb.test(a.nodeName)&&a.href?0:w;return a[b]}if(!c.support.style&&f&&b==="style"){if(e)a.style.cssText=""+d;return a.style.cssText}e&&a.setAttribute(b,""+d);a=!c.support.hrefNormalized&&f&&j?a.getAttribute(b,2):a.getAttribute(b);return a===null?w:a}return c.style(a,b,d)}});var O=/\.(.*)$/,db=function(a){return a.replace(/[^\w\s\.\|`]/g,
function(b){return"\\"+b})};c.event={add:function(a,b,d,f){if(!(a.nodeType===3||a.nodeType===8)){if(a.setInterval&&a!==A&&!a.frameElement)a=A;var e,j;if(d.handler){e=d;d=e.handler}if(!d.guid)d.guid=c.guid++;if(j=c.data(a)){var i=j.events=j.events||{},o=j.handle;if(!o)j.handle=o=function(){return typeof c!=="undefined"&&!c.event.triggered?c.event.handle.apply(o.elem,arguments):w};o.elem=a;b=b.split(" ");for(var k,n=0,r;k=b[n++];){j=e?c.extend({},e):{handler:d,data:f};if(k.indexOf(".")>-1){r=k.split(".");
k=r.shift();j.namespace=r.slice(0).sort().join(".")}else{r=[];j.namespace=""}j.type=k;j.guid=d.guid;var u=i[k],z=c.event.special[k]||{};if(!u){u=i[k]=[];if(!z.setup||z.setup.call(a,f,r,o)===false)if(a.addEventListener)a.addEventListener(k,o,false);else a.attachEvent&&a.attachEvent("on"+k,o)}if(z.add){z.add.call(a,j);if(!j.handler.guid)j.handler.guid=d.guid}u.push(j);c.event.global[k]=true}a=null}}},global:{},remove:function(a,b,d,f){if(!(a.nodeType===3||a.nodeType===8)){var e,j=0,i,o,k,n,r,u,z=c.data(a),
C=z&&z.events;if(z&&C){if(b&&b.type){d=b.handler;b=b.type}if(!b||typeof b==="string"&&b.charAt(0)==="."){b=b||"";for(e in C)c.event.remove(a,e+b)}else{for(b=b.split(" ");e=b[j++];){n=e;i=e.indexOf(".")<0;o=[];if(!i){o=e.split(".");e=o.shift();k=new RegExp("(^|\\.)"+c.map(o.slice(0).sort(),db).join("\\.(?:.*\\.)?")+"(\\.|$)")}if(r=C[e])if(d){n=c.event.special[e]||{};for(B=f||0;B<r.length;B++){u=r[B];if(d.guid===u.guid){if(i||k.test(u.namespace)){f==null&&r.splice(B--,1);n.remove&&n.remove.call(a,u)}if(f!=
null)break}}if(r.length===0||f!=null&&r.length===1){if(!n.teardown||n.teardown.call(a,o)===false)Ca(a,e,z.handle);delete C[e]}}else for(var B=0;B<r.length;B++){u=r[B];if(i||k.test(u.namespace)){c.event.remove(a,n,u.handler,B);r.splice(B--,1)}}}if(c.isEmptyObject(C)){if(b=z.handle)b.elem=null;delete z.events;delete z.handle;c.isEmptyObject(z)&&c.removeData(a)}}}}},trigger:function(a,b,d,f){var e=a.type||a;if(!f){a=typeof a==="object"?a[G]?a:c.extend(c.Event(e),a):c.Event(e);if(e.indexOf("!")>=0){a.type=
e=e.slice(0,-1);a.exclusive=true}if(!d){a.stopPropagation();c.event.global[e]&&c.each(c.cache,function(){this.events&&this.events[e]&&c.event.trigger(a,b,this.handle.elem)})}if(!d||d.nodeType===3||d.nodeType===8)return w;a.result=w;a.target=d;b=c.makeArray(b);b.unshift(a)}a.currentTarget=d;(f=c.data(d,"handle"))&&f.apply(d,b);f=d.parentNode||d.ownerDocument;try{if(!(d&&d.nodeName&&c.noData[d.nodeName.toLowerCase()]))if(d["on"+e]&&d["on"+e].apply(d,b)===false)a.result=false}catch(j){}if(!a.isPropagationStopped()&&
f)c.event.trigger(a,b,f,true);else if(!a.isDefaultPrevented()){f=a.target;var i,o=c.nodeName(f,"a")&&e==="click",k=c.event.special[e]||{};if((!k._default||k._default.call(d,a)===false)&&!o&&!(f&&f.nodeName&&c.noData[f.nodeName.toLowerCase()])){try{if(f[e]){if(i=f["on"+e])f["on"+e]=null;c.event.triggered=true;f[e]()}}catch(n){}if(i)f["on"+e]=i;c.event.triggered=false}}},handle:function(a){var b,d,f,e;a=arguments[0]=c.event.fix(a||A.event);a.currentTarget=this;b=a.type.indexOf(".")<0&&!a.exclusive;
if(!b){d=a.type.split(".");a.type=d.shift();f=new RegExp("(^|\\.)"+d.slice(0).sort().join("\\.(?:.*\\.)?")+"(\\.|$)")}e=c.data(this,"events");d=e[a.type];if(e&&d){d=d.slice(0);e=0;for(var j=d.length;e<j;e++){var i=d[e];if(b||f.test(i.namespace)){a.handler=i.handler;a.data=i.data;a.handleObj=i;i=i.handler.apply(this,arguments);if(i!==w){a.result=i;if(i===false){a.preventDefault();a.stopPropagation()}}if(a.isImmediatePropagationStopped())break}}}return a.result},props:"altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
fix:function(a){if(a[G])return a;var b=a;a=c.Event(b);for(var d=this.props.length,f;d;){f=this.props[--d];a[f]=b[f]}if(!a.target)a.target=a.srcElement||s;if(a.target.nodeType===3)a.target=a.target.parentNode;if(!a.relatedTarget&&a.fromElement)a.relatedTarget=a.fromElement===a.target?a.toElement:a.fromElement;if(a.pageX==null&&a.clientX!=null){b=s.documentElement;d=s.body;a.pageX=a.clientX+(b&&b.scrollLeft||d&&d.scrollLeft||0)-(b&&b.clientLeft||d&&d.clientLeft||0);a.pageY=a.clientY+(b&&b.scrollTop||
d&&d.scrollTop||0)-(b&&b.clientTop||d&&d.clientTop||0)}if(!a.which&&(a.charCode||a.charCode===0?a.charCode:a.keyCode))a.which=a.charCode||a.keyCode;if(!a.metaKey&&a.ctrlKey)a.metaKey=a.ctrlKey;if(!a.which&&a.button!==w)a.which=a.button&1?1:a.button&2?3:a.button&4?2:0;return a},guid:1E8,proxy:c.proxy,special:{ready:{setup:c.bindReady,teardown:c.noop},live:{add:function(a){c.event.add(this,a.origType,c.extend({},a,{handler:oa}))},remove:function(a){var b=true,d=a.origType.replace(O,"");c.each(c.data(this,
"events").live||[],function(){if(d===this.origType.replace(O,""))return b=false});b&&c.event.remove(this,a.origType,oa)}},beforeunload:{setup:function(a,b,d){if(this.setInterval)this.onbeforeunload=d;return false},teardown:function(a,b){if(this.onbeforeunload===b)this.onbeforeunload=null}}}};var Ca=s.removeEventListener?function(a,b,d){a.removeEventListener(b,d,false)}:function(a,b,d){a.detachEvent("on"+b,d)};c.Event=function(a){if(!this.preventDefault)return new c.Event(a);if(a&&a.type){this.originalEvent=
a;this.type=a.type}else this.type=a;this.timeStamp=J();this[G]=true};c.Event.prototype={preventDefault:function(){this.isDefaultPrevented=Z;var a=this.originalEvent;if(a){a.preventDefault&&a.preventDefault();a.returnValue=false}},stopPropagation:function(){this.isPropagationStopped=Z;var a=this.originalEvent;if(a){a.stopPropagation&&a.stopPropagation();a.cancelBubble=true}},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=Z;this.stopPropagation()},isDefaultPrevented:Y,isPropagationStopped:Y,
isImmediatePropagationStopped:Y};var Da=function(a){var b=a.relatedTarget;try{for(;b&&b!==this;)b=b.parentNode;if(b!==this){a.type=a.data;c.event.handle.apply(this,arguments)}}catch(d){}},Ea=function(a){a.type=a.data;c.event.handle.apply(this,arguments)};c.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(a,b){c.event.special[a]={setup:function(d){c.event.add(this,b,d&&d.selector?Ea:Da,a)},teardown:function(d){c.event.remove(this,b,d&&d.selector?Ea:Da)}}});if(!c.support.submitBubbles)c.event.special.submit=
{setup:function(){if(this.nodeName.toLowerCase()!=="form"){c.event.add(this,"click.specialSubmit",function(a){var b=a.target,d=b.type;if((d==="submit"||d==="image")&&c(b).closest("form").length)return na("submit",this,arguments)});c.event.add(this,"keypress.specialSubmit",function(a){var b=a.target,d=b.type;if((d==="text"||d==="password")&&c(b).closest("form").length&&a.keyCode===13)return na("submit",this,arguments)})}else return false},teardown:function(){c.event.remove(this,".specialSubmit")}};
if(!c.support.changeBubbles){var da=/textarea|input|select/i,ea,Fa=function(a){var b=a.type,d=a.value;if(b==="radio"||b==="checkbox")d=a.checked;else if(b==="select-multiple")d=a.selectedIndex>-1?c.map(a.options,function(f){return f.selected}).join("-"):"";else if(a.nodeName.toLowerCase()==="select")d=a.selectedIndex;return d},fa=function(a,b){var d=a.target,f,e;if(!(!da.test(d.nodeName)||d.readOnly)){f=c.data(d,"_change_data");e=Fa(d);if(a.type!=="focusout"||d.type!=="radio")c.data(d,"_change_data",
e);if(!(f===w||e===f))if(f!=null||e){a.type="change";return c.event.trigger(a,b,d)}}};c.event.special.change={filters:{focusout:fa,click:function(a){var b=a.target,d=b.type;if(d==="radio"||d==="checkbox"||b.nodeName.toLowerCase()==="select")return fa.call(this,a)},keydown:function(a){var b=a.target,d=b.type;if(a.keyCode===13&&b.nodeName.toLowerCase()!=="textarea"||a.keyCode===32&&(d==="checkbox"||d==="radio")||d==="select-multiple")return fa.call(this,a)},beforeactivate:function(a){a=a.target;c.data(a,
"_change_data",Fa(a))}},setup:function(){if(this.type==="file")return false;for(var a in ea)c.event.add(this,a+".specialChange",ea[a]);return da.test(this.nodeName)},teardown:function(){c.event.remove(this,".specialChange");return da.test(this.nodeName)}};ea=c.event.special.change.filters}s.addEventListener&&c.each({focus:"focusin",blur:"focusout"},function(a,b){function d(f){f=c.event.fix(f);f.type=b;return c.event.handle.call(this,f)}c.event.special[b]={setup:function(){this.addEventListener(a,
d,true)},teardown:function(){this.removeEventListener(a,d,true)}}});c.each(["bind","one"],function(a,b){c.fn[b]=function(d,f,e){if(typeof d==="object"){for(var j in d)this[b](j,f,d[j],e);return this}if(c.isFunction(f)){e=f;f=w}var i=b==="one"?c.proxy(e,function(k){c(this).unbind(k,i);return e.apply(this,arguments)}):e;if(d==="unload"&&b!=="one")this.one(d,f,e);else{j=0;for(var o=this.length;j<o;j++)c.event.add(this[j],d,i,f)}return this}});c.fn.extend({unbind:function(a,b){if(typeof a==="object"&&
!a.preventDefault)for(var d in a)this.unbind(d,a[d]);else{d=0;for(var f=this.length;d<f;d++)c.event.remove(this[d],a,b)}return this},delegate:function(a,b,d,f){return this.live(b,d,f,a)},undelegate:function(a,b,d){return arguments.length===0?this.unbind("live"):this.die(b,null,d,a)},trigger:function(a,b){return this.each(function(){c.event.trigger(a,b,this)})},triggerHandler:function(a,b){if(this[0]){a=c.Event(a);a.preventDefault();a.stopPropagation();c.event.trigger(a,b,this[0]);return a.result}},
toggle:function(a){for(var b=arguments,d=1;d<b.length;)c.proxy(a,b[d++]);return this.click(c.proxy(a,function(f){var e=(c.data(this,"lastToggle"+a.guid)||0)%d;c.data(this,"lastToggle"+a.guid,e+1);f.preventDefault();return b[e].apply(this,arguments)||false}))},hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}});var Ga={focus:"focusin",blur:"focusout",mouseenter:"mouseover",mouseleave:"mouseout"};c.each(["live","die"],function(a,b){c.fn[b]=function(d,f,e,j){var i,o=0,k,n,r=j||this.selector,
u=j?this:c(this.context);if(c.isFunction(f)){e=f;f=w}for(d=(d||"").split(" ");(i=d[o++])!=null;){j=O.exec(i);k="";if(j){k=j[0];i=i.replace(O,"")}if(i==="hover")d.push("mouseenter"+k,"mouseleave"+k);else{n=i;if(i==="focus"||i==="blur"){d.push(Ga[i]+k);i+=k}else i=(Ga[i]||i)+k;b==="live"?u.each(function(){c.event.add(this,pa(i,r),{data:f,selector:r,handler:e,origType:i,origHandler:e,preType:n})}):u.unbind(pa(i,r),e)}}return this}});c.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error".split(" "),
function(a,b){c.fn[b]=function(d){return d?this.bind(b,d):this.trigger(b)};if(c.attrFn)c.attrFn[b]=true});A.attachEvent&&!A.addEventListener&&A.attachEvent("onunload",function(){for(var a in c.cache)if(c.cache[a].handle)try{c.event.remove(c.cache[a].handle.elem)}catch(b){}});(function(){function a(g){for(var h="",l,m=0;g[m];m++){l=g[m];if(l.nodeType===3||l.nodeType===4)h+=l.nodeValue;else if(l.nodeType!==8)h+=a(l.childNodes)}return h}function b(g,h,l,m,q,p){q=0;for(var v=m.length;q<v;q++){var t=m[q];
if(t){t=t[g];for(var y=false;t;){if(t.sizcache===l){y=m[t.sizset];break}if(t.nodeType===1&&!p){t.sizcache=l;t.sizset=q}if(t.nodeName.toLowerCase()===h){y=t;break}t=t[g]}m[q]=y}}}function d(g,h,l,m,q,p){q=0;for(var v=m.length;q<v;q++){var t=m[q];if(t){t=t[g];for(var y=false;t;){if(t.sizcache===l){y=m[t.sizset];break}if(t.nodeType===1){if(!p){t.sizcache=l;t.sizset=q}if(typeof h!=="string"){if(t===h){y=true;break}}else if(k.filter(h,[t]).length>0){y=t;break}}t=t[g]}m[q]=y}}}var f=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
e=0,j=Object.prototype.toString,i=false,o=true;[0,0].sort(function(){o=false;return 0});var k=function(g,h,l,m){l=l||[];var q=h=h||s;if(h.nodeType!==1&&h.nodeType!==9)return[];if(!g||typeof g!=="string")return l;for(var p=[],v,t,y,S,H=true,M=x(h),I=g;(f.exec(""),v=f.exec(I))!==null;){I=v[3];p.push(v[1]);if(v[2]){S=v[3];break}}if(p.length>1&&r.exec(g))if(p.length===2&&n.relative[p[0]])t=ga(p[0]+p[1],h);else for(t=n.relative[p[0]]?[h]:k(p.shift(),h);p.length;){g=p.shift();if(n.relative[g])g+=p.shift();
t=ga(g,t)}else{if(!m&&p.length>1&&h.nodeType===9&&!M&&n.match.ID.test(p[0])&&!n.match.ID.test(p[p.length-1])){v=k.find(p.shift(),h,M);h=v.expr?k.filter(v.expr,v.set)[0]:v.set[0]}if(h){v=m?{expr:p.pop(),set:z(m)}:k.find(p.pop(),p.length===1&&(p[0]==="~"||p[0]==="+")&&h.parentNode?h.parentNode:h,M);t=v.expr?k.filter(v.expr,v.set):v.set;if(p.length>0)y=z(t);else H=false;for(;p.length;){var D=p.pop();v=D;if(n.relative[D])v=p.pop();else D="";if(v==null)v=h;n.relative[D](y,v,M)}}else y=[]}y||(y=t);y||k.error(D||
g);if(j.call(y)==="[object Array]")if(H)if(h&&h.nodeType===1)for(g=0;y[g]!=null;g++){if(y[g]&&(y[g]===true||y[g].nodeType===1&&E(h,y[g])))l.push(t[g])}else for(g=0;y[g]!=null;g++)y[g]&&y[g].nodeType===1&&l.push(t[g]);else l.push.apply(l,y);else z(y,l);if(S){k(S,q,l,m);k.uniqueSort(l)}return l};k.uniqueSort=function(g){if(B){i=o;g.sort(B);if(i)for(var h=1;h<g.length;h++)g[h]===g[h-1]&&g.splice(h--,1)}return g};k.matches=function(g,h){return k(g,null,null,h)};k.find=function(g,h,l){var m,q;if(!g)return[];
for(var p=0,v=n.order.length;p<v;p++){var t=n.order[p];if(q=n.leftMatch[t].exec(g)){var y=q[1];q.splice(1,1);if(y.substr(y.length-1)!=="\\"){q[1]=(q[1]||"").replace(/\\/g,"");m=n.find[t](q,h,l);if(m!=null){g=g.replace(n.match[t],"");break}}}}m||(m=h.getElementsByTagName("*"));return{set:m,expr:g}};k.filter=function(g,h,l,m){for(var q=g,p=[],v=h,t,y,S=h&&h[0]&&x(h[0]);g&&h.length;){for(var H in n.filter)if((t=n.leftMatch[H].exec(g))!=null&&t[2]){var M=n.filter[H],I,D;D=t[1];y=false;t.splice(1,1);if(D.substr(D.length-
1)!=="\\"){if(v===p)p=[];if(n.preFilter[H])if(t=n.preFilter[H](t,v,l,p,m,S)){if(t===true)continue}else y=I=true;if(t)for(var U=0;(D=v[U])!=null;U++)if(D){I=M(D,t,U,v);var Ha=m^!!I;if(l&&I!=null)if(Ha)y=true;else v[U]=false;else if(Ha){p.push(D);y=true}}if(I!==w){l||(v=p);g=g.replace(n.match[H],"");if(!y)return[];break}}}if(g===q)if(y==null)k.error(g);else break;q=g}return v};k.error=function(g){throw"Syntax error, unrecognized expression: "+g;};var n=k.selectors={order:["ID","NAME","TAG"],match:{ID:/#((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
CLASS:/\.((?:[\w\u00c0-\uFFFF-]|\\.)+)/,NAME:/\[name=['"]*((?:[\w\u00c0-\uFFFF-]|\\.)+)['"]*\]/,ATTR:/\[\s*((?:[\w\u00c0-\uFFFF-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,TAG:/^((?:[\w\u00c0-\uFFFF\*-]|\\.)+)/,CHILD:/:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,POS:/:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,PSEUDO:/:((?:[\w\u00c0-\uFFFF-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/},leftMatch:{},attrMap:{"class":"className","for":"htmlFor"},attrHandle:{href:function(g){return g.getAttribute("href")}},
relative:{"+":function(g,h){var l=typeof h==="string",m=l&&!/\W/.test(h);l=l&&!m;if(m)h=h.toLowerCase();m=0;for(var q=g.length,p;m<q;m++)if(p=g[m]){for(;(p=p.previousSibling)&&p.nodeType!==1;);g[m]=l||p&&p.nodeName.toLowerCase()===h?p||false:p===h}l&&k.filter(h,g,true)},">":function(g,h){var l=typeof h==="string";if(l&&!/\W/.test(h)){h=h.toLowerCase();for(var m=0,q=g.length;m<q;m++){var p=g[m];if(p){l=p.parentNode;g[m]=l.nodeName.toLowerCase()===h?l:false}}}else{m=0;for(q=g.length;m<q;m++)if(p=g[m])g[m]=
l?p.parentNode:p.parentNode===h;l&&k.filter(h,g,true)}},"":function(g,h,l){var m=e++,q=d;if(typeof h==="string"&&!/\W/.test(h)){var p=h=h.toLowerCase();q=b}q("parentNode",h,m,g,p,l)},"~":function(g,h,l){var m=e++,q=d;if(typeof h==="string"&&!/\W/.test(h)){var p=h=h.toLowerCase();q=b}q("previousSibling",h,m,g,p,l)}},find:{ID:function(g,h,l){if(typeof h.getElementById!=="undefined"&&!l)return(g=h.getElementById(g[1]))?[g]:[]},NAME:function(g,h){if(typeof h.getElementsByName!=="undefined"){var l=[];
h=h.getElementsByName(g[1]);for(var m=0,q=h.length;m<q;m++)h[m].getAttribute("name")===g[1]&&l.push(h[m]);return l.length===0?null:l}},TAG:function(g,h){return h.getElementsByTagName(g[1])}},preFilter:{CLASS:function(g,h,l,m,q,p){g=" "+g[1].replace(/\\/g,"")+" ";if(p)return g;p=0;for(var v;(v=h[p])!=null;p++)if(v)if(q^(v.className&&(" "+v.className+" ").replace(/[\t\n]/g," ").indexOf(g)>=0))l||m.push(v);else if(l)h[p]=false;return false},ID:function(g){return g[1].replace(/\\/g,"")},TAG:function(g){return g[1].toLowerCase()},
CHILD:function(g){if(g[1]==="nth"){var h=/(-?)(\d*)n((?:\+|-)?\d*)/.exec(g[2]==="even"&&"2n"||g[2]==="odd"&&"2n+1"||!/\D/.test(g[2])&&"0n+"+g[2]||g[2]);g[2]=h[1]+(h[2]||1)-0;g[3]=h[3]-0}g[0]=e++;return g},ATTR:function(g,h,l,m,q,p){h=g[1].replace(/\\/g,"");if(!p&&n.attrMap[h])g[1]=n.attrMap[h];if(g[2]==="~=")g[4]=" "+g[4]+" ";return g},PSEUDO:function(g,h,l,m,q){if(g[1]==="not")if((f.exec(g[3])||"").length>1||/^\w/.test(g[3]))g[3]=k(g[3],null,null,h);else{g=k.filter(g[3],h,l,true^q);l||m.push.apply(m,
g);return false}else if(n.match.POS.test(g[0])||n.match.CHILD.test(g[0]))return true;return g},POS:function(g){g.unshift(true);return g}},filters:{enabled:function(g){return g.disabled===false&&g.type!=="hidden"},disabled:function(g){return g.disabled===true},checked:function(g){return g.checked===true},selected:function(g){return g.selected===true},parent:function(g){return!!g.firstChild},empty:function(g){return!g.firstChild},has:function(g,h,l){return!!k(l[3],g).length},header:function(g){return/h\d/i.test(g.nodeName)},
text:function(g){return"text"===g.type},radio:function(g){return"radio"===g.type},checkbox:function(g){return"checkbox"===g.type},file:function(g){return"file"===g.type},password:function(g){return"password"===g.type},submit:function(g){return"submit"===g.type},image:function(g){return"image"===g.type},reset:function(g){return"reset"===g.type},button:function(g){return"button"===g.type||g.nodeName.toLowerCase()==="button"},input:function(g){return/input|select|textarea|button/i.test(g.nodeName)}},
setFilters:{first:function(g,h){return h===0},last:function(g,h,l,m){return h===m.length-1},even:function(g,h){return h%2===0},odd:function(g,h){return h%2===1},lt:function(g,h,l){return h<l[3]-0},gt:function(g,h,l){return h>l[3]-0},nth:function(g,h,l){return l[3]-0===h},eq:function(g,h,l){return l[3]-0===h}},filter:{PSEUDO:function(g,h,l,m){var q=h[1],p=n.filters[q];if(p)return p(g,l,h,m);else if(q==="contains")return(g.textContent||g.innerText||a([g])||"").indexOf(h[3])>=0;else if(q==="not"){h=
h[3];l=0;for(m=h.length;l<m;l++)if(h[l]===g)return false;return true}else k.error("Syntax error, unrecognized expression: "+q)},CHILD:function(g,h){var l=h[1],m=g;switch(l){case "only":case "first":for(;m=m.previousSibling;)if(m.nodeType===1)return false;if(l==="first")return true;m=g;case "last":for(;m=m.nextSibling;)if(m.nodeType===1)return false;return true;case "nth":l=h[2];var q=h[3];if(l===1&&q===0)return true;h=h[0];var p=g.parentNode;if(p&&(p.sizcache!==h||!g.nodeIndex)){var v=0;for(m=p.firstChild;m;m=
m.nextSibling)if(m.nodeType===1)m.nodeIndex=++v;p.sizcache=h}g=g.nodeIndex-q;return l===0?g===0:g%l===0&&g/l>=0}},ID:function(g,h){return g.nodeType===1&&g.getAttribute("id")===h},TAG:function(g,h){return h==="*"&&g.nodeType===1||g.nodeName.toLowerCase()===h},CLASS:function(g,h){return(" "+(g.className||g.getAttribute("class"))+" ").indexOf(h)>-1},ATTR:function(g,h){var l=h[1];g=n.attrHandle[l]?n.attrHandle[l](g):g[l]!=null?g[l]:g.getAttribute(l);l=g+"";var m=h[2];h=h[4];return g==null?m==="!=":m===
"="?l===h:m==="*="?l.indexOf(h)>=0:m==="~="?(" "+l+" ").indexOf(h)>=0:!h?l&&g!==false:m==="!="?l!==h:m==="^="?l.indexOf(h)===0:m==="$="?l.substr(l.length-h.length)===h:m==="|="?l===h||l.substr(0,h.length+1)===h+"-":false},POS:function(g,h,l,m){var q=n.setFilters[h[2]];if(q)return q(g,l,h,m)}}},r=n.match.POS;for(var u in n.match){n.match[u]=new RegExp(n.match[u].source+/(?![^\[]*\])(?![^\(]*\))/.source);n.leftMatch[u]=new RegExp(/(^(?:.|\r|\n)*?)/.source+n.match[u].source.replace(/\\(\d+)/g,function(g,
h){return"\\"+(h-0+1)}))}var z=function(g,h){g=Array.prototype.slice.call(g,0);if(h){h.push.apply(h,g);return h}return g};try{Array.prototype.slice.call(s.documentElement.childNodes,0)}catch(C){z=function(g,h){h=h||[];if(j.call(g)==="[object Array]")Array.prototype.push.apply(h,g);else if(typeof g.length==="number")for(var l=0,m=g.length;l<m;l++)h.push(g[l]);else for(l=0;g[l];l++)h.push(g[l]);return h}}var B;if(s.documentElement.compareDocumentPosition)B=function(g,h){if(!g.compareDocumentPosition||
!h.compareDocumentPosition){if(g==h)i=true;return g.compareDocumentPosition?-1:1}g=g.compareDocumentPosition(h)&4?-1:g===h?0:1;if(g===0)i=true;return g};else if("sourceIndex"in s.documentElement)B=function(g,h){if(!g.sourceIndex||!h.sourceIndex){if(g==h)i=true;return g.sourceIndex?-1:1}g=g.sourceIndex-h.sourceIndex;if(g===0)i=true;return g};else if(s.createRange)B=function(g,h){if(!g.ownerDocument||!h.ownerDocument){if(g==h)i=true;return g.ownerDocument?-1:1}var l=g.ownerDocument.createRange(),m=
h.ownerDocument.createRange();l.setStart(g,0);l.setEnd(g,0);m.setStart(h,0);m.setEnd(h,0);g=l.compareBoundaryPoints(Range.START_TO_END,m);if(g===0)i=true;return g};(function(){var g=s.createElement("div"),h="script"+(new Date).getTime();g.innerHTML="<a name='"+h+"'/>";var l=s.documentElement;l.insertBefore(g,l.firstChild);if(s.getElementById(h)){n.find.ID=function(m,q,p){if(typeof q.getElementById!=="undefined"&&!p)return(q=q.getElementById(m[1]))?q.id===m[1]||typeof q.getAttributeNode!=="undefined"&&
q.getAttributeNode("id").nodeValue===m[1]?[q]:w:[]};n.filter.ID=function(m,q){var p=typeof m.getAttributeNode!=="undefined"&&m.getAttributeNode("id");return m.nodeType===1&&p&&p.nodeValue===q}}l.removeChild(g);l=g=null})();(function(){var g=s.createElement("div");g.appendChild(s.createComment(""));if(g.getElementsByTagName("*").length>0)n.find.TAG=function(h,l){l=l.getElementsByTagName(h[1]);if(h[1]==="*"){h=[];for(var m=0;l[m];m++)l[m].nodeType===1&&h.push(l[m]);l=h}return l};g.innerHTML="<a href='#'></a>";
if(g.firstChild&&typeof g.firstChild.getAttribute!=="undefined"&&g.firstChild.getAttribute("href")!=="#")n.attrHandle.href=function(h){return h.getAttribute("href",2)};g=null})();s.querySelectorAll&&function(){var g=k,h=s.createElement("div");h.innerHTML="<p class='TEST'></p>";if(!(h.querySelectorAll&&h.querySelectorAll(".TEST").length===0)){k=function(m,q,p,v){q=q||s;if(!v&&q.nodeType===9&&!x(q))try{return z(q.querySelectorAll(m),p)}catch(t){}return g(m,q,p,v)};for(var l in g)k[l]=g[l];h=null}}();
(function(){var g=s.createElement("div");g.innerHTML="<div class='test e'></div><div class='test'></div>";if(!(!g.getElementsByClassName||g.getElementsByClassName("e").length===0)){g.lastChild.className="e";if(g.getElementsByClassName("e").length!==1){n.order.splice(1,0,"CLASS");n.find.CLASS=function(h,l,m){if(typeof l.getElementsByClassName!=="undefined"&&!m)return l.getElementsByClassName(h[1])};g=null}}})();var E=s.compareDocumentPosition?function(g,h){return!!(g.compareDocumentPosition(h)&16)}:
function(g,h){return g!==h&&(g.contains?g.contains(h):true)},x=function(g){return(g=(g?g.ownerDocument||g:0).documentElement)?g.nodeName!=="HTML":false},ga=function(g,h){var l=[],m="",q;for(h=h.nodeType?[h]:h;q=n.match.PSEUDO.exec(g);){m+=q[0];g=g.replace(n.match.PSEUDO,"")}g=n.relative[g]?g+"*":g;q=0;for(var p=h.length;q<p;q++)k(g,h[q],l);return k.filter(m,l)};c.find=k;c.expr=k.selectors;c.expr[":"]=c.expr.filters;c.unique=k.uniqueSort;c.text=a;c.isXMLDoc=x;c.contains=E})();var eb=/Until$/,fb=/^(?:parents|prevUntil|prevAll)/,
gb=/,/;R=Array.prototype.slice;var Ia=function(a,b,d){if(c.isFunction(b))return c.grep(a,function(e,j){return!!b.call(e,j,e)===d});else if(b.nodeType)return c.grep(a,function(e){return e===b===d});else if(typeof b==="string"){var f=c.grep(a,function(e){return e.nodeType===1});if(Ua.test(b))return c.filter(b,f,!d);else b=c.filter(b,f)}return c.grep(a,function(e){return c.inArray(e,b)>=0===d})};c.fn.extend({find:function(a){for(var b=this.pushStack("","find",a),d=0,f=0,e=this.length;f<e;f++){d=b.length;
c.find(a,this[f],b);if(f>0)for(var j=d;j<b.length;j++)for(var i=0;i<d;i++)if(b[i]===b[j]){b.splice(j--,1);break}}return b},has:function(a){var b=c(a);return this.filter(function(){for(var d=0,f=b.length;d<f;d++)if(c.contains(this,b[d]))return true})},not:function(a){return this.pushStack(Ia(this,a,false),"not",a)},filter:function(a){return this.pushStack(Ia(this,a,true),"filter",a)},is:function(a){return!!a&&c.filter(a,this).length>0},closest:function(a,b){if(c.isArray(a)){var d=[],f=this[0],e,j=
{},i;if(f&&a.length){e=0;for(var o=a.length;e<o;e++){i=a[e];j[i]||(j[i]=c.expr.match.POS.test(i)?c(i,b||this.context):i)}for(;f&&f.ownerDocument&&f!==b;){for(i in j){e=j[i];if(e.jquery?e.index(f)>-1:c(f).is(e)){d.push({selector:i,elem:f});delete j[i]}}f=f.parentNode}}return d}var k=c.expr.match.POS.test(a)?c(a,b||this.context):null;return this.map(function(n,r){for(;r&&r.ownerDocument&&r!==b;){if(k?k.index(r)>-1:c(r).is(a))return r;r=r.parentNode}return null})},index:function(a){if(!a||typeof a===
"string")return c.inArray(this[0],a?c(a):this.parent().children());return c.inArray(a.jquery?a[0]:a,this)},add:function(a,b){a=typeof a==="string"?c(a,b||this.context):c.makeArray(a);b=c.merge(this.get(),a);return this.pushStack(qa(a[0])||qa(b[0])?b:c.unique(b))},andSelf:function(){return this.add(this.prevObject)}});c.each({parent:function(a){return(a=a.parentNode)&&a.nodeType!==11?a:null},parents:function(a){return c.dir(a,"parentNode")},parentsUntil:function(a,b,d){return c.dir(a,"parentNode",
d)},next:function(a){return c.nth(a,2,"nextSibling")},prev:function(a){return c.nth(a,2,"previousSibling")},nextAll:function(a){return c.dir(a,"nextSibling")},prevAll:function(a){return c.dir(a,"previousSibling")},nextUntil:function(a,b,d){return c.dir(a,"nextSibling",d)},prevUntil:function(a,b,d){return c.dir(a,"previousSibling",d)},siblings:function(a){return c.sibling(a.parentNode.firstChild,a)},children:function(a){return c.sibling(a.firstChild)},contents:function(a){return c.nodeName(a,"iframe")?
a.contentDocument||a.contentWindow.document:c.makeArray(a.childNodes)}},function(a,b){c.fn[a]=function(d,f){var e=c.map(this,b,d);eb.test(a)||(f=d);if(f&&typeof f==="string")e=c.filter(f,e);e=this.length>1?c.unique(e):e;if((this.length>1||gb.test(f))&&fb.test(a))e=e.reverse();return this.pushStack(e,a,R.call(arguments).join(","))}});c.extend({filter:function(a,b,d){if(d)a=":not("+a+")";return c.find.matches(a,b)},dir:function(a,b,d){var f=[];for(a=a[b];a&&a.nodeType!==9&&(d===w||a.nodeType!==1||!c(a).is(d));){a.nodeType===
1&&f.push(a);a=a[b]}return f},nth:function(a,b,d){b=b||1;for(var f=0;a;a=a[d])if(a.nodeType===1&&++f===b)break;return a},sibling:function(a,b){for(var d=[];a;a=a.nextSibling)a.nodeType===1&&a!==b&&d.push(a);return d}});var Ja=/ jQuery\d+="(?:\d+|null)"/g,V=/^\s+/,Ka=/(<([\w:]+)[^>]*?)\/>/g,hb=/^(?:area|br|col|embed|hr|img|input|link|meta|param)$/i,La=/<([\w:]+)/,ib=/<tbody/i,jb=/<|&#?\w+;/,ta=/<script|<object|<embed|<option|<style/i,ua=/checked\s*(?:[^=]|=\s*.checked.)/i,Ma=function(a,b,d){return hb.test(d)?
a:b+"></"+d+">"},F={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],area:[1,"<map>","</map>"],_default:[0,"",""]};F.optgroup=F.option;F.tbody=F.tfoot=F.colgroup=F.caption=F.thead;F.th=F.td;if(!c.support.htmlSerialize)F._default=[1,"div<div>","</div>"];c.fn.extend({text:function(a){if(c.isFunction(a))return this.each(function(b){var d=
c(this);d.text(a.call(this,b,d.text()))});if(typeof a!=="object"&&a!==w)return this.empty().append((this[0]&&this[0].ownerDocument||s).createTextNode(a));return c.text(this)},wrapAll:function(a){if(c.isFunction(a))return this.each(function(d){c(this).wrapAll(a.call(this,d))});if(this[0]){var b=c(a,this[0].ownerDocument).eq(0).clone(true);this[0].parentNode&&b.insertBefore(this[0]);b.map(function(){for(var d=this;d.firstChild&&d.firstChild.nodeType===1;)d=d.firstChild;return d}).append(this)}return this},
wrapInner:function(a){if(c.isFunction(a))return this.each(function(b){c(this).wrapInner(a.call(this,b))});return this.each(function(){var b=c(this),d=b.contents();d.length?d.wrapAll(a):b.append(a)})},wrap:function(a){return this.each(function(){c(this).wrapAll(a)})},unwrap:function(){return this.parent().each(function(){c.nodeName(this,"body")||c(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,true,function(a){this.nodeType===1&&this.appendChild(a)})},
prepend:function(){return this.domManip(arguments,true,function(a){this.nodeType===1&&this.insertBefore(a,this.firstChild)})},before:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,false,function(b){this.parentNode.insertBefore(b,this)});else if(arguments.length){var a=c(arguments[0]);a.push.apply(a,this.toArray());return this.pushStack(a,"before",arguments)}},after:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,false,function(b){this.parentNode.insertBefore(b,
this.nextSibling)});else if(arguments.length){var a=this.pushStack(this,"after",arguments);a.push.apply(a,c(arguments[0]).toArray());return a}},remove:function(a,b){for(var d=0,f;(f=this[d])!=null;d++)if(!a||c.filter(a,[f]).length){if(!b&&f.nodeType===1){c.cleanData(f.getElementsByTagName("*"));c.cleanData([f])}f.parentNode&&f.parentNode.removeChild(f)}return this},empty:function(){for(var a=0,b;(b=this[a])!=null;a++)for(b.nodeType===1&&c.cleanData(b.getElementsByTagName("*"));b.firstChild;)b.removeChild(b.firstChild);
return this},clone:function(a){var b=this.map(function(){if(!c.support.noCloneEvent&&!c.isXMLDoc(this)){var d=this.outerHTML,f=this.ownerDocument;if(!d){d=f.createElement("div");d.appendChild(this.cloneNode(true));d=d.innerHTML}return c.clean([d.replace(Ja,"").replace(/=([^="'>\s]+\/)>/g,'="$1">').replace(V,"")],f)[0]}else return this.cloneNode(true)});if(a===true){ra(this,b);ra(this.find("*"),b.find("*"))}return b},html:function(a){if(a===w)return this[0]&&this[0].nodeType===1?this[0].innerHTML.replace(Ja,
""):null;else if(typeof a==="string"&&!ta.test(a)&&(c.support.leadingWhitespace||!V.test(a))&&!F[(La.exec(a)||["",""])[1].toLowerCase()]){a=a.replace(Ka,Ma);try{for(var b=0,d=this.length;b<d;b++)if(this[b].nodeType===1){c.cleanData(this[b].getElementsByTagName("*"));this[b].innerHTML=a}}catch(f){this.empty().append(a)}}else c.isFunction(a)?this.each(function(e){var j=c(this),i=j.html();j.empty().append(function(){return a.call(this,e,i)})}):this.empty().append(a);return this},replaceWith:function(a){if(this[0]&&
this[0].parentNode){if(c.isFunction(a))return this.each(function(b){var d=c(this),f=d.html();d.replaceWith(a.call(this,b,f))});if(typeof a!=="string")a=c(a).detach();return this.each(function(){var b=this.nextSibling,d=this.parentNode;c(this).remove();b?c(b).before(a):c(d).append(a)})}else return this.pushStack(c(c.isFunction(a)?a():a),"replaceWith",a)},detach:function(a){return this.remove(a,true)},domManip:function(a,b,d){function f(u){return c.nodeName(u,"table")?u.getElementsByTagName("tbody")[0]||
u.appendChild(u.ownerDocument.createElement("tbody")):u}var e,j,i=a[0],o=[],k;if(!c.support.checkClone&&arguments.length===3&&typeof i==="string"&&ua.test(i))return this.each(function(){c(this).domManip(a,b,d,true)});if(c.isFunction(i))return this.each(function(u){var z=c(this);a[0]=i.call(this,u,b?z.html():w);z.domManip(a,b,d)});if(this[0]){e=i&&i.parentNode;e=c.support.parentNode&&e&&e.nodeType===11&&e.childNodes.length===this.length?{fragment:e}:sa(a,this,o);k=e.fragment;if(j=k.childNodes.length===
1?(k=k.firstChild):k.firstChild){b=b&&c.nodeName(j,"tr");for(var n=0,r=this.length;n<r;n++)d.call(b?f(this[n],j):this[n],n>0||e.cacheable||this.length>1?k.cloneNode(true):k)}o.length&&c.each(o,Qa)}return this}});c.fragments={};c.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){c.fn[a]=function(d){var f=[];d=c(d);var e=this.length===1&&this[0].parentNode;if(e&&e.nodeType===11&&e.childNodes.length===1&&d.length===1){d[b](this[0]);
return this}else{e=0;for(var j=d.length;e<j;e++){var i=(e>0?this.clone(true):this).get();c.fn[b].apply(c(d[e]),i);f=f.concat(i)}return this.pushStack(f,a,d.selector)}}});c.extend({clean:function(a,b,d,f){b=b||s;if(typeof b.createElement==="undefined")b=b.ownerDocument||b[0]&&b[0].ownerDocument||s;for(var e=[],j=0,i;(i=a[j])!=null;j++){if(typeof i==="number")i+="";if(i){if(typeof i==="string"&&!jb.test(i))i=b.createTextNode(i);else if(typeof i==="string"){i=i.replace(Ka,Ma);var o=(La.exec(i)||["",
""])[1].toLowerCase(),k=F[o]||F._default,n=k[0],r=b.createElement("div");for(r.innerHTML=k[1]+i+k[2];n--;)r=r.lastChild;if(!c.support.tbody){n=ib.test(i);o=o==="table"&&!n?r.firstChild&&r.firstChild.childNodes:k[1]==="<table>"&&!n?r.childNodes:[];for(k=o.length-1;k>=0;--k)c.nodeName(o[k],"tbody")&&!o[k].childNodes.length&&o[k].parentNode.removeChild(o[k])}!c.support.leadingWhitespace&&V.test(i)&&r.insertBefore(b.createTextNode(V.exec(i)[0]),r.firstChild);i=r.childNodes}if(i.nodeType)e.push(i);else e=
c.merge(e,i)}}if(d)for(j=0;e[j];j++)if(f&&c.nodeName(e[j],"script")&&(!e[j].type||e[j].type.toLowerCase()==="text/javascript"))f.push(e[j].parentNode?e[j].parentNode.removeChild(e[j]):e[j]);else{e[j].nodeType===1&&e.splice.apply(e,[j+1,0].concat(c.makeArray(e[j].getElementsByTagName("script"))));d.appendChild(e[j])}return e},cleanData:function(a){for(var b,d,f=c.cache,e=c.event.special,j=c.support.deleteExpando,i=0,o;(o=a[i])!=null;i++)if(d=o[c.expando]){b=f[d];if(b.events)for(var k in b.events)e[k]?
c.event.remove(o,k):Ca(o,k,b.handle);if(j)delete o[c.expando];else o.removeAttribute&&o.removeAttribute(c.expando);delete f[d]}}});var kb=/z-?index|font-?weight|opacity|zoom|line-?height/i,Na=/alpha\([^)]*\)/,Oa=/opacity=([^)]*)/,ha=/float/i,ia=/-([a-z])/ig,lb=/([A-Z])/g,mb=/^-?\d+(?:px)?$/i,nb=/^-?\d/,ob={position:"absolute",visibility:"hidden",display:"block"},pb=["Left","Right"],qb=["Top","Bottom"],rb=s.defaultView&&s.defaultView.getComputedStyle,Pa=c.support.cssFloat?"cssFloat":"styleFloat",ja=
function(a,b){return b.toUpperCase()};c.fn.css=function(a,b){return X(this,a,b,true,function(d,f,e){if(e===w)return c.curCSS(d,f);if(typeof e==="number"&&!kb.test(f))e+="px";c.style(d,f,e)})};c.extend({style:function(a,b,d){if(!a||a.nodeType===3||a.nodeType===8)return w;if((b==="width"||b==="height")&&parseFloat(d)<0)d=w;var f=a.style||a,e=d!==w;if(!c.support.opacity&&b==="opacity"){if(e){f.zoom=1;b=parseInt(d,10)+""==="NaN"?"":"alpha(opacity="+d*100+")";a=f.filter||c.curCSS(a,"filter")||"";f.filter=
Na.test(a)?a.replace(Na,b):b}return f.filter&&f.filter.indexOf("opacity=")>=0?parseFloat(Oa.exec(f.filter)[1])/100+"":""}if(ha.test(b))b=Pa;b=b.replace(ia,ja);if(e)f[b]=d;return f[b]},css:function(a,b,d,f){if(b==="width"||b==="height"){var e,j=b==="width"?pb:qb;function i(){e=b==="width"?a.offsetWidth:a.offsetHeight;f!=="border"&&c.each(j,function(){f||(e-=parseFloat(c.curCSS(a,"padding"+this,true))||0);if(f==="margin")e+=parseFloat(c.curCSS(a,"margin"+this,true))||0;else e-=parseFloat(c.curCSS(a,
"border"+this+"Width",true))||0})}a.offsetWidth!==0?i():c.swap(a,ob,i);return Math.max(0,Math.round(e))}return c.curCSS(a,b,d)},curCSS:function(a,b,d){var f,e=a.style;if(!c.support.opacity&&b==="opacity"&&a.currentStyle){f=Oa.test(a.currentStyle.filter||"")?parseFloat(RegExp.$1)/100+"":"";return f===""?"1":f}if(ha.test(b))b=Pa;if(!d&&e&&e[b])f=e[b];else if(rb){if(ha.test(b))b="float";b=b.replace(lb,"-$1").toLowerCase();e=a.ownerDocument.defaultView;if(!e)return null;if(a=e.getComputedStyle(a,null))f=
a.getPropertyValue(b);if(b==="opacity"&&f==="")f="1"}else if(a.currentStyle){d=b.replace(ia,ja);f=a.currentStyle[b]||a.currentStyle[d];if(!mb.test(f)&&nb.test(f)){b=e.left;var j=a.runtimeStyle.left;a.runtimeStyle.left=a.currentStyle.left;e.left=d==="fontSize"?"1em":f||0;f=e.pixelLeft+"px";e.left=b;a.runtimeStyle.left=j}}return f},swap:function(a,b,d){var f={};for(var e in b){f[e]=a.style[e];a.style[e]=b[e]}d.call(a);for(e in b)a.style[e]=f[e]}});if(c.expr&&c.expr.filters){c.expr.filters.hidden=function(a){var b=
a.offsetWidth,d=a.offsetHeight,f=a.nodeName.toLowerCase()==="tr";return b===0&&d===0&&!f?true:b>0&&d>0&&!f?false:c.curCSS(a,"display")==="none"};c.expr.filters.visible=function(a){return!c.expr.filters.hidden(a)}}var sb=J(),tb=/<script(.|\s)*?\/script>/gi,ub=/select|textarea/i,vb=/color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week/i,N=/=\?(&|$)/,ka=/\?/,wb=/(\?|&)_=.*?(&|$)/,xb=/^(\w+:)?\/\/([^\/?#]+)/,yb=/%20/g,zb=c.fn.load;c.fn.extend({load:function(a,b,d){if(typeof a!==
"string")return zb.call(this,a);else if(!this.length)return this;var f=a.indexOf(" ");if(f>=0){var e=a.slice(f,a.length);a=a.slice(0,f)}f="GET";if(b)if(c.isFunction(b)){d=b;b=null}else if(typeof b==="object"){b=c.param(b,c.ajaxSettings.traditional);f="POST"}var j=this;c.ajax({url:a,type:f,dataType:"html",data:b,complete:function(i,o){if(o==="success"||o==="notmodified")j.html(e?c("<div />").append(i.responseText.replace(tb,"")).find(e):i.responseText);d&&j.each(d,[i.responseText,o,i])}});return this},
serialize:function(){return c.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?c.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||ub.test(this.nodeName)||vb.test(this.type))}).map(function(a,b){a=c(this).val();return a==null?null:c.isArray(a)?c.map(a,function(d){return{name:b.name,value:d}}):{name:b.name,value:a}}).get()}});c.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),
function(a,b){c.fn[b]=function(d){return this.bind(b,d)}});c.extend({get:function(a,b,d,f){if(c.isFunction(b)){f=f||d;d=b;b=null}return c.ajax({type:"GET",url:a,data:b,success:d,dataType:f})},getScript:function(a,b){return c.get(a,null,b,"script")},getJSON:function(a,b,d){return c.get(a,b,d,"json")},post:function(a,b,d,f){if(c.isFunction(b)){f=f||d;d=b;b={}}return c.ajax({type:"POST",url:a,data:b,success:d,dataType:f})},ajaxSetup:function(a){c.extend(c.ajaxSettings,a)},ajaxSettings:{url:location.href,
global:true,type:"GET",contentType:"application/x-www-form-urlencoded",processData:true,async:true,xhr:A.XMLHttpRequest&&(A.location.protocol!=="file:"||!A.ActiveXObject)?function(){return new A.XMLHttpRequest}:function(){try{return new A.ActiveXObject("Microsoft.XMLHTTP")}catch(a){}},accepts:{xml:"application/xml, text/xml",html:"text/html",script:"text/javascript, application/javascript",json:"application/json, text/javascript",text:"text/plain",_default:"*/*"}},lastModified:{},etag:{},ajax:function(a){function b(){e.success&&
e.success.call(k,o,i,x);e.global&&f("ajaxSuccess",[x,e])}function d(){e.complete&&e.complete.call(k,x,i);e.global&&f("ajaxComplete",[x,e]);e.global&&!--c.active&&c.event.trigger("ajaxStop")}function f(q,p){(e.context?c(e.context):c.event).trigger(q,p)}var e=c.extend(true,{},c.ajaxSettings,a),j,i,o,k=a&&a.context||e,n=e.type.toUpperCase();if(e.data&&e.processData&&typeof e.data!=="string")e.data=c.param(e.data,e.traditional);if(e.dataType==="jsonp"){if(n==="GET")N.test(e.url)||(e.url+=(ka.test(e.url)?
"&":"?")+(e.jsonp||"callback")+"=?");else if(!e.data||!N.test(e.data))e.data=(e.data?e.data+"&":"")+(e.jsonp||"callback")+"=?";e.dataType="json"}if(e.dataType==="json"&&(e.data&&N.test(e.data)||N.test(e.url))){j=e.jsonpCallback||"jsonp"+sb++;if(e.data)e.data=(e.data+"").replace(N,"="+j+"$1");e.url=e.url.replace(N,"="+j+"$1");e.dataType="script";A[j]=A[j]||function(q){o=q;b();d();A[j]=w;try{delete A[j]}catch(p){}z&&z.removeChild(C)}}if(e.dataType==="script"&&e.cache===null)e.cache=false;if(e.cache===
false&&n==="GET"){var r=J(),u=e.url.replace(wb,"$1_="+r+"$2");e.url=u+(u===e.url?(ka.test(e.url)?"&":"?")+"_="+r:"")}if(e.data&&n==="GET")e.url+=(ka.test(e.url)?"&":"?")+e.data;e.global&&!c.active++&&c.event.trigger("ajaxStart");r=(r=xb.exec(e.url))&&(r[1]&&r[1]!==location.protocol||r[2]!==location.host);if(e.dataType==="script"&&n==="GET"&&r){var z=s.getElementsByTagName("head")[0]||s.documentElement,C=s.createElement("script");C.src=e.url;if(e.scriptCharset)C.charset=e.scriptCharset;if(!j){var B=
false;C.onload=C.onreadystatechange=function(){if(!B&&(!this.readyState||this.readyState==="loaded"||this.readyState==="complete")){B=true;b();d();C.onload=C.onreadystatechange=null;z&&C.parentNode&&z.removeChild(C)}}}z.insertBefore(C,z.firstChild);return w}var E=false,x=e.xhr();if(x){e.username?x.open(n,e.url,e.async,e.username,e.password):x.open(n,e.url,e.async);try{if(e.data||a&&a.contentType)x.setRequestHeader("Content-Type",e.contentType);if(e.ifModified){c.lastModified[e.url]&&x.setRequestHeader("If-Modified-Since",
c.lastModified[e.url]);c.etag[e.url]&&x.setRequestHeader("If-None-Match",c.etag[e.url])}r||x.setRequestHeader("X-Requested-With","XMLHttpRequest");x.setRequestHeader("Accept",e.dataType&&e.accepts[e.dataType]?e.accepts[e.dataType]+", */*":e.accepts._default)}catch(ga){}if(e.beforeSend&&e.beforeSend.call(k,x,e)===false){e.global&&!--c.active&&c.event.trigger("ajaxStop");x.abort();return false}e.global&&f("ajaxSend",[x,e]);var g=x.onreadystatechange=function(q){if(!x||x.readyState===0||q==="abort"){E||
d();E=true;if(x)x.onreadystatechange=c.noop}else if(!E&&x&&(x.readyState===4||q==="timeout")){E=true;x.onreadystatechange=c.noop;i=q==="timeout"?"timeout":!c.httpSuccess(x)?"error":e.ifModified&&c.httpNotModified(x,e.url)?"notmodified":"success";var p;if(i==="success")try{o=c.httpData(x,e.dataType,e)}catch(v){i="parsererror";p=v}if(i==="success"||i==="notmodified")j||b();else c.handleError(e,x,i,p);d();q==="timeout"&&x.abort();if(e.async)x=null}};try{var h=x.abort;x.abort=function(){x&&h.call(x);
g("abort")}}catch(l){}e.async&&e.timeout>0&&setTimeout(function(){x&&!E&&g("timeout")},e.timeout);try{x.send(n==="POST"||n==="PUT"||n==="DELETE"?e.data:null)}catch(m){c.handleError(e,x,null,m);d()}e.async||g();return x}},handleError:function(a,b,d,f){if(a.error)a.error.call(a.context||a,b,d,f);if(a.global)(a.context?c(a.context):c.event).trigger("ajaxError",[b,a,f])},active:0,httpSuccess:function(a){try{return!a.status&&location.protocol==="file:"||a.status>=200&&a.status<300||a.status===304||a.status===
1223||a.status===0}catch(b){}return false},httpNotModified:function(a,b){var d=a.getResponseHeader("Last-Modified"),f=a.getResponseHeader("Etag");if(d)c.lastModified[b]=d;if(f)c.etag[b]=f;return a.status===304||a.status===0},httpData:function(a,b,d){var f=a.getResponseHeader("content-type")||"",e=b==="xml"||!b&&f.indexOf("xml")>=0;a=e?a.responseXML:a.responseText;e&&a.documentElement.nodeName==="parsererror"&&c.error("parsererror");if(d&&d.dataFilter)a=d.dataFilter(a,b);if(typeof a==="string")if(b===
"json"||!b&&f.indexOf("json")>=0)a=c.parseJSON(a);else if(b==="script"||!b&&f.indexOf("javascript")>=0)c.globalEval(a);return a},param:function(a,b){function d(i,o){if(c.isArray(o))c.each(o,function(k,n){b||/\[\]$/.test(i)?f(i,n):d(i+"["+(typeof n==="object"||c.isArray(n)?k:"")+"]",n)});else!b&&o!=null&&typeof o==="object"?c.each(o,function(k,n){d(i+"["+k+"]",n)}):f(i,o)}function f(i,o){o=c.isFunction(o)?o():o;e[e.length]=encodeURIComponent(i)+"="+encodeURIComponent(o)}var e=[];if(b===w)b=c.ajaxSettings.traditional;
if(c.isArray(a)||a.jquery)c.each(a,function(){f(this.name,this.value)});else for(var j in a)d(j,a[j]);return e.join("&").replace(yb,"+")}});var la={},Ab=/toggle|show|hide/,Bb=/^([+-]=)?([\d+-.]+)(.*)$/,W,va=[["height","marginTop","marginBottom","paddingTop","paddingBottom"],["width","marginLeft","marginRight","paddingLeft","paddingRight"],["opacity"]];c.fn.extend({show:function(a,b){if(a||a===0)return this.animate(K("show",3),a,b);else{a=0;for(b=this.length;a<b;a++){var d=c.data(this[a],"olddisplay");
this[a].style.display=d||"";if(c.css(this[a],"display")==="none"){d=this[a].nodeName;var f;if(la[d])f=la[d];else{var e=c("<"+d+" />").appendTo("body");f=e.css("display");if(f==="none")f="block";e.remove();la[d]=f}c.data(this[a],"olddisplay",f)}}a=0;for(b=this.length;a<b;a++)this[a].style.display=c.data(this[a],"olddisplay")||"";return this}},hide:function(a,b){if(a||a===0)return this.animate(K("hide",3),a,b);else{a=0;for(b=this.length;a<b;a++){var d=c.data(this[a],"olddisplay");!d&&d!=="none"&&c.data(this[a],
"olddisplay",c.css(this[a],"display"))}a=0;for(b=this.length;a<b;a++)this[a].style.display="none";return this}},_toggle:c.fn.toggle,toggle:function(a,b){var d=typeof a==="boolean";if(c.isFunction(a)&&c.isFunction(b))this._toggle.apply(this,arguments);else a==null||d?this.each(function(){var f=d?a:c(this).is(":hidden");c(this)[f?"show":"hide"]()}):this.animate(K("toggle",3),a,b);return this},fadeTo:function(a,b,d){return this.filter(":hidden").css("opacity",0).show().end().animate({opacity:b},a,d)},
animate:function(a,b,d,f){var e=c.speed(b,d,f);if(c.isEmptyObject(a))return this.each(e.complete);return this[e.queue===false?"each":"queue"](function(){var j=c.extend({},e),i,o=this.nodeType===1&&c(this).is(":hidden"),k=this;for(i in a){var n=i.replace(ia,ja);if(i!==n){a[n]=a[i];delete a[i];i=n}if(a[i]==="hide"&&o||a[i]==="show"&&!o)return j.complete.call(this);if((i==="height"||i==="width")&&this.style){j.display=c.css(this,"display");j.overflow=this.style.overflow}if(c.isArray(a[i])){(j.specialEasing=
j.specialEasing||{})[i]=a[i][1];a[i]=a[i][0]}}if(j.overflow!=null)this.style.overflow="hidden";j.curAnim=c.extend({},a);c.each(a,function(r,u){var z=new c.fx(k,j,r);if(Ab.test(u))z[u==="toggle"?o?"show":"hide":u](a);else{var C=Bb.exec(u),B=z.cur(true)||0;if(C){u=parseFloat(C[2]);var E=C[3]||"px";if(E!=="px"){k.style[r]=(u||1)+E;B=(u||1)/z.cur(true)*B;k.style[r]=B+E}if(C[1])u=(C[1]==="-="?-1:1)*u+B;z.custom(B,u,E)}else z.custom(B,u,"")}});return true})},stop:function(a,b){var d=c.timers;a&&this.queue([]);
this.each(function(){for(var f=d.length-1;f>=0;f--)if(d[f].elem===this){b&&d[f](true);d.splice(f,1)}});b||this.dequeue();return this}});c.each({slideDown:K("show",1),slideUp:K("hide",1),slideToggle:K("toggle",1),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"}},function(a,b){c.fn[a]=function(d,f){return this.animate(b,d,f)}});c.extend({speed:function(a,b,d){var f=a&&typeof a==="object"?a:{complete:d||!d&&b||c.isFunction(a)&&a,duration:a,easing:d&&b||b&&!c.isFunction(b)&&b};f.duration=c.fx.off?0:typeof f.duration===
"number"?f.duration:c.fx.speeds[f.duration]||c.fx.speeds._default;f.old=f.complete;f.complete=function(){f.queue!==false&&c(this).dequeue();c.isFunction(f.old)&&f.old.call(this)};return f},easing:{linear:function(a,b,d,f){return d+f*a},swing:function(a,b,d,f){return(-Math.cos(a*Math.PI)/2+0.5)*f+d}},timers:[],fx:function(a,b,d){this.options=b;this.elem=a;this.prop=d;if(!b.orig)b.orig={}}});c.fx.prototype={update:function(){this.options.step&&this.options.step.call(this.elem,this.now,this);(c.fx.step[this.prop]||
c.fx.step._default)(this);if((this.prop==="height"||this.prop==="width")&&this.elem.style)this.elem.style.display="block"},cur:function(a){if(this.elem[this.prop]!=null&&(!this.elem.style||this.elem.style[this.prop]==null))return this.elem[this.prop];return(a=parseFloat(c.css(this.elem,this.prop,a)))&&a>-10000?a:parseFloat(c.curCSS(this.elem,this.prop))||0},custom:function(a,b,d){function f(j){return e.step(j)}this.startTime=J();this.start=a;this.end=b;this.unit=d||this.unit||"px";this.now=this.start;
this.pos=this.state=0;var e=this;f.elem=this.elem;if(f()&&c.timers.push(f)&&!W)W=setInterval(c.fx.tick,13)},show:function(){this.options.orig[this.prop]=c.style(this.elem,this.prop);this.options.show=true;this.custom(this.prop==="width"||this.prop==="height"?1:0,this.cur());c(this.elem).show()},hide:function(){this.options.orig[this.prop]=c.style(this.elem,this.prop);this.options.hide=true;this.custom(this.cur(),0)},step:function(a){var b=J(),d=true;if(a||b>=this.options.duration+this.startTime){this.now=
this.end;this.pos=this.state=1;this.update();this.options.curAnim[this.prop]=true;for(var f in this.options.curAnim)if(this.options.curAnim[f]!==true)d=false;if(d){if(this.options.display!=null){this.elem.style.overflow=this.options.overflow;a=c.data(this.elem,"olddisplay");this.elem.style.display=a?a:this.options.display;if(c.css(this.elem,"display")==="none")this.elem.style.display="block"}this.options.hide&&c(this.elem).hide();if(this.options.hide||this.options.show)for(var e in this.options.curAnim)c.style(this.elem,
e,this.options.orig[e]);this.options.complete.call(this.elem)}return false}else{e=b-this.startTime;this.state=e/this.options.duration;a=this.options.easing||(c.easing.swing?"swing":"linear");this.pos=c.easing[this.options.specialEasing&&this.options.specialEasing[this.prop]||a](this.state,e,0,1,this.options.duration);this.now=this.start+(this.end-this.start)*this.pos;this.update()}return true}};c.extend(c.fx,{tick:function(){for(var a=c.timers,b=0;b<a.length;b++)a[b]()||a.splice(b--,1);a.length||
c.fx.stop()},stop:function(){clearInterval(W);W=null},speeds:{slow:600,fast:200,_default:400},step:{opacity:function(a){c.style(a.elem,"opacity",a.now)},_default:function(a){if(a.elem.style&&a.elem.style[a.prop]!=null)a.elem.style[a.prop]=(a.prop==="width"||a.prop==="height"?Math.max(0,a.now):a.now)+a.unit;else a.elem[a.prop]=a.now}}});if(c.expr&&c.expr.filters)c.expr.filters.animated=function(a){return c.grep(c.timers,function(b){return a===b.elem}).length};c.fn.offset="getBoundingClientRect"in s.documentElement?
function(a){var b=this[0];if(a)return this.each(function(e){c.offset.setOffset(this,a,e)});if(!b||!b.ownerDocument)return null;if(b===b.ownerDocument.body)return c.offset.bodyOffset(b);var d=b.getBoundingClientRect(),f=b.ownerDocument;b=f.body;f=f.documentElement;return{top:d.top+(self.pageYOffset||c.support.boxModel&&f.scrollTop||b.scrollTop)-(f.clientTop||b.clientTop||0),left:d.left+(self.pageXOffset||c.support.boxModel&&f.scrollLeft||b.scrollLeft)-(f.clientLeft||b.clientLeft||0)}}:function(a){var b=
this[0];if(a)return this.each(function(r){c.offset.setOffset(this,a,r)});if(!b||!b.ownerDocument)return null;if(b===b.ownerDocument.body)return c.offset.bodyOffset(b);c.offset.initialize();var d=b.offsetParent,f=b,e=b.ownerDocument,j,i=e.documentElement,o=e.body;f=(e=e.defaultView)?e.getComputedStyle(b,null):b.currentStyle;for(var k=b.offsetTop,n=b.offsetLeft;(b=b.parentNode)&&b!==o&&b!==i;){if(c.offset.supportsFixedPosition&&f.position==="fixed")break;j=e?e.getComputedStyle(b,null):b.currentStyle;
k-=b.scrollTop;n-=b.scrollLeft;if(b===d){k+=b.offsetTop;n+=b.offsetLeft;if(c.offset.doesNotAddBorder&&!(c.offset.doesAddBorderForTableAndCells&&/^t(able|d|h)$/i.test(b.nodeName))){k+=parseFloat(j.borderTopWidth)||0;n+=parseFloat(j.borderLeftWidth)||0}f=d;d=b.offsetParent}if(c.offset.subtractsBorderForOverflowNotVisible&&j.overflow!=="visible"){k+=parseFloat(j.borderTopWidth)||0;n+=parseFloat(j.borderLeftWidth)||0}f=j}if(f.position==="relative"||f.position==="static"){k+=o.offsetTop;n+=o.offsetLeft}if(c.offset.supportsFixedPosition&&
f.position==="fixed"){k+=Math.max(i.scrollTop,o.scrollTop);n+=Math.max(i.scrollLeft,o.scrollLeft)}return{top:k,left:n}};c.offset={initialize:function(){var a=s.body,b=s.createElement("div"),d,f,e,j=parseFloat(c.curCSS(a,"marginTop",true))||0;c.extend(b.style,{position:"absolute",top:0,left:0,margin:0,border:0,width:"1px",height:"1px",visibility:"hidden"});b.innerHTML="<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
a.insertBefore(b,a.firstChild);d=b.firstChild;f=d.firstChild;e=d.nextSibling.firstChild.firstChild;this.doesNotAddBorder=f.offsetTop!==5;this.doesAddBorderForTableAndCells=e.offsetTop===5;f.style.position="fixed";f.style.top="20px";this.supportsFixedPosition=f.offsetTop===20||f.offsetTop===15;f.style.position=f.style.top="";d.style.overflow="hidden";d.style.position="relative";this.subtractsBorderForOverflowNotVisible=f.offsetTop===-5;this.doesNotIncludeMarginInBodyOffset=a.offsetTop!==j;a.removeChild(b);
c.offset.initialize=c.noop},bodyOffset:function(a){var b=a.offsetTop,d=a.offsetLeft;c.offset.initialize();if(c.offset.doesNotIncludeMarginInBodyOffset){b+=parseFloat(c.curCSS(a,"marginTop",true))||0;d+=parseFloat(c.curCSS(a,"marginLeft",true))||0}return{top:b,left:d}},setOffset:function(a,b,d){if(/static/.test(c.curCSS(a,"position")))a.style.position="relative";var f=c(a),e=f.offset(),j=parseInt(c.curCSS(a,"top",true),10)||0,i=parseInt(c.curCSS(a,"left",true),10)||0;if(c.isFunction(b))b=b.call(a,
d,e);d={top:b.top-e.top+j,left:b.left-e.left+i};"using"in b?b.using.call(a,d):f.css(d)}};c.fn.extend({position:function(){if(!this[0])return null;var a=this[0],b=this.offsetParent(),d=this.offset(),f=/^body|html$/i.test(b[0].nodeName)?{top:0,left:0}:b.offset();d.top-=parseFloat(c.curCSS(a,"marginTop",true))||0;d.left-=parseFloat(c.curCSS(a,"marginLeft",true))||0;f.top+=parseFloat(c.curCSS(b[0],"borderTopWidth",true))||0;f.left+=parseFloat(c.curCSS(b[0],"borderLeftWidth",true))||0;return{top:d.top-
f.top,left:d.left-f.left}},offsetParent:function(){return this.map(function(){for(var a=this.offsetParent||s.body;a&&!/^body|html$/i.test(a.nodeName)&&c.css(a,"position")==="static";)a=a.offsetParent;return a})}});c.each(["Left","Top"],function(a,b){var d="scroll"+b;c.fn[d]=function(f){var e=this[0],j;if(!e)return null;if(f!==w)return this.each(function(){if(j=wa(this))j.scrollTo(!a?f:c(j).scrollLeft(),a?f:c(j).scrollTop());else this[d]=f});else return(j=wa(e))?"pageXOffset"in j?j[a?"pageYOffset":
"pageXOffset"]:c.support.boxModel&&j.document.documentElement[d]||j.document.body[d]:e[d]}});c.each(["Height","Width"],function(a,b){var d=b.toLowerCase();c.fn["inner"+b]=function(){return this[0]?c.css(this[0],d,false,"padding"):null};c.fn["outer"+b]=function(f){return this[0]?c.css(this[0],d,false,f?"margin":"border"):null};c.fn[d]=function(f){var e=this[0];if(!e)return f==null?null:this;if(c.isFunction(f))return this.each(function(j){var i=c(this);i[d](f.call(this,j,i[d]()))});return"scrollTo"in
e&&e.document?e.document.compatMode==="CSS1Compat"&&e.document.documentElement["client"+b]||e.document.body["client"+b]:e.nodeType===9?Math.max(e.documentElement["client"+b],e.body["scroll"+b],e.documentElement["scroll"+b],e.body["offset"+b],e.documentElement["offset"+b]):f===w?c.css(e,d):this.css(d,typeof f==="string"?f:f+"px")}});A.jQuery=A.$=c})(window);jQuery.noConflict();


]]></data>
	</file>
	<file>
	  <filename>/includes/jquery.tablednd.js</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[/**
 * TableDnD plug-in for JQuery, allows you to drag and drop table rows
 * You can set up various options to control how the system will work
 * Copyright (c) Denis Howlett <denish@isocra.com>
 * Licensed like jQuery, see http://docs.jquery.com/License.
 *
 * Configuration options:
 * 
 * onDragStyle
 *     This is the style that is assigned to the row during drag. There are limitations to the styles that can be
 *     associated with a row (such as you can't assign a border--well you can, but it won't be
 *     displayed). (So instead consider using onDragClass.) The CSS style to apply is specified as
 *     a map (as used in the jQuery css(...) function).
 * onDropStyle
 *     This is the style that is assigned to the row when it is dropped. As for onDragStyle, there are limitations
 *     to what you can do. Also this replaces the original style, so again consider using onDragClass which
 *     is simply added and then removed on drop.
 * onDragClass
 *     This class is added for the duration of the drag and then removed when the row is dropped. It is more
 *     flexible than using onDragStyle since it can be inherited by the row cells and other content. The default
 *     is class is tDnD_whileDrag. So to use the default, simply customise this CSS class in your
 *     stylesheet.
 * onDrop
 *     Pass a function that will be called when the row is dropped. The function takes 2 parameters: the table
 *     and the row that was dropped. You can work out the new order of the rows by using
 *     table.rows.
 * onDragStart
 *     Pass a function that will be called when the user starts dragging. The function takes 2 parameters: the
 *     table and the row which the user has started to drag.
 * onAllowDrop
 *     Pass a function that will be called as a row is over another row. If the function returns true, allow 
 *     dropping on that row, otherwise not. The function takes 2 parameters: the dragged row and the row under
 *     the cursor. It returns a boolean: true allows the drop, false doesn't allow it.
 * scrollAmount
 *     This is the number of pixels to scroll if the user moves the mouse cursor to the top or bottom of the
 *     window. The page should automatically scroll up or down as appropriate (tested in IE6, IE7, Safari, FF2,
 *     FF3 beta
 * dragHandle
 *     This is the name of a class that you assign to one or more cells in each row that is draggable. If you
 *     specify this class, then you are responsible for setting cursor: move in the CSS and only these cells
 *     will have the drag behaviour. If you do not specify a dragHandle, then you get the old behaviour where
 *     the whole row is draggable.
 * 
 * Other ways to control behaviour:
 *
 * Add class="nodrop" to any rows for which you don't want to allow dropping, and class="nodrag" to any rows
 * that you don't want to be draggable.
 *
 * Inside the onDrop method you can also call $.tableDnD.serialize() this returns a string of the form
 * <tableID>[]=<rowID1>&<tableID>[]=<rowID2> so that you can send this back to the server. The table must have
 * an ID as must all the rows.
 *
 * Other methods:
 *
 * $("...").tableDnDUpdate() 
 * Will update all the matching tables, that is it will reapply the mousedown method to the rows (or handle cells).
 * This is useful if you have updated the table rows using Ajax and you want to make the table draggable again.
 * The table maintains the original configuration (so you don't have to specify it again).
 *
 * $("...").tableDnDSerialize()
 * Will serialize and return the serialized string as above, but for each of the matching tables--so it can be
 * called from anywhere and isn't dependent on the currentTable being set up correctly before calling
 *
 * Known problems:
 * - Auto-scoll has some problems with IE7  (it scrolls even when it shouldn't), work-around: set scrollAmount to 0
 * 
 * Version 0.2: 2008-02-20 First public version
 * Version 0.3: 2008-02-07 Added onDragStart option
 *                         Made the scroll amount configurable (default is 5 as before)
 * Version 0.4: 2008-03-15 Changed the noDrag/noDrop attributes to nodrag/nodrop classes
 *                         Added onAllowDrop to control dropping
 *                         Fixed a bug which meant that you couldn't set the scroll amount in both directions
 *                         Added serialize method
 * Version 0.5: 2008-05-16 Changed so that if you specify a dragHandle class it doesn't make the whole row
 *                         draggable
 *                         Improved the serialize method to use a default (and settable) regular expression.
 *                         Added tableDnDupate() and tableDnDSerialize() to be called when you are outside the table
 */
jQuery.tableDnD = {
    /** Keep hold of the current table being dragged */
    currentTable : null,
    /** Keep hold of the current drag object if any */
    dragObject: null,
    /** The current mouse offset */
    mouseOffset: null,
    /** Remember the old value of Y so that we don't do too much processing */
    oldY: 0,

    /** Actually build the structure */
    build: function(options) {
        // Set up the defaults if any

        this.each(function() {
            // This is bound to each matching table, set up the defaults and override with user options
            this.tableDnDConfig = jQuery.extend({
                onDragStyle: null,
                onDropStyle: null,
				// Add in the default class for whileDragging
				onDragClass: "tDnD_whileDrag",
                onDrop: null,
                onDragStart: null,
                scrollAmount: 5,
				serializeRegexp: /[^\-]*$/, // The regular expression to use to trim row IDs
				serializeParamName: null, // If you want to specify another parameter name instead of the table ID
                dragHandle: null // If you give the name of a class here, then only Cells with this class will be draggable
            }, options || {});
            // Now make the rows draggable
            jQuery.tableDnD.makeDraggable(this);
        });

        // Now we need to capture the mouse up and mouse move event
        // We can use bind so that we don't interfere with other event handlers
        jQuery(document)
            .bind('mousemove', jQuery.tableDnD.mousemove)
            .bind('mouseup', jQuery.tableDnD.mouseup);

        // Don't break the chain
        return this;
    },

    /** This function makes all the rows on the table draggable apart from those marked as "NoDrag" */
    makeDraggable: function(table) {
        var config = table.tableDnDConfig;
		if (table.tableDnDConfig.dragHandle) {
			// We only need to add the event to the specified cells
			var cells = jQuery("td."+table.tableDnDConfig.dragHandle, table);
			cells.each(function() {
				// The cell is bound to "this"
                jQuery(this).mousedown(function(ev) {
                    jQuery.tableDnD.dragObject = this.parentNode;
                    jQuery.tableDnD.currentTable = table;
                    jQuery.tableDnD.mouseOffset = jQuery.tableDnD.getMouseOffset(this, ev);
                    if (config.onDragStart) {
                        // Call the onDrop method if there is one
                        config.onDragStart(table, this);
                    }
                    return false;
                });
			})
		} else {
			// For backwards compatibility, we add the event to the whole row
	        var rows = jQuery("tr", table); // get all the rows as a wrapped set
	        rows.each(function() {
				// Iterate through each row, the row is bound to "this"
				var row = jQuery(this);
				if (! row.hasClass("nodrag")) {
	                row.mousedown(function(ev) {
	                    if (ev.target.tagName == "TD") {
	                        jQuery.tableDnD.dragObject = this;
	                        jQuery.tableDnD.currentTable = table;
	                        jQuery.tableDnD.mouseOffset = jQuery.tableDnD.getMouseOffset(this, ev);
	                        if (config.onDragStart) {
	                            // Call the onDrop method if there is one
	                            config.onDragStart(table, this);
	                        }
	                        return false;
	                    }
	                }).css("cursor", "move"); // Store the tableDnD object
				}
			});
		}
	},

	updateTables: function() {
		this.each(function() {
			// this is now bound to each matching table
			if (this.tableDnDConfig) {
				jQuery.tableDnD.makeDraggable(this);
			}
		})
	},

    /** Get the mouse coordinates from the event (allowing for browser differences) */
    mouseCoords: function(ev){
        if(ev.pageX || ev.pageY){
            return {x:ev.pageX, y:ev.pageY};
        }
        return {
            x:ev.clientX + document.body.scrollLeft - document.body.clientLeft,
            y:ev.clientY + document.body.scrollTop  - document.body.clientTop
        };
    },

    /** Given a target element and a mouse event, get the mouse offset from that element.
        To do this we need the element's position and the mouse position */
    getMouseOffset: function(target, ev) {
        ev = ev || window.event;

        var docPos    = this.getPosition(target);
        var mousePos  = this.mouseCoords(ev);
        return {x:mousePos.x - docPos.x, y:mousePos.y - docPos.y};
    },

    /** Get the position of an element by going up the DOM tree and adding up all the offsets */
    getPosition: function(e){
        var left = 0;
        var top  = 0;
        /** Safari fix -- thanks to Luis Chato for this! */
        if (e.offsetHeight == 0) {
            /** Safari 2 doesn't correctly grab the offsetTop of a table row
            this is detailed here:
            http://jacob.peargrove.com/blog/2006/technical/table-row-offsettop-bug-in-safari/
            the solution is likewise noted there, grab the offset of a table cell in the row - the firstChild.
            note that firefox will return a text node as a first child, so designing a more thorough
            solution may need to take that into account, for now this seems to work in firefox, safari, ie */
            e = e.firstChild; // a table cell
        }
		if (e && e.offsetParent) {
        	while (e.offsetParent){
            	left += e.offsetLeft;
            	top  += e.offsetTop;
            	e     = e.offsetParent;
        	}

        	left += e.offsetLeft;
        	top  += e.offsetTop;
        }

        return {x:left, y:top};
    },

    mousemove: function(ev) {
        if (jQuery.tableDnD.dragObject == null) {
            return;
        }

        var dragObj = jQuery(jQuery.tableDnD.dragObject);
        var config = jQuery.tableDnD.currentTable.tableDnDConfig;
        var mousePos = jQuery.tableDnD.mouseCoords(ev);
        var y = mousePos.y - jQuery.tableDnD.mouseOffset.y;
        //auto scroll the window
	    var yOffset = window.pageYOffset;
	 	if (document.all) {
	        // Windows version
	        //yOffset=document.body.scrollTop;
	        if (typeof document.compatMode != 'undefined' &&
	             document.compatMode != 'BackCompat') {
	           yOffset = document.documentElement.scrollTop;
	        }
	        else if (typeof document.body != 'undefined') {
	           yOffset=document.body.scrollTop;
	        }

	    }
		    
		if (mousePos.y-yOffset < config.scrollAmount) {
	    	window.scrollBy(0, -config.scrollAmount);
	    } else {
            var windowHeight = window.innerHeight ? window.innerHeight
                    : document.documentElement.clientHeight ? document.documentElement.clientHeight : document.body.clientHeight;
            if (windowHeight-(mousePos.y-yOffset) < config.scrollAmount) {
                window.scrollBy(0, config.scrollAmount);
            }
        }


        if (y != jQuery.tableDnD.oldY) {
            // work out if we're going up or down...
            var movingDown = y > jQuery.tableDnD.oldY;
            // update the old value
            jQuery.tableDnD.oldY = y;
            // update the style to show we're dragging
			if (config.onDragClass) {
				dragObj.addClass(config.onDragClass);
			} else {
	            dragObj.css(config.onDragStyle);
			}
            // If we're over a row then move the dragged row to there so that the user sees the
            // effect dynamically
            var currentRow = jQuery.tableDnD.findDropTargetRow(dragObj, y);
            if (currentRow) {
                // TODO worry about what happens when there are multiple TBODIES
                if (movingDown && jQuery.tableDnD.dragObject != currentRow) {
                    jQuery.tableDnD.dragObject.parentNode.insertBefore(jQuery.tableDnD.dragObject, currentRow.nextSibling);
                } else if (! movingDown && jQuery.tableDnD.dragObject != currentRow) {
                    jQuery.tableDnD.dragObject.parentNode.insertBefore(jQuery.tableDnD.dragObject, currentRow);
                }
            }
        }

        return false;
    },

    /** We're only worried about the y position really, because we can only move rows up and down */
    findDropTargetRow: function(draggedRow, y) {
        var rows = jQuery.tableDnD.currentTable.rows;
        for (var i=0; i<rows.length; i++) {
            var row = rows[i];
            var rowY    = this.getPosition(row).y;
            var rowHeight = parseInt(row.offsetHeight)/2;
            if (row.offsetHeight == 0) {
                rowY = this.getPosition(row.firstChild).y;
                rowHeight = parseInt(row.firstChild.offsetHeight)/2;
            }
            // Because we always have to insert before, we need to offset the height a bit
            if ((y > rowY - rowHeight) && (y < (rowY + rowHeight))) {
                // that's the row we're over
				// If it's the same as the current row, ignore it
				if (row == draggedRow) {return null;}
                var config = jQuery.tableDnD.currentTable.tableDnDConfig;
                if (config.onAllowDrop) {
                    if (config.onAllowDrop(draggedRow, row)) {
                        return row;
                    } else {
                        return null;
                    }
                } else {
					// If a row has nodrop class, then don't allow dropping (inspired by John Tarr and Famic)
                    var nodrop = jQuery(row).hasClass("nodrop");
                    if (! nodrop) {
                        return row;
                    } else {
                        return null;
                    }
                }
                return row;
            }
        }
        return null;
    },

    mouseup: function(e) {
        if (jQuery.tableDnD.currentTable && jQuery.tableDnD.dragObject) {
            var droppedRow = jQuery.tableDnD.dragObject;
            var config = jQuery.tableDnD.currentTable.tableDnDConfig;
            // If we have a dragObject, then we need to release it,
            // The row will already have been moved to the right place so we just reset stuff
			if (config.onDragClass) {
	            jQuery(droppedRow).removeClass(config.onDragClass);
			} else {
	            jQuery(droppedRow).css(config.onDropStyle);
			}
            jQuery.tableDnD.dragObject   = null;
            if (config.onDrop) {
                // Call the onDrop method if there is one
                config.onDrop(jQuery.tableDnD.currentTable, droppedRow);
            }
            jQuery.tableDnD.currentTable = null; // let go of the table too
        }
    },

    serialize: function() {
        if (jQuery.tableDnD.currentTable) {
            return jQuery.tableDnD.serializeTable(jQuery.tableDnD.currentTable);
        } else {
            return "Error: No Table id set, you need to set an id on your table and every row";
        }
    },

	serializeTable: function(table) {
        var result = "";
        var tableId = table.id;
        var rows = table.rows;
        for (var i=0; i<rows.length; i++) {
            if (result.length > 0) result += "&";
            var rowId = rows[i].id;
            if (rowId && rowId && table.tableDnDConfig && table.tableDnDConfig.serializeRegexp) {
                rowId = rowId.match(table.tableDnDConfig.serializeRegexp)[0];
            }

            result += tableId + '[]=' + rowId;
        }
        return result;
	},

	serializeTables: function() {
        var result = "";
        this.each(function() {
			// this is now bound to each matching table
			result += jQuery.tableDnD.serializeTable(this);
		});
        return result;
    }

}

jQuery.fn.extend(
	{
		tableDnD : jQuery.tableDnD.build,
		tableDnDUpdate : jQuery.tableDnD.updateTables,
		tableDnDSerialize: jQuery.tableDnD.serializeTables
	}
);]]></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/replacement.inc</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/includes/Sample_Form.xml</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?xml version="1.0" encoding="utf-8"?>
<form id="3"
	alias="sample_form">
		<form_name><![CDATA[Sample Form]]></form_name>
		<attribute key="predisplay_udt"><![CDATA[-1]]></attribute>
		<attribute key="submit_action"><![CDATA[text]]></attribute>
		<attribute key="input_button_safety"><![CDATA[0]]></attribute>
		<attribute key="use_catcha"><![CDATA[]]></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="prev_button_text"><![CDATA[Back...]]></attribute>
		<attribute key="inline"><![CDATA[0]]></attribute>
		<attribute key="submit_javascript"><![CDATA[]]></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 !empty($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 isset($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 isset($has_captcha) && $has_captcha == 1}
    <div class="captcha">{$graphic_captcha}{$title_captcha}<br />{if !empty($input_captcha)}{$input_captcha}{/if}</div>
  {/if}
  <div class="submit">{$prev}{$submit}</div>
  </div>
  {$fb_form_end}
{/if}
{$fb_form_footer}]]></attribute>
		<attribute key="validate_udt"><![CDATA[-1]]></attribute>
		<attribute key="title_position"><![CDATA[left]]></attribute>
		<attribute key="list_delimiter"><![CDATA[ - ]]></attribute>
		<attribute key="required_field_symbol"><![CDATA[*]]></attribute>
		<attribute key="unspecified"><![CDATA[[unspecified]]]></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>

<p>If you'd like to contribute to the future development of FormBuilder, you can make a donation below. I will be happy to give donors credit as a sponsor in the FormBuilder help. Every bit helps!</p>

<form action="https://www.paypal.com/cgi-bin/webscr" method="post">
<input type="hidden" name="cmd" value="_s-xclick">
<input type="hidden" name="hosted_button_id" value="2057231">
<input type="image" src="https://www.paypal.com/en_US/i/btn/btn_donate_SM.gif" border="0" name="submit" alt="">
<img alt="" border="0" src="https://www.paypal.com/en_US/i/scr/pixel.gif" width="1" height="1">
</form>
]]></attribute>
		<attribute key="submit_button_text"><![CDATA[Send Feedback]]></attribute>
		<attribute key="next_button_text"><![CDATA[Continue...]]></attribute>
		<attribute key="predisplay_each_udt"><![CDATA[-1]]></attribute>
		<attribute key="use_captcha"><![CDATA[0]]></attribute>
	<field id="21"
		type="FieldsetStart"
		validation_type=""
		order_by="2"
		required="0"
		hide_label="0"
		display_in_submission="">
			<field_name><![CDATA[Fieldset Start]]></field_name>
			<options>
			<option name="legend"><![CDATA[Help Improve Form Builder]]></option>
			<option name="css_class"><![CDATA[]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="22"
		type="DispositionEmail"
		validation_type=""
		order_by="3"
		required="0"
		hide_label="0"
		display_in_submission="">
			<field_name><![CDATA[Send It]]></field_name>
			<options>
			<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>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="23"
		type="StaticTextField"
		validation_type=""
		order_by="4"
		required="0"
		hide_label="0"
		display_in_submission="">
			<field_name><![CDATA[Welcome!]]></field_name>
			<options>
			<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[message]]></option>
			<option name="field_alias"><![CDATA[]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="24"
		type="CheckboxGroupField"
		validation_type=""
		order_by="5"
		required="0"
		hide_label="0"
		display_in_submission="1">
			<field_name><![CDATA[Modules you'll be using together]]></field_name>
			<options>
			<option name="no_empty"><![CDATA[]]></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>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="25"
		type="CheckboxGroupField"
		validation_type=""
		order_by="6"
		required="0"
		hide_label="0"
		display_in_submission="1">
			<field_name><![CDATA[What will you personally be doing on your CMS MS site?]]></field_name>
			<options>
			<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>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="26"
		type="CountryPickerField"
		validation_type=""
		order_by="7"
		required="0"
		hide_label="0"
		display_in_submission="1">
			<field_name><![CDATA[Where are you from?]]></field_name>
			<options>
			<option name="default"><![CDATA[]]></option>
			<option name="select_one"><![CDATA[Select One]]></option>
			<option name="css_class"><![CDATA[]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="27"
		type="TextAreaField"
		validation_type=""
		order_by="8"
		required="0"
		hide_label="0"
		display_in_submission="1">
			<field_name><![CDATA[Do you have any comments / feedback for me?]]></field_name>
			<options>
			<option name="css_class"><![CDATA[]]></option>
			<option name="rows"><![CDATA[10]]></option>
			<option name="cols"><![CDATA[60]]></option>
			<value><![CDATA[]]></value>
			</options>
</field>
	<field id="28"
		type="FieldsetEnd"
		validation_type=""
		order_by="9"
		required="0"
		hide_label="0"
		display_in_submission="">
			<field_name><![CDATA[Fieldset End]]></field_name>
			<options>
			<option name="css_class"><![CDATA[]]></option>
			<value><![CDATA[]]></value>
			</options>
</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
$lang['friendlyname'] = 'Form Builder';

// field types
$lang['field_type_DispositionEmailFromFEUProperty'] = '*Email users matching an FEU property';
$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_HTML5NumberField']='HTML5 Number Input';
$lang['field_type_HTML5EmailField']='HTML5 Email Input';
$lang['field_type_HTML5URLField']='HTML5 URL Input';
$lang['field_type_SiteAdminField']='Site Admin';
$lang['field_type_PasswordField']='Password';
$lang['field_type_PasswordAgainField']='Password Again (verify)';
$lang['field_type_TextFieldExpandable']='Text Input (Multiple)';
$lang['field_type_TextAreaField']='Text Area';
$lang['field_type_ButtonField']='Button';
$lang['field_type_CheckboxField']='Check Box';
$lang['field_type_CheckboxGroupField']='Check Box Group';
$lang['field_type_PulldownField']='Pulldown';
$lang['field_type_YearPullDownField']='Year 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_DispositionUniqueFile']='*Write Results to a Unique Flat File for each submission';
$lang['field_type_DispositionDatabase']='*Store Results in Database';
$lang['field_type_DispositionFormBrowser']='*Store Results for FormBrowser Module';
$lang['field_type_DispositionUserTag']='*Call A User Defined Tag With the Form Results';
$lang['field_type_DispositionForm'] = '*Submit to an arbitrary form action';
$lang['field_type_DispositionDeliverToEmailAddressField']='*Email to User-Supplied Email Address';
$lang['field_type_DispositionEmailSiteAdmin']='*Email to CMS Admin User';
$lang['field_type_DispositionEmailBasedFrontendFields']='*Email results based on frontend fields';
$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_CCEmailAddressField']='Email Carbon Copy (CC) Address 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['field_type_UserTagField'] = '-User Defined Tag Call';
$lang['field_type_CompanyDirectoryField'] = 'Company Directory Field';
$lang['field_type_ModuleInterfaceField'] = '-Module Interface Field';
$lang['field_type_CheckboxExtendedField'] = 'Checkbox extended'; // Need to remove

// 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';
$lang['validation_empty']='Can\'t be empty';

// validation error messages and other alerts
$lang['required'] = 'Required';
$lang['not_required'] = 'Not Required';
$lang['not_available'] = 'Not Available';
$lang['error_emailfromfeuprop'] = 'Error in Field Setup';
$lang['error_nofeu'] = 'The FrontEndUsers module could not be found.  This field will not function.';
$lang['error_nofeudefns'] = 'No suitable FEU property could be found.  This field will not function.';
$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['please_login'] = 'Please log in to use this form';
$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['please_enter_at_least'] = 'Please enter a value that is at least %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.';
$lang['no_field_assigned'] = 'No field assigned for %s';

// 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['fields']='fields';
$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['css'] = 'CSS';
//$lang['year_start'] = 'Start 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'] = '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['tab_udt'] = 'UDT Integration';

$lang['title_feu_property'] = 'FrontEndUsers Property';
$lang['info_feu_property'] = 'Only certain property types can be used for matching (dropdowns, multi-select fields, etc).';
$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['title_cataloger_attribute_fields'] = 'Cataloger Attribute Fields';
$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['title_textfield_label'] = 'Textfield label'; // Remove?
$lang['title_show_textfield'] = 'Show textfield?'; // Remove?
$lang['help_name_regex'] = 'A regular expression to allow filtering cataloger items by name';
$lang['help_field_height'] = 'The height of the multi-select 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_allow_overwrite'] = 'Allow upload to overwrite previously files?';
$lang['title_allow_overwrite_long'] = 'Should uploaded file overwrite previously uploaded file if it has the same name?';
$lang['overwrite']='Allows Overwriting';
$lang['nooverwrite']='No Overwrite';
$lang['file_already_exists']='File %s already exists, and cannot be overwritten.';
$lang['title_file_rename']='Filename template';
$lang['original_file_extension']='Original file extension (includes the ".")';
$lang['title_suppress_filename']='Suppress filename in emails and forms the end user will see';
$lang['title_suppress_attachment']='Deny file to be attached with emails';
$lang['file_rename_help']='To rename a file upon uploading, create the template here. Leave blank to preserve original filename';
$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 E-mailer 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_field_alias_short']='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 and DOM id (CSS id) attribute';
$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_button_text']='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_field_css_id']='CSS id for this field';
$lang['title_form_css_class']='CSS Class for this form';
$lang['title_field_css_class']='CSS Class for this field';
$lang['title_form_predisplay_udt'] = 'User defined tag to call before form is displayed the first time (only called once)';
$lang['title_form_predisplay_each_udt'] = 'User defined tag to call before form is displayed (called on every page of multipage forms)';
$lang['title_form_validate_udt'] = 'User defined tag to call during form validation';
$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_textarea_length']='Maximum length of field content (0 or blank means no limit)';
$lang['title_text']='Static text to display';
$lang['title_field_regex']='Validation Regex';
$lang['title_lines_to_show'] = 'Number of Lines to display';
$lang['title_read_only'] = 'Read Only';
$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_file_destination'] = 'Directory to save files into';
$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="_blank">"Captcha"</a> to protect form submissions if you install the Captcha module. For more information, <a href="http://dev.cmsmadesimple.org/projects/captcha/" target="_blank">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="_blank">"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_default_blank']='Default to blank';
$lang['title_default_blank_help']='Default to blank (uncheck to default to today\'s date)';
$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['title_encrypt_database_data'] = 'Encrypt data stored in database';
$lang['title_crypt_cert'] = 'Certificate for encrypting data';
$lang['title_encryption_keyfile'] = 'Pass phrase or path to file containing pass phrase. (If using OpenSSL, this is the pass phrase for the private key)';
$lang['title_encrypt_sortfields'] = 'Hash sort fields?';
$lang['title_private_key'] = 'Private Key to use for encrypting data';
$lang['title_encrypt_sortfields_help'] = 'This hashes the sort fields, but leaves the first few letters unencrypted. Cryptographically, this creates a vulnerability, but for most users it is an acceptable trade off between security and the ability to sort records. Sorting becomes approximate, but will remain pretty good. If you do not use this option, sort fields are stored in plain text.';
$lang['title_encryption_functions'] = 'Storage Encryption Unavailable';
$lang['title_install_crypto'] = 'Please install the OpenSSL module or mcrypt support if you would like to enable database encryption.';
$lang['title_install_curl'] = 'Please make sure you have CURL support active in your PHP install. See http://www.php.net/manual/en/book.curl.php';
$lang['title_mle_version'] = 'Run in MLE Mode';
$lang['title_mle_version_long'] = 'Changes/support for CMSMS Multi-Language Edition fork. Do not check this if you are not running the MLE version.';
$lang['title_ensure_cert_key_match'] = 'Ensure that you select the private key that is appropriate for the certificate you are using for encryption!';
$lang['choose_crypt'] = 'Encryption Library';
$lang['title_encrypt_database_long'] = 'Check this to encrypt the stored data. This makes it more difficult (but not impossible) for hackers to view the information.';
$lang['choose_crypt_long'] = 'The options below only apply if you are using the OpenSSL Encryption library';
$lang['title_crypt_lib']='Encryption Library';
$lang['openssl'] = 'OpenSSL Library';
$lang['mcrypt'] = 'PHP mcrypt Library';
$lang['title_feu_binding'] = 'Frontend User binding';
$lang['title_install_feu'] = 'Please install the Frontend User module to connect a form and its data to a specific user';
$lang['title_feu_bind_help'] = 'Check this to lock front-end access to this form\'s data to the logged-in front-end user.';
$lang['title_encryption'] = 'Encryption';
$lang['title_export_form_to_udt'] = 'Export form reference to UDT as $params[\'FORM\']? (do not do this if you are going to print_r($params) )';
$lang['title_url_help'] = 'Entire URL, including protocol and path (e.g., http://myhost.com/form_handler.cgi)';
$lang['title_url'] = 'Form submission URL';
$lang['title_method'] = 'Form method';
$lang['title_maps_to'] = 'Map field "%s" to form submission variable';
$lang['title_additional'] = 'Additional submission';
$lang['title_additional_help'] = 'Anything to be appended to the submission payload, in URL-encoded form (.e.g, "user=steve+jobs&employee_number=1)';
$lang['title_include_in_submission'] = 'Include field in Submission';
$lang['title_date_order']='Date component field order (for input)';
$lang['title_data_stored_in_fbr'] = 'Data will be stored in an XML format in the [PREFIX]_module_fb_formbrowser database table.';
$lang['error_has_no_fb_field'] = 'Error! Either the form has no Form Browser Disposition, or it failed to instantiate (due to memory issues?)';
$lang['help_date_order']='Use "m" for Month, "d" for Day, and "y" for Year. Separate the items by hyphens.';
$lang['restricted_to_group'] = 'Only in group %s';
$lang['title_show_to_user'] = 'Display to user';
$lang['title_use_random_generator'] = 'Use random number generator instead of static';
$lang['title_numbers_to_generate'] = 'How many numbers to generate in process';
$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_ignored_if_upload']='(This field ignored if you use the Uploads module to manage files)';
$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 containing:<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['help_rtf_file_template']='Specify a file located in the FormBuilder/templates/ folder. This field is ignored if you use TXT as your file type.';
$lang['help_rtf_template_type']='Basic: Use the textarea below to layout the field names/values in a single block.<br />
Advanced: Specify Smarty variables in the RTF Template File as you would below, but arrange them however you like and add formatting.<br />
&nbsp;You can still use the %%HEADER%% and %%FOOTER%% sections in the RTF file.';
$lang['help_unique_file_template']='For TXT, this will be immediately after the Header Template.<br />
For RTF, this will replace the %%FIELDS%% string in the template file if RTF Template Type is set to "Basic".<br />
This field will be ignored if using "RTF" as File Type and "Advanced" as RTF Template Type.';
$lang['help_file_header_template']='For TXT, this will be placed at the top of the file. For RTF, this will replace the %%HEADER%% string in the template file.';
$lang['help_file_footer_template']='For TXT, this will be placed at the bottom of the file. For RTF, this will replace the %%FOOTER%% string in the template file.';
$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_footer_template']='Create Sample Footer 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_file_footer']='Template for the footer of output file';
$lang['title_rtf_file_template']='Template RTF file to use';
$lang['title_unique_file_template']='Template for output';
$lang['title_file_type']='Choose a file type to use';
$lang['title_rtf_template_type']='Choose an RTF template type';
$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 for display (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['title_submit_date']='Date Submitted';
$lang['title_approval_date']='Date Approved (by admin)';
$lang['title_user_approved']='Date Approved (by submitter)';
$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 Field names';
$lang['title_require_fieldnames_long'] = 'Require fields to have a name?';
$lang['title_unique_fieldnames'] = 'Require Unique Field names';
$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_field_helptext'] = 'Help-text to display with this field';
$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_string_unspaced'] = 'String (no spaces between fields)?';
$lang['title_compute_value'] = 'Value to compute';
$lang['title_compute'] = 'Computed/PHP';
$lang['title_string'] = 'String';
$lang['title_numeric'] = 'Numeric';
$lang['title_inline_form'] = 'Display form inline?';
$lang['title_inline_form_help'] = 'Inline means any form follow-up replaces the {FormBuilder} 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.<br />
If left blank, this will default to your default uploads directory ($config[\'uploads_path\']).';
$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['title_display_length'] = 'Display length';
$lang['title_minimum_length'] = 'Minimum response length';
$lang['title_hide'] = 'Hide input';
$lang['title_hide_help'] = 'Show symbols rather plain text when user enters password?';
$lang['password_does_not_match'] = 'Password does not match %s';
$lang['back_top'] = 'Back to FormBuilder Main Page';
$lang['title_headers_to_modify'] = 'Which email headers should this input populate?';
$lang['title_blank_invalid'] = 'Do not accept blank space as valid response';
$lang['title_blank_invalid_long'] = 'If a field is required, checking this will require that people put in some alphanumeric characters, not just spaces';
$lang['title_must_save_order'] = 'You must click one of the "save" buttons to make your new field order permanent.';
$lang['title_html5'] = 'Use HTML5 instead of JavaScript';
$lang['title_email_cc_address'] = 'Address(es) to email as Carbon copy (CC). Use commas to delimit multiple addresses.';
$lang['title_use_bcc']='Use Blind carbon copy (BCC instead of CC)';
$lang['title_send_using']='Mail Addressing';
$lang['title_field_to_modify']='Email field to add CC address';
$lang['title_modifies']='Add CC to "%s"';
$lang['bcc_field']='"BCC" recipients';
$lang['cc_field']='"CC" recipients';
$lang['to_field']='Normal ("To" recipients)';
$lang['bcc']='BCC';
$lang['cc']='CC';

$lang['error_CompanyDirectory_module_not_available'] = 'Company Directory module is not available!';
$lang['option_never'] = 'Never';
$lang['option_user_choice'] = 'Give user a choice (checkbox)';
$lang['option_always'] = 'Always';
$lang['option_from'] = '"From" email address';
$lang['option_reply'] = '"Reply-To" email address';
$lang['option_both'] = 'Both "From" and "Reply-To" email addresses';
$lang['option_dropdown']='Dropdown';
$lang['option_selectlist_single']='Select List (single)';
$lang['option_selectlist_multiple']='Select List (multiple)';
$lang['option_radiogroup']='Radio Group';
$lang['title_company_field_note']='Note: Output will be in the form of<br/>"company name"=>"value"';
$lang['title_pick_categories']='Pick a category (multiple)';
$lang['title_pick_fielddef']='Pull a field Definition\'s value (single) <em>optional</em>';
$lang['title_choose_user_input']='Choose User input';
$lang['title_see_also_udt']='(Also take a look at the Form Submission tab if you want to set a UDT for form validation)';
$lang['title_year_end_message']='End year';
$lang['title_field_logic']='Smarty data or logic that is meant to be sent with this field';
$lang['title_field_logic_long']='Can be Smarty data, JavaScript, or some other data you want to sent along with this field.<br />Goes through the Smarty compiler, so remember use {literal}{/literal} tags with &lt;script&gt;&lt;/script&gt;';
$lang['title_field_includelabels']='Include labels';
$lang['title_field_includelabels_help']='Enabling this includes labels to output. example - label: value,label2: value2';
$lang['title_field_siblings']='Link this field to it\'s sibling';
$lang['title_field_siblings_help']='Dropdown lists all siblings of this field and allows you to link this field to one of it\'s sibling. Makes possible controlling this field with selected sibling controls.';
$lang['title_field_hidebuttons']='Hide control buttons';
$lang['title_field_hidebuttons_help']='Hides frontend control buttons of this field.';
$lang['title_note']='Note';
$lang['title_changing_triggers_reindex']='Changing any of the above fields will trigger a re-index of *all* saved records, so it could take a while.';
$lang['illegal_file']='Attempted upload of illegal file type (%s) from %s';
$lang['title_searchable']='Make records accessible to Search Module';
$lang['title_searchable_help']='Checking this will make all submitted data accessible to the Search Module. DO NOT use this if you encrypt your data -- the information gets exposed to search whether or not it is encrypted!';
$lang['uploaded_outside_webroot']='%s (outside web root)';
$lang['title_fbr_edit']='Editable in FormBrowser Admin?';
$lang['title_active_only']='Only include active users?';

$lang['error_usertag_disposition'] = 'User defined tag returned an error';
$lang['error_usertag'] = 'User defined tag %s returned an error.';
$lang['error_cataloger_module_not_available']='<strong>Cataloger module does not seem to be installed/active.</strong>';
$lang['warning'] = 'WARNING!';
$lang['select_source_template'] = 'Select a source template:';
$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'] = 'Copy 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 Response Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_no_field_error']='Validation Response 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['must_specify_one_admin']='Must specify an Admin';


$lang['operators_help'] = 'If you use String evaluation, the only operation available is concatenation (+). If you use Number evaluation you have basic, very simple math (, +, -, *, /, ). If you use Computed/PHP evaluation, you can
use any function you want, but you need to quote things (substitution occurs before evaluation), e.g., substr(\'$fld_22\',0,2).\'$fld_23\'.'; 
$lang['help_module_interface']='Using Module Interface';
$lang['help_module_interface_long']='<b>This field is used as a gateway to other modules!</b>
Use it by creating your form elements in the templates of the other module(s) you wish to incorporate, and using the <strong>{$FBid}</strong> to tie it back to FormBuilder. For example, to include form options based on the Products module, create the following template in Products:<br />
<pre>
{foreach from=$items item=entry}
	{assign var=MData value=\'\'}
	{assign var=Cd value=\'\'}
		{foreach from=$FBvalue item=MData}
			{assign var=MData value=\'::\'|explode:$MData}
			{if $MData[1]==$entry->id}
				{assign var=Cd value=\' checked="checked"\'}
			{/if}
		{/foreach}
	&lt;div class="ProductDirectoryItem">
		&lt;input type="checkbox" value="{$entry->price}::{$entry->id}" name="{$FBid}[]" {$Cd} />{$entry->product_name} ({$entry->weight}{$weight_units}) &pound;{$entry->price}    
	&lt;/div>
{/foreach}
</pre>
<br/>
where in the input below you put something like <strong>{Products category="cat" summarytemplate="Your_FB_template"}</strong>';
$lang['title_add_tag'] = 'Add your tag';

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

$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']='Sent when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormSubmitError']='Sent if there is an error when a FormBuilder form is submitted';
$lang['event_info_OnFormBuilderFormDisplay']='Sent when a FormBuilder form is displayed';

$lang['event_help_OnFormBuilderFormSubmit']='<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']='<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']='<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>Variable</th><th>Value</th></tr>
<tr><td>\$entry->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>\$entry->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>\$entry->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>\$entry->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>\$entry->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>\$entry->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>\$entry->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>\$entry->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>\$entry->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>\$entry->name</td><td>the field's name</td></tr>
<tr><td>\$entry->helptext</td><td>the field's help text</td></tr>
<tr><td>\$entry->input</td><td>the field's input control (e.g., the input field itself)</td></tr>
<tr><td>\$entry->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>\$entry->input_id</td><td>the ID of the field's input (useful for label for=\"foo\")</td></tr>
<tr><td>\$entry->alias</td><td>the alias specified for this field</td></tr>
<tr><td>\$entry->id</td><td>the internal / opaque id FormBuilder uses for this field</td></tr>
<tr><td>\$entry->type</td><td>the field's data type</td></tr>                             
<tr><td>\$entry->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>\$entry->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In the case of a multipage form, you will also have access to the value of previous fields. They
are in the \$previous array, or accessible by their names (e.g., &#123;\$myfield->value} ).
You can use this in Static Text fields as well, which is a nice way to personalize forms!</p>

<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>\$in_formbrowser</td><td>1 if form is being viewed from FormBrowser</td></tr>
<tr><td>\$in_admin</td><td>1 if form is being viewed via FormBrowser admin</td></tr>
<tr><td>\$fbr_id</td><td>Response ID if form is being viewed from FormBrowser</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>
";

// post-install message
$lang['post_install']="FormBuilder installed. Please consult the module's Help page for documentation.";

$lang['title_month_input'] = "Month Format for Form Input";
$lang['opt_month_input_text'] = "Text";
$lang['opt_month_input_number'] = "Number";
$lang['opt_month_input_both'] = "Both";
$lang['title_default_time'] = "Default Time";
$lang['title_default_time_help'] = '(Set to -1 for default time to be the current time)';
$lang['title_minute_interval'] = "Minute Interval";


?>
]]></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'] = 'Neodpov&iacute;d&aacute; regul&aacute;rn&iacute;mu v&yacute;razu';
$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['css'] = 'CSS';
$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_field_css_id'] = 'CSS id for this field';
$lang['title_form_css_class'] = 'CSS Class for this form';
$lang['title_field_css_class'] = 'CSS Class for this field';
$lang['title_form_predisplay_udt'] = 'User defined tag to call before form is displayed';
$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_usertag_disposition'] = 'User defined tag returned an error';
$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['utma'] = '156861353.1812446927.1201250230.1247586856.1247778823.119';
$lang['utmz'] = '156861353.1247151290.117.54.utmccn=(referral)|utmcsr=zspraksice.zkedu.cz|utmcct=/skolca/admin/imagefiles.php|utmcmd=referral';
$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'] = 'V&aelig;lg en (eller flere) katalog emner';
$lang['field_type_FieldsetEnd'] = '-Felts&aelig;t slut';
$lang['field_type_FieldsetStart'] = '-Felts&aelig;t begynd';
$lang['field_type_TextField'] = 'Tekstfelt';
$lang['field_type_PasswordField'] = 'Password';
$lang['field_type_PasswordAgainField'] = 'Skriv Password (konfirmation)';
$lang['field_type_TextFieldExpandable'] = 'Tekstfelt (flere)';
$lang['field_type_TextAreaField'] = 'Tekstfelt, flere linier';
$lang['field_type_ButtonField'] = 'Knap';
$lang['field_type_CheckboxField'] = 'Afkrydsningsboks';
$lang['field_type_CheckboxGroupField'] = 'Gruppe af afkrydsningsbokse';
$lang['field_type_PulldownField'] = 'Pulldown-menu';
$lang['field_type_YearPullDownField'] = 'Pulldown (&aring;r)';
$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_DispositionForm'] = '*Submit to an arbitrary form action';
$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['field_type_UserTagField'] = '-User Defined Tag Call';
$lang['field_type_CompanyDirectoryField'] = 'Company Directory Field';
$lang['field_type_ModuleInterfaceField'] = '-Module Interface Field';
$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['please_login'] = 'V&aelig;r venlig at logge ind for at bruge denne formular';
$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['please_enter_at_least'] = 'V&aelig;r venlig at taste en v&aelig;rdi der har mindst %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['css'] = 'CSS';
$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['tab_udt'] = 'UDT Integration';
$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'] = 'Der er genereret for mange e-mails fra denne IP adresse. Anti-Spam funktionen har forhindret afsendelse.';
$lang['suspected_spam_log'] = 'Mail fra IP %s, mist&aelig;nkt for at v&aelig;re spam, er stoppet.';
$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'] = 'H&oslash;jden p&aring; multi-v&aelig;lg felt';
$lang['title_name_regex'] = 'Cataloger Item Name Regular Expression';
$lang['title_field_height'] = 'Felth&oslash;jde';
$lang['title_file_path'] = 'Destinationsmappe for output filer';
$lang['title_udt_name'] = 'Brugerdefineret Tag';
$lang['title_uploads_destpage'] = 'Side at vende tilbage til med upload-l&aelig;nken';
$lang['title_uploadmodule_summary'] = 'Indsendt med formulargenerator';
$lang['title_uploads_category'] = 'Upload kategori';
$lang['title_sendto_uploads'] = 'Send denne fil til upload-modulet';
$lang['title_legend'] = 'Historie';
$lang['title_maximum_length'] = 'Maximum l&aelig;ngde';
$lang['title_checkbox_label'] = 'Navn p&aring; checkboks';
$lang['title_radio_label'] = 'Navn p&aring; knap';
$lang['title_checked_value'] = 'V&aelig;rdi n&aring;r markeret';
$lang['title_unchecked_value'] = 'V&aelig;rdi uden markering';
$lang['title_checkbox_details'] = 'Gruppedetaljer for Checkboks';
$lang['title_delete'] = 'Slet?';
$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'] = 'Standart udvalg';
$lang['title_select_default_state'] = 'Standart udvalg';
$lang['title_select_default_province'] = 'Standart udvalg';
$lang['title_option_name'] = 'Valgmulighedens navn';
$lang['title_option_value'] = 'Indsendt v&aelig;rdi';
$lang['title_pulldown_details'] = 'Pulldown muligheder';
$lang['title_multiselect_details'] = 'Multivalg muligheder';
$lang['title_destination_address'] = 'Destination Email Address';
$lang['title_destination_filename'] = 'Destiantion for Fil-navn';
$lang['title_email_from_name'] = '&quot;Fra navn&quot; for email';
$lang['title_relaxed_email_regex'] = 'Brug bl&oslash;d email validering';
$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 tegns&aelig;t kodning';
$lang['title_director_details'] = 'Pulldown-based Emailer Details';
$lang['title_file_name'] = 'Fil navn';
$lang['title_email_subject'] = 'Emnelinie i e-mail';
$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_field_alias_short'] = 'Alias';
$lang['title_form_fields'] = 'Formular felter';
$lang['title_field_id'] = 'Felt Id';
$lang['title_show_fieldaliases'] = 'Vis Field Aliases';
$lang['title_show_fieldaliases_long'] = 'Klik her for at for at se display aliaser n&aring;r der tilf&oslash;res eller redigeres i en formular';
$lang['title_field_name'] = 'Felt Navn';
$lang['title_field_alias'] = 'Field Alias';
$lang['title_radiogroup_details'] = 'Radio Button Group Details';
$lang['title_field_type'] = 'Felttype';
$lang['title_not_ready3'] = 'for at skabe et formular-styrende felt';
$lang['title_add_new_form'] = 'Tilf&oslash;j ny formular';
$lang['title_show_version'] = 'Vis formular generator version?';
$lang['title_show_version_long'] = 'Dette vil inds&aelig;tte formulargeneratorens versionsnummer i en kommentar for at bidrage til debugging';
$lang['title_add_new_field'] = 'Tilf&oslash;r nyt felt';
$lang['title_form_submit_button'] = 'Tekst til formularens &quot;Indsend&quot; knap';
$lang['title_button_text'] = 'Knap-tekst';
$lang['title_submit_button_safety'] = 'Tilf&oslash;j Javascript til endelig &quot;Indsend&quot;-knap, der vil forhindre multiple indsendelser?';
$lang['title_submit_button_safety_help'] = 'Tilf&oslash;j sikkerheds-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_field_css_id'] = 'CSS id for this field';
$lang['title_form_css_class'] = 'CSS Class for this form';
$lang['title_field_css_class'] = 'CSS Class for this field';
$lang['title_form_predisplay_udt'] = 'Brugerdefineret tag der skal kaldes f&oslash;r formularen vises f&oslash;rste gang (kaldes kun &eacute;n gang)';
$lang['title_form_predisplay_each_udt'] = 'Brugerdefineret tag der skal kaldes f&oslash;r formularen vises (kaldes p&aring; hver side af flersidige formularer)';
$lang['title_form_validate_udt'] = 'Brugerdefineret tag der skal kaldes under formularvalidering';
$lang['title_form_required_symbol'] = 'Symbol der bruges til at markere &quot;Kr&aelig;vet felt&quot;';
$lang['title_field_required'] = 'P&aring;kr&aelig;vet';
$lang['title_field_required_long'] = 'Kr&aelig;v en markering for dette felt';
$lang['title_hide_label'] = 'Skjul 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'] = 'Antal linier at vise';
$lang['title_read_only'] = 'Kun l&aelig;serettighed';
$lang['no_default'] = 'Intet 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'] = 'Debug- / fejlmeddelelser forhindres i at blive set af brugere.';
$lang['title_email_template'] = 'Email skabelon';
$lang['title_maximum_size'] = 'Maximum uploadst&oslash;rrelse for filer (kilobytes)';
$lang['title_maximum_size_long'] = 'Denne begr&aelig;nsning er en tilf&oslash;jelse  til eventuelle begr&aelig;nsninger sat af php eller webserver-konfigurationen';
$lang['title_permitted_extensions'] = 'Tilladte endelser';
$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'] = 'Vis restriktioner?';
$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'] = 'Side nummer %s af %s';
$lang['title_no_advanced_options'] = 'Feltet har inden avancered valgmuligheder';
$lang['title_form_unspecified'] = 'Responstekst ved uspeciferede feltv&aelig;rdier';
$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'] = 'Klik her for at s&aelig;tte en gr&aelig;nse p&aring; ti (10) mails tilladt fra den givne IP adresse per time.';
$lang['title_enable_antispam'] = 'Iv&aelig;rks&aelig;t simple anti-spam forholdsregler?';
$lang['title_show_fieldids'] = 'Vis Field IDs';
$lang['title_show_fieldids_long'] = 'Tillad visning af felt ID n&aring;r der tilf&oslash;jes eller redigeres i en formular hvis der klikkes her';
$lang['title_xml_to_upload'] = 'Upload formular fra XML file';
$lang['title_xml_upload_formname'] = 'Brug dette formularnavn';
$lang['title_import_legend'] = 'XML formular import';
$lang['title_xml_upload_formalias'] = 'Brug dette formular alias';
$lang['title_html_email'] = 'Gener&eacute;r HTML email?';
$lang['title_link_autopopulate'] = 'Fuldf&oslash;r automatisk?';
$lang['title_link_autopopulate_help'] = 'Inds&aelig;t automatisk URL fra siden, der indeholder formularen?
(Dette tager precedens fra sidel&aelig;nke muligheden nedenunder)';
$lang['title_default_link'] = 'Standart l&aelig;nke URL';
$lang['title_default_link_title'] = 'Standart l&aelig;nke tekst';
$lang['title_link_to_sitepage'] = 'L&aelig;nke til side';
$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'] = 'Brug Captcha for at beskytte formularindl&aelig;g?';
$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'] = 'Konfirm&eacute;r venligst at du ikke er et script ved at l&aelig;se og inds&aelig;tte tegnene fra billedet';
$lang['title_user_captcha_error'] = 'Forkert tekst for Captcha';
$lang['wrong_captcha'] = 'Captcha var ikke identisk';
$lang['title_title_user_captcha'] = 'Hj&aelig;lpetekst 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_default_blank'] = 'Default to blank';
$lang['title_default_blank_help'] = 'Default to blank (uncheck to default to today&#039;s date)';
$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['title_encrypt_database_data'] = 'Encrypt data stored in database';
$lang['title_crypt_cert'] = 'Certificate for encrypting data';
$lang['title_encryption_keyfile'] = 'Passphrase or path to file containing passphrase. (If using OpenSSL, this is the passphrase for the private key)';
$lang['title_encrypt_sortfields'] = 'Hash sort fields?';
$lang['title_private_key'] = 'Private Key to use for encrypting data';
$lang['title_encrypt_sortfields_help'] = 'This hashes the sort fields, but leaves the first few letters unencrypted. Cryptographically, this creates a vulnerability, but for most users it is an acceptable tradeoff between security and the ability to sort records. Sorting becomes approximate, but will remain pretty good. If you do not use this option, sort fields are stored in plaintext.';
$lang['title_encryption_functions'] = 'Storage Encryption Unavailable';
$lang['title_install_crypto'] = 'Please install the OpenSSL module or mcrypt support if you would like to enable database encryption.';
$lang['title_install_curl'] = 'Please make sure you have CURL support active in your PHP install. See http://www.php.net/manual/en/book.curl.php';
$lang['title_mle_version'] = 'Run in MLE Mode';
$lang['title_mle_version_long'] = 'Changes/support for CMSMS Multi-Language Edition fork. Do not check this if you are not running the MLE version.';
$lang['title_ensure_cert_key_match'] = 'Ensure that you select the private key that is appropriate for the certificate you are using for encryption!';
$lang['choose_crypt'] = 'Encryption Library';
$lang['title_encrypt_database_long'] = 'Check this to encrypt the stored data. This makes it more difficult (but not impossible) for hackers to view the information.';
$lang['choose_crypt_long'] = 'The options below only apply if you are using the OpenSSL Encryption library';
$lang['title_crypt_lib'] = 'Encryption Library';
$lang['openssl'] = 'OpenSSL Library';
$lang['mcrypt'] = 'PHP mcrypt Library';
$lang['title_feu_binding'] = 'Frontend User binding';
$lang['title_install_feu'] = 'Please install the Frontend User module to connect a form and its data to a specific user';
$lang['title_feu_bind_help'] = 'Check this to lock front-end access to this form&#039;s data to the logged-in front-end user.';
$lang['title_encryption'] = 'Encryption';
$lang['title_export_form_to_udt'] = 'Export form reference to UDT as $params[&#039;FORM&#039;]? (do not do this if you are going to print_r($params) )';
$lang['title_url_help'] = 'Entire URL, including protocol and path (e.g., http://myhost.com/form_handler.cgi)';
$lang['title_url'] = 'Form submission URL';
$lang['title_method'] = 'Form method';
$lang['title_maps_to'] = 'Map field &quot;%s&quot; to form submission variable';
$lang['title_additional'] = 'Additional submission';
$lang['title_additional_help'] = 'Anything to be appended to the submission payload, in URL-encoded form (.e.g, &quot;user=steve+jobs&amp;employee_number=1)';
$lang['title_include_in_submission'] = 'Include field in Submission';
$lang['title_data_stored_in_fbr'] = 'Data will be stored in an XML format in the [PREFIX]_module_fb_frombrowser database table.';
$lang['error_has_no_fb_field'] = 'Error! Either the form has no form_builder disposition, or it failed to instantiate (due to memory issues?)';
$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_footer_template'] = 'Create Sample Footer 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_file_footer'] = 'Template for the footer 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['title_submit_date'] = 'Date Submitted';
$lang['title_approval_date'] = 'Date Approved (by admin)';
$lang['title_user_approved'] = 'Date Approved (by submitter)';
$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_field_helptext'] = 'Help-text to display with this field';
$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['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['title_display_length'] = 'Display length';
$lang['title_minimum_length'] = 'Minimum response length';
$lang['title_hide'] = 'Hide input';
$lang['title_hide_help'] = 'Show symbols rather plain text when user enters password?';
$lang['password_does_not_match'] = 'Password does not match %s';
$lang['back_top'] = 'Back to FormBuilder Main Page';
$lang['title_headers_to_modify'] = 'Which email headers should this input populate?';
$lang['title_blank_invalid'] = 'Do not accept blank space as valid response';
$lang['title_blank_invalid_long'] = 'If a field is required, checking this will require that people put in some alphanumeric characters, not just spaces';
$lang['error_CompanyDirectory_module_not_available'] = 'Company Directory module is not available!';
$lang['option_never'] = 'Aldrig';
$lang['option_user_choice'] = 'Give user a choice (checkbox)';
$lang['option_always'] = 'Altid';
$lang['option_from'] = '&quot;From&quot; email address';
$lang['option_reply'] = '&quot;Reply-To&quot; email address';
$lang['option_both'] = 'Both &quot;From&quot; and &quot;Reply-To&quot; email addresses';
$lang['option_dropdown'] = 'Dropdown';
$lang['option_selectlist_single'] = 'Select List (single)';
$lang['option_selectlist_multiple'] = 'Select List (multiple)';
$lang['option_radiogroup'] = 'Radio Group';
$lang['title_company_field_note'] = 'Note: Output will be in the form of<br/>&quot;company name&quot;=>&quot;value&quot;';
$lang['title_pick_categories'] = 'Pick a category (multiple)';
$lang['title_pick_fielddef'] = 'Pull a field Definition&#039;s value (single) <em>optional</em>';
$lang['title_choose_user_input'] = 'Choose User input';
$lang['title_see_also_udt'] = '(Also take a look at the Form Submission tab if you want to set a UDT for form validation)';
$lang['title_year_end_message'] = 'End year';
$lang['error_usertag_disposition'] = 'User defined tag returned an error';
$lang['error_usertag'] = 'User defined tag %s returned an error.';
$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['help_module_interface'] = 'Using Module Interface';
$lang['help_module_interface_long'] = '<b>This field is used as a gateway to other modules!</b>
Use it by creating your form elements in the templates of the other module(s) you wish to incorporate, and using the <strong>{$FBid}</strong> to tie it back to FormBuilder. For example, to include form options based on the Products module, create the following template in Products:<br/>
<pre>
{foreach from=$items item=entry}
	{assign var=MData value=&#039;&#039;}
	{assign var=Cd value=&#039;&#039;}
		{foreach from=$FBvalue item=MData}
			{assign var=MData value=&#039;::&#039;|explode:$MData}
			{if $MData[1]==$entry->id}
				{assign var=Cd value=&#039; checked=&quot;checked&quot;&#039;}
			{/if}
		{/foreach}
	<div class=&quot;ProductDirectoryItem&quot;>
		<input type=&quot;checkbox&quot; value=&quot;{$entry->price}::{$entry->id}&quot; name=&quot;{$FBid}[]&quot; {$Cd} />{$entry->product_name} ({$entry->weight}{$weight_units}) &pound;{$entry->price}    
	</div>
{/foreach}
</pre>
<br/>
where in the input below you put something like <strong>{Products category=&quot;cat&quot; summarytemplate=&quot;Your_FB_template&quot;}</strong>';
$lang['title_add_tag'] = 'Add your tag';
$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['utma'] = '156861353.1954323075.1266874698.1270666248.1271101264.3';
$lang['utmz'] = '156861353.1271101264.3.3.utmccn=(referral)|utmcsr=cmsms.org|utmcct=/|utmcmd=referral';
$lang['qca'] = 'P0-1147258755-1266874698050';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/de_DE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'FormBuilder';
$lang['field_type_DispositionEmailFromFEUProperty'] = '*E-Mail an Benutzer mit passender FEU Benutzer-Eigenschaft';
$lang['field_type_'] = 'Feldtyp wurde nicht definiert';
$lang['field_type_CatalogerItemsField'] = 'Wählen Sie einen (oder mehrere) Cataloger-Einträge aus';
$lang['field_type_FieldsetEnd'] = '- Formularabschnitt (fieldset) Ende';
$lang['field_type_FieldsetStart'] = '- Formularabschnitt (fieldset) Start';
$lang['field_type_TextField'] = 'Textfeld';
$lang['field_type_HTML5NumberField'] = 'HTML5-Zahleneingabe';
$lang['field_type_HTML5EmailField'] = 'HTML5-E-Mail-Eingabe';
$lang['field_type_HTML5URLField'] = 'HTML5-URL-Eingabe';
$lang['field_type_SiteAdminField'] = 'Seitenadministator';
$lang['field_type_PasswordField'] = 'Passwort';
$lang['field_type_PasswordAgainField'] = 'Passwort-Wiederholung';
$lang['field_type_TextFieldExpandable'] = 'Textfeld (mehrfach)';
$lang['field_type_TextAreaField'] = 'Textarea';
$lang['field_type_ButtonField'] = 'Knopf';
$lang['field_type_CheckboxField'] = 'Kontrollkästchen';
$lang['field_type_CheckboxGroupField'] = 'Kontrollkästchen-Gruppe';
$lang['field_type_PulldownField'] = 'Aufklappliste';
$lang['field_type_YearPullDownField'] = 'Aufklappliste-Jahresauswahl';
$lang['field_type_MultiselectField'] = 'Mehrfachauswahl';
$lang['field_type_StatePickerField'] = 'Auswahl eines U.S.-Staates';
$lang['field_type_ProvincePickerField'] = 'Auswahl einer kanadischen Provinz';
$lang['field_type_CountryPickerField'] = 'Länderauswahl';
$lang['field_type_DatePickerField'] = 'Datumsauswahl';
$lang['field_type_TimePickerField'] = 'Zeitauswahl';
$lang['field_type_RadioGroupField'] = 'Radioknopf-Gruppe';
$lang['field_type_DispositionDirector'] = '*Ergebnisse per E-Mail 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 E-Mail an vorgegebene Adresse(n) senden';
$lang['field_type_DispositionEmailConfirmation'] = '*Überprüfung über die E-Mail-Adresse';
$lang['field_type_DispositionFromEmailAddressField'] = '*per E-Mail an „Von“-Adressfeld eine Kopie senden';
$lang['field_type_DispositionFile'] = '*Ergebnisse in eine Datei schreiben';
$lang['field_type_DispositionUniqueFile'] = '*Ergebnisse für jede Eingabe in eine eigene Datei schreiben';
$lang['field_type_DispositionDatabase'] = '*Ergebnisse in der Datenbank speichern';
$lang['field_type_DispositionFormBrowser'] = '*Ergebnisse für das FormBrowser-Modul speichern';
$lang['field_type_DispositionUserTag'] = '*Einen benutzerdefinierten Tag mit den Ergebnissen als Parameter aufrufen';
$lang['field_type_DispositionForm'] = '*Ergebnisse an eine festgelegte Formular-Aktion senden';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Ergebnisse per E-Mail an eine vom Besucher angegebene E-Mail-Adresse versenden';
$lang['field_type_DispositionEmailSiteAdmin'] = '*E-Mail an den CMS-Administrator';
$lang['field_type_DispositionEmailBasedFrontendFields'] = '*E-Mail-Ergebnisse, basierend auf den Feldern im Frontend';
$lang['field_type_DispositionListItExtended'] = 'Ergebnisse für das ListItExtended-Modul speichern';
$lang['field_type_PageBreakField'] = '-Seitenumbruch';
$lang['field_type_FileUploadField'] = 'Dateiupload';
$lang['field_type_FromEmailAddressField'] = 'E-Mail-Adresse „Von“';
$lang['field_type_FromEmailAddressAgainField'] = 'E-Mail-Adresse „Von“ wiederholen';
$lang['field_type_FromEmailNameField'] = 'E-Mail „Von“-Name';
$lang['field_type_FromEmailSubjectField'] = 'E-Mail „Betreff“';
$lang['field_type_CCEmailAddressField'] = 'E-Mail-Feld „Kopie senden an …“ (CC)';
$lang['field_type_StaticTextField'] = '-Statischer Text';
$lang['field_type_SystemLinkField'] = '-Statischer Link';
$lang['field_type_LinkField'] = '-Link (vom Benutzer einzugeben)';
$lang['field_type_HiddenField'] = '-Verstecktes Feld';
$lang['field_type_ComputedField'] = '-Berechnetes Feld';
$lang['field_type_UniqueIntegerField'] = '-Eindeutige Zahl (Seriell)';
$lang['field_type_UserTagField'] = '-Benutzerdefinierter Tag';
$lang['field_type_CompanyDirectoryField'] = '-CompanyDirectory-Feld';
$lang['field_type_ModuleInterfaceField'] = '-Modulschnittstellenfeld';
$lang['field_type_CheckboxExtendedField'] = 'Kontrollkästchen (erweitert)';
$lang['validation_none'] = 'Keine Überprüfung';
$lang['validation_numeric'] = 'Nummerisch';
$lang['validation_integer'] = 'Ganzzahl';
$lang['validation_email_address'] = 'E-Mail-Adresse';
$lang['validation_usphone'] = 'Telefonnummer (US)';
$lang['validation_must_check'] = 'Pflichtfeld';
$lang['validation_regex_match'] = 'Entspricht dem regulären Ausdruck';
$lang['validation_regex_nomatch'] = 'Entspricht nicht dem regulären Ausdruck';
$lang['validation_empty'] = 'darf nicht leer sein';
$lang['required'] = 'benötigt';
$lang['not_required'] = 'nicht benötigt';
$lang['not_available'] = 'nicht verfügbar';
$lang['error_emailfromfeuprop'] = 'Fehler in den Feldeinstellungen';
$lang['error_nofeu'] = 'Das FrontEndUsers-Modul wurde nicht gefunden. Dieses Feld hat keine Funktion.';
$lang['error_nofeudefns'] = 'Keine passende FEU-Benutzer-Eigenschaft gefunden. Dieses Feld hat keine Funktion.';
$lang['required_field_missing'] = 'Für ein Pflichtfeld wurde kein Wert eingegeben';
$lang['please_enter_a_value'] = 'Bitte füllen Sie das Feld „%s“ aus.';
$lang['please_enter_a_number'] = 'Bitte geben Sie bei „%s“ eine Zahl ein.';
$lang['please_enter_valid'] = 'Bitte geben Sie bei „%s“ einen gültigen Eintrag ein.';
$lang['please_enter_an_integer'] = 'Bitte geben Sie bei „%s“ einen ganzzahligen Wert ein.';
$lang['please_enter_an_email'] = 'Bitte geben Sie bei „%s“ eine gültige E-Mail-Adresse ein.';
$lang['email_address_does_not_match'] = 'Die E-Mail-Adresse stimmt nicht mit der Eingabe in „%s“ überein.';
$lang['please_enter_a_phone'] = 'Bitte geben Sie bei „%s“ eine gültige Telefonnummer ein.';
$lang['please_login'] = 'Bitte melden Sie sich an, um dieses Formular zu verwenden!';
$lang['not_valid_email'] = '„%s“ scheint keine gültige E-Mail-Adresse zu sein.';
$lang['please_enter_no_longer'] = 'Bitte geben Sie einen Wert ein, der nicht länger als %s Zeichen ist.';
$lang['please_enter_at_least'] = 'Bitte geben Sie einen Wert ein, der mindestens %s Zeichen hat.';
$lang['title_list_delimiter'] = 'Zeichen, das als Trenner verwendet werden soll, wenn mehr als ein Wert als Ergebnis zurückgegeben wird';
$lang['you_need_permission'] = 'Sie benötigen die Berechtigung „%s“, um diese Aktion auszufü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öscht.';
$lang['field_deleted'] = 'Feld gelöscht.';
$lang['configuration_updated'] = 'Konfigurationen aktualisiert.';
$lang['you_must_check'] = 'Bevor Sie weitermachen können, müssen Sie „%s“ überprüfen.';
$lang['must_specify_one_destination'] = 'Sie müssen hier mindestens eine Zieladresse angeben!';
$lang['are_you_sure_delete_form'] = 'Wollen Sie das Formular „%s“ wirklich löschen?';
$lang['are_you_sure_delete_field'] = 'Wollen Sie das Feld „%s“ wirklich löschen?';
$lang['notice_select_type'] = 'Die erweiterten Optionen sind erst verfügbar, wenn der Feldtyp festgelegt wurde.';
$lang['field_name_in_use'] = 'Der Feldname „%s“ 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üssen einen Namen erhalten, oder Sie deaktivieren dies in der FormBuilder-Konfiguration.';
$lang['no_field_assigned'] = 'Kein Feld zugewiesen für %s';
$lang['anonymous'] = 'Anonym';
$lang['abbreviation_length'] = 'Länge: %s';
$lang['boxes'] = '%s Kontrollkästchen';
$lang['options'] = '%s Optionen';
$lang['text_length'] = '%s Zeichen';
$lang['order'] = 'Reihenfolge';
$lang['unspecified'] = '(nicht angegeben)';
$lang['added'] = 'hinzugefügt';
$lang['updated'] = 'aktualisiert';
$lang['sort_options'] = 'Optionen zur Sortierung bei der Ausgabe';
$lang['select_one'] = 'Eine Option auswählen';
$lang['select_type'] = 'Einen Typ auswählen';
$lang['to'] = 'An';
$lang['yes'] = 'Ja';
$lang['no'] = 'Nein';
$lang['recipients'] = 'Empfänger';
$lang['fields'] = 'Felder';
$lang['file_count'] = '%s mögliche Dateien';
$lang['destination_count'] = '%s Ziele';
$lang['save'] = 'Speichern';
$lang['add'] = 'Hinzufü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öße';
$lang['permitted_extensions'] = 'Dateierweiterungen';
$lang['permitted_filetypes'] = 'Erlaubte Dateitypen';
$lang['file_too_large'] = 'Die hochgeladene Datei ist zu groß! Die maximale Größe ist:';
$lang['illegal_file_type'] = 'Dieser Dateityp darf nicht hochgeladen werden. Bitte prüfen Sie, ob die Dateierweiterung korrekt ist.';
$lang['upload'] = 'Hochladen';
$lang['form_imported'] = 'Formular importiert.';
$lang['form_import_failed'] = 'Formular-Import fehlgeschlagen! 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öschen';
$lang['day'] = 'Tag';
$lang['mon'] = 'Monat';
$lang['year'] = 'Jahr';
$lang['none'] = '(keine Angabe)';
$lang['css'] = 'CSS';
$lang['notice'] = 'Hinweis';
$lang['general'] = 'Allgemein';
$lang['about'] = 'Über';
$lang['templates'] = 'Vorlagen';
$lang['advanced'] = 'Erweitert';
$lang['styling'] = 'Gestaltung';
$lang['team'] = 'Kollektiv';
$lang['contributors'] = 'Mitwirkende';
$lang['uninstalled'] = 'Modul deinstalliert.';
$lang['installed'] = 'Modulversion %s installiert.';
$lang['upgraded'] = 'Modul auf Version %s aktualisiert.';
$lang['button_previous'] = '< zurück';
$lang['button_submit'] = 'Formular absenden';
$lang['button_continue'] = 'weiter >';
$lang['value_checked'] = 'Geprüft';
$lang['value_unchecked'] = 'Ungeprüft';
$lang['tab_main'] = 'Hauptseite';
$lang['tab_symbol'] = 'Einstellungen fü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'] = 'Bestätigungs-Template';
$lang['tab_udt'] = 'Integration von benutzerdefinierten Tags';
$lang['title_feu_property'] = 'FrontEndUsers Benutzer-Eigenschaft';
$lang['info_feu_property'] = 'Es können nur bestimmte Eigenschaftstypen verwendet werden (Klappboxen, Mehrfachauswahl-Listen, etc).';
$lang['canuse_smarty'] = '<em>In diesem Feld sind auch Smarty-Variablen gültige Werte.<em>';
$lang['add_options'] = 'Weitere Optionen hinzufügen';
$lang['delete_options'] = 'Markierte Optionen löschen';
$lang['add_checkboxes'] = 'Weitere Kontrollkästchen hinzufügen';
$lang['delete_checkboxes'] = 'Markierte Kontrollkästchen löschen';
$lang['add_address'] = 'Eine weitere Adresse hinzufügen';
$lang['delete_address'] = 'Markierte Adressen löschen';
$lang['add_destination'] = 'Ein weiteres Ziel hinzufügen';
$lang['delete_destination'] = 'Markierte Ziele löschen';
$lang['suspected_spam'] = 'Von Ihrer IP-Adresse wurden zu viele E-Mails versandt. Es wurde daher vorbeugend ein Anti-Spam-Code ausgegeben.';
$lang['suspected_spam_log'] = 'Verdächtiger Spam von der IP %s wurde gestoppt.';
$lang['reorder'] = 'Felder neu ordnen';
$lang['cancel'] = 'Abbrechen';
$lang['value_set'] = 'Festgelegter Wert: %s';
$lang['help_cataloger_attribute_fields'] = 'Im folgenden finden Sie eine Liste von Attributen, die vom Cataloger-Modul verfügbar sind.<br/>Optional können Sie gültige Bereiche, Werte oder mehrere Werte festlegen, die zur Filterung der Einträge verwendet werden können, die den Besuchern angezeigt werden.<br/>
<br/>
<strong>Bereiche:</strong><br/>
Verwenden Sie den Syntax: "range: minWert to maxWert", um einen minimalen und einen maximalen Wert festzulegen.<br/>
<br/>
<strong>Mehrere Werte:</strong><br/>
 Verwenden Sie den Syntax "multi: Wert1|Wert2|Wert3", um mehrere Werte für ein Attribut festzulegen.<br/>
<br/>
<strong>Werte der verborgenen Felder</strong><br/>
Verwenden Sie den Syntax {$fld_id}, um einen Wert für ein verborgenes Feld festzulegen.<br/>
<br/>';
$lang['title_textfield_label'] = 'Textfeld-Etikett';
$lang['title_show_textfield'] = 'Textfeld anzeigen?';
$lang['help_name_regex'] = 'Ein regulärer Ausdruck, der es ermöglicht, Cataloger-Einträge nach dem Namen zu filtern';
$lang['help_field_height'] = 'Die Höhe des Feldes zur Mehrfachauswahl';
$lang['title_name_regex'] = 'Regulärer Ausdruck für die Namen von Cataloger-Einträgen';
$lang['title_field_height'] = 'Feldhöhe';
$lang['title_file_path'] = 'Zielverzeichnis für die ausgegebenen Dateien';
$lang['title_udt_name'] = 'Benutzerdefinierter Tag';
$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 übergeben';
$lang['title_allow_overwrite'] = 'Können Uploads vorhandene Dateien überschreiben?';
$lang['title_allow_overwrite_long'] = 'Können Uploads bereits vorhandene Dateien mit dem gleichen Dateinamen überschreiben?';
$lang['overwrite'] = 'Ermöglicht Überschreiben';
$lang['nooverwrite'] = 'Kein Überschreiben';
$lang['file_already_exists'] = 'Datei %s existiert bereits und kann nicht überschrieben werden.';
$lang['title_file_rename'] = 'Dateinamenvorlage';
$lang['original_file_extension'] = 'Original Dateierweiterung (umfasst den „.“)';
$lang['title_suppress_filename'] = 'Unterdrückt Dateinamen in E-Mails und Formularen die der Endbenutzer sieht';
$lang['title_suppress_attachment'] = 'Datei darf nicht an E-Mails angehängt werden';
$lang['file_rename_help'] = 'Eine Vorlage für den neuen Dateinamen der nach dem Upload vergeben wird. Lassen Sie dieses Feld leer, um den Originaldateinamen beizubehalten.';
$lang['title_legend'] = 'Legende';
$lang['title_maximum_length'] = 'Maximale Länge';
$lang['title_checkbox_label'] = 'Beschriftung des Kontrollkä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ästchen-Gruppe';
$lang['title_delete'] = 'Löschen?';
$lang['title_select_one_message'] = 'Text für „Bitte auswählen“';
$lang['title_selection_value'] = 'Auswahl Wert';
$lang['title_selection_displayname'] = 'Auswahl des angezeigten Namens';
$lang['title_selection_subject'] = 'Auswahl des „Betreffs“';
$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'] = 'Übermittelter Wert';
$lang['title_pulldown_details'] = 'Listenfeld-Optionen';
$lang['title_multiselect_details'] = 'Optionen zur Mehrfachauswahl';
$lang['title_destination_address'] = 'Ziel-E-Mail-Adresse';
$lang['title_destination_filename'] = 'Name der Zieldatei';
$lang['title_email_from_name'] = '„Von (Name)“ der E-Mail';
$lang['title_relaxed_email_regex'] = 'Lockere E-Mail-Überprüfung verwenden';
$lang['title_relaxed_regex_long'] = 'Verwendet eine lockere Überprüfung der E-Mail (erlaubt z. Bsp. „x@y“ anstatt des erforderlichen „x@y.de“)';
$lang['title_email_from_address'] = '„Von (E-Mail-Adresse)“ der E-Mail';
$lang['title_email_encoding'] = 'Zeichenkodierung der E-Mail';
$lang['title_director_details'] = 'Listenfeldbasierte E-Mail-Details';
$lang['title_file_name'] = 'Dateiname';
$lang['title_email_subject'] = 'Betreffzeile der E-Mail';
$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ügen Sie ein Feld hinzu, mit dem die Benutzereingaben verarbeitet werden. Sie können';
$lang['title_not_ready_link'] = 'diese Tastenkombination verwenden,';
$lang['title_form_alias'] = 'Formular-Alias';
$lang['title_field_alias_short'] = 'Alias';
$lang['title_form_fields'] = 'Formularfelder';
$lang['title_field_id'] = 'Feld-ID';
$lang['title_show_fieldaliases'] = 'Feld-Aliase 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ügen';
$lang['title_show_version'] = 'Version des FormBuilder-Moduls anzeigen?';
$lang['title_show_version_long'] = 'Als Hilfe zur Fehlerbeseitigung wird die Versionsnummer des FormBuilder-Moduls in einem Kommentar eingebettet.';
$lang['title_add_new_field'] = 'Neues Feld hinzufügen';
$lang['title_form_submit_button'] = 'Text für den „Absenden“-Knopf';
$lang['title_button_text'] = 'Knopf-Text';
$lang['title_submit_button_safety'] = 'Soll dem Versenden-Knopf ein Javascript hinzugefügt werden, um den mehrfachen Versand des Formulars zu verhindern?';
$lang['title_submit_button_safety_help'] = 'Sicherheitsscript hinzufügen';
$lang['title_form_next_button'] = 'Text für den „Weiter“-Knopf (für mehrseitige Formulare)';
$lang['title_form_prev_button'] = 'Text für den „Zurück“-Knopf (für mehrseitige Formulare)';
$lang['title_field_validation'] = 'Feld-Überprüfung';
$lang['title_field_to_validate'] = 'Zu überprüfendes Feld';
$lang['title_field_css_id'] = 'CSS-ID für dieses Feld';
$lang['title_form_css_class'] = 'CSS-Klasse für dieses Formular';
$lang['title_field_css_class'] = 'CSS-Klasse für dieses Feld';
$lang['title_form_predisplay_udt'] = 'Benutzerdefinierter Tag, der vor der Anzeige des Formulars ausgeführt werden soll';
$lang['title_form_predisplay_each_udt'] = 'Benutzerdefinierter Tag, der vor der Anzeige des Formulars aufgerufen wird (bei mehrseitigen Formularen wird er bei jeder einzelnen Seite des Formulars aufgerufen)';
$lang['title_form_validate_udt'] = 'Benutzerdefinierter Tag, der während der Formularprüfung aufgerufen wird';
$lang['title_form_required_symbol'] = 'Symbol zur Kennzeichnung der Pflichtfelder';
$lang['title_field_required'] = 'Pflichtfeld';
$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_textarea_length'] = 'Maximale Länge des Feldinhalts (0 oder leer bedeutet ohne Limit)';
$lang['title_text'] = 'Anzuzeigender statischer Text';
$lang['title_field_regex'] = 'Regex-Überprüfung';
$lang['title_lines_to_show'] = 'Anzahl der anzuzeigenden Zeilen';
$lang['title_read_only'] = 'Nur lesen';
$lang['no_default'] = 'Keine Voreinstellung';
$lang['redirect_after_approval'] = 'Seite, auf die nach Überprüfung weitergeleitet wird';
$lang['title_regex_help'] = 'Dieser reguläre Ausdruck wird nur verwendet, wenn die Art der Überprüfung auf eine Regex-Option eingestellt ist. Geben Sie einen vollständigen regulären Ausdruck in Perl-Syntax ein, einschließlich Schrägstrichen am Anfang und Ende und “Flags”; z. B.: <code>/image\.(\d+)/i</code>';
$lang['title_field_required_abbrev'] = 'Pflichtfeld';
$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'] = 'E-Mail-Vorlage';
$lang['title_maximum_size'] = 'Maximale Größe für hochzuladende Dateien (in KB)';
$lang['title_maximum_size_long'] = 'Dieses Limit ist eine Ergänzung der Vorgaben aus der PHP- oder Server-Konfiguration.';
$lang['title_file_destination'] = 'Das Verzeichnis, in das die Dateien gespeichert werden sollen';
$lang['title_permitted_extensions'] = 'Zugelassene Dateiendungen';
$lang['title_permitted_extensions_long'] = 'Geben Sie hier eine Aufzählung der zugelassenen Dateiendungen jeweils getrennt duch ein Komma ein (ohne Punkt, z. B. „jpg,gif,jpeg“). Leerzeichen werden ignoriert. Ohne Eintrag gelten keine Beschränkungen.';
$lang['title_show_limitations'] = 'Beschränkungen anzeigen?';
$lang['title_show_limitations_long'] = 'Beschränkungen der Größe und der Dateiendungen mit dem Upload-Feld anzeigen?';
$lang['title_form_template'] = 'Vorlage fü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ückgegeben wird';
$lang['title_enable_fastadd_long'] = 'Das Listenfeld für schnelles Hinzufügen von Feldern in Formularen aktivieren?';
$lang['title_enable_fastadd'] = 'Das Listenfeld für schnelles Hinzufügen von Feldern aktivieren?';
$lang['title_fastadd'] = 'Schnelle Felderstellung';
$lang['title_enable_antispam_long'] = 'Wenn Sie dies aktivieren, können pro IP-Adresse maximal 10 E-Mails 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-E-Mail erzeugen?';
$lang['title_link_autopopulate'] = 'Automatisch veröffentlichen?';
$lang['title_link_autopopulate_help'] = 'Automatisch mit der URL der Formularseite veröffentlichen? (dies ü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önnen Sie über ein <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">„CAPTCHA“</a> Ihr Formular vor Spam schü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ützen?';
$lang['title_use_captcha_help'] = 'Aktivieren Sie dieses Feld, um Ihr Formular mittels <a href="http://www.wikipedia.org/wiki/Captcha" target="_blank">"Captcha"</a> vor Spam zu schützen.';
$lang['title_user_captcha'] = 'Bitte bestä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ür CAPTCHA';
$lang['title_dont_submit_unchecked'] = 'Für nicht aktivierte Kontrollkästchen keine Werte übermitteln';
$lang['title_dont_submit_unchecked_help'] = 'Aktivieren Sie dies, wenn nur bei aktiviertem Kontrollkästchen Werte zurückgegeben werden sollen.';
$lang['link_label'] = 'Beschriftung des Links';
$lang['link_destination'] = 'Ziel-URL des Links';
$lang['title_default_set'] = 'Häkchen voreingestellt setzen?';
$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 überschrieben werden)';
$lang['title_textarea_cols'] = 'Spalten (Hinweis: Dies kann durch CSS überschrieben werden)';
$lang['title_form_main'] = 'Details des Hauptformulars';
$lang['title_default_blank'] = 'Voreingestellt leer';
$lang['title_default_blank_help'] = 'Voreingestellt leer (deaktiviert die Voreinstellung für das heutige Datum)';
$lang['title_show_username'] = 'Den Anmelde-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änken';
$lang['title_encrypt_database_data'] = 'Verschlüsseln von in der Datenbank gespeicherten Daten';
$lang['title_crypt_cert'] = 'Zertifikat für die Verschlüsselung von Daten';
$lang['title_encryption_keyfile'] = 'Kennwortsatz oder Pfad zu einer Datei die den Kennwortsatz enthält. (Bei verwendung von OpenSSL ist dies der Kennwortsatz für den privaten Schlüssel)';
$lang['title_encrypt_sortfields'] = 'Hash sort fields?';
$lang['title_private_key'] = 'Privater Schlüssel für die Datenverschlüsselung';
$lang['title_encrypt_sortfields_help'] = 'This hashes the sort fields, but leaves the first few letters unencrypted. Cryptographically, this creates a vulnerability, but for most users it is an acceptable tradeoff between security and the ability to sort records. Sorting becomes approximate, but will remain pretty good. If you do not use this option, sort fields are stored in plaintext.';
$lang['title_encryption_functions'] = 'Verschlüsselte Speicherung nicht verfügbar';
$lang['title_install_crypto'] = 'Bitte installieren Sie das OpenSSL Modul oder die PHP mcrypt Bibliothek wenn Sie verschlüsselte Daten in der Datenbank speichern möchten.';
$lang['title_install_curl'] = 'Bitte prüfen Sie ob Ihre PHP Installation CURL unterstützt. Siehe auch http://www.php.net/manual/de/book.curl.php';
$lang['title_mle_version'] = 'Im Mehrsprachenmodus (MLE) starten';
$lang['title_mle_version_long'] = 'Changes/support for CMSMS Multi-Language Edition fork. Do not check this if you are not running the MLE version.';
$lang['title_ensure_cert_key_match'] = 'Ensure that you select the private key that is appropriate for the certificate you are using for encryption!';
$lang['choose_crypt'] = 'Verschlüsselungsbibliothek';
$lang['title_encrypt_database_long'] = 'Check this to encrypt the stored data. This makes it more difficult (but not impossible) for hackers to view the information.';
$lang['choose_crypt_long'] = 'The options below only apply if you are using the OpenSSL Encryption library';
$lang['title_crypt_lib'] = 'Verschlüsselungsbibliothek';
$lang['openssl'] = 'OpenSSL-Bibliothek';
$lang['mcrypt'] = 'PHP mcrypt Bibliothek';
$lang['title_install_listit2'] = 'Zur Übermittlung der Daten an das Modul „ListItExtended“, muss es überhaupt installiert sein';
$lang['title_listit2_instance'] = 'ListItExtended-Instanz';
$lang['title_feu_binding'] = 'Verbindung mit Frontend-User-Modul';
$lang['title_install_feu'] = 'Bitte installieren Sie das Frontend-User-Modul, um ein Formular und dessen Daten mit einem bestimmten Benutzer zu verbinden.';
$lang['title_feu_bind_help'] = 'Check this to lock front-end access to this form\'s data to the logged-in front-end user.';
$lang['title_encryption'] = 'Verschlüsselung';
$lang['title_export_form_to_udt'] = 'Export form reference to UDT as $params[\'FORM\']?';
$lang['title_url_help'] = 'Vollständige URL, inklusive Protokoll und Verzeichnispfad (z.B. http://myhost.com/form_handler.cgi)';
$lang['title_url'] = 'Formular-Empfänger-URL';
$lang['title_method'] = 'Formularmethode';
$lang['title_maps_to'] = 'Feld „%s“ einer Formularabsendungsvariable zuweisen';
$lang['title_maps_to_field'] = 'Feld „%s“ diesem Feld zuweisen:';
$lang['title_additional'] = 'zusätzliche Datenübermittlung';
$lang['title_additional_help'] = 'Anything to be appended to the submission payload, in URL-encoded form (.e.g, "user=steve+jobs&employee_number=1)';
$lang['title_include_in_submission'] = 'Feld in Übermittlung einschließen';
$lang['title_date_order'] = 'Date component field order (for input)';
$lang['title_data_stored_in_fbr'] = 'Data will be stored in an XML format in the [PREFIX]_module_fb_frombrowser database table.';
$lang['error_has_no_fb_field'] = 'Error! Either the form has no form_builder disposition, or it failed to instantiate (due to memory issues?)';
$lang['help_date_order'] = 'Format: „m“ für Monat, „d“ für Tag, und „y“ für Jahr; Werte durch Bindestriche trennen';
$lang['restricted_to_group'] = 'Nur in Gruppe %s';
$lang['title_show_to_user'] = 'Dem Benutzer anzeigen?';
$lang['title_use_random_generator'] = 'Verwende zufällige Zahlen statt fest vorgegebener';
$lang['title_numbers_to_generate'] = 'Anzahl der generierten Nummern';
$lang['help_leaveempty'] = 'Dieses Feld kann leer gelassen werden';
$lang['help_variables_for_template'] = 'Variablen für die Vorlage';
$lang['help_variables_for_computation'] = 'Verfü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_ignored_if_upload'] = '(Dieses Feld wird bei Verwendung des Uploads Moduls ignoriert)';
$lang['help_other_fields'] = 'Alternative Feldnamen können wechselweise verwendet werden (dies ist insbesondere dann nützlich, wenn Smarty Probleme mit Zeichen außerhalb von ASCII 32-126 hat). <br />Wenn Sie diese dem Formular hinzufügen, sind weitere Felder verfügbar.';
$lang['help_array_fields'] = 'Dies ist eine weitere Option, um via $fieldname_obj, $alias_obj oder $fld_#_obj die Feldwerte abzufragen (jedes Feld enthält ein Objekt):<br />
<table>
<tr class=\'odd\'><td>name</td><td>Feld-name</td></tr>
<tr><td>type</td><td>Feldtyp</td></tr>
<tr class=\'odd\'><td>id</td><td>Interne Feld-ID</td></tr>
<tr><td>value</td><td>Menschen-lesbarer Wert</td></tr>
<tr class=\'odd\'><td>valueArray</td><td>Array der Feldwerte</td></tr>
</table>
<em>Beispiel:</em>{$fld_1_obj->name} = {$fld_1_obj->value}';
$lang['help_date_format'] = 'Informationen zur Formatierung finden Sie <a href="http://de.php.net/manual/de/function.date.php">in der PHP-Beschreibung</a>.';
$lang['help_variable_name'] = 'Variable';
$lang['help_form_field'] = 'Dieses Feld enthält';
$lang['help_rtf_file_template'] = 'Geben Sie eine Datei im FormBuilder/templates/ Ordner an. Bei Dateityp TXT wird dieses Feld ignoriert.';
$lang['help_rtf_template_type'] = 'Basic: Use the textarea below to layout the field names/values in a single block.<br />
Advanced: Specify Smarty variables in the RTF Template File as you would below, but arrange them however you like and add formatting.<br />
&nbsp;You can still use the %%HEADER%% and %%FOOTER%% sections in the RTF file.';
$lang['help_unique_file_template'] = 'For TXT, this will be immediately after the Header Template.<br />
For RTF, this will replace the %%FIELDS%% string in the template file if RTF Template Type is set to "Basic".<br />
This field will be ignored if using "RTF" as File Type and "Advanced" as RTF Template Type.';
$lang['help_file_header_template'] = 'Bei TXT am Anfang der Datei plaziert. Bei RTF wird der Platzhalter %%HEADER%% in der Template-Datei ersetzt.';
$lang['help_file_footer_template'] = 'Bei TXT am Ende der Datei plaziert. Bei RTF wird der Platzhalter %%FOOTER%% in der Template-Datei ersetzt.';
$lang['link_back_to_form'] = '« Zurück zum Formular';
$lang['title_create_sample_template'] = 'Eine Beispiel-Vorlage erstellen';
$lang['title_create_sample_html_template'] = 'Eine Beispiel-HTML-Vorlage erstellen';
$lang['title_create_sample_header_template'] = 'Eine Beispiel-Header-Vorlage erstellen';
$lang['title_create_sample_footer_template'] = 'Eine Beispiel-Footer-Vorlage erstellen';
$lang['title_create_sample_header'] = 'Einen Beispiel-Header erstellen';
$lang['help_tab_symbol'] = 'ein Tabulator-Zeichen';
$lang['title_file_template'] = 'Vorlage für eine Zeile der ausgegebenen Datei';
$lang['title_file_header'] = 'Vorlage für den Header der ausgegebenen Datei';
$lang['title_file_footer'] = 'Vorlage für den Footer der ausgegebenen Datei';
$lang['title_rtf_file_template'] = 'Vorlage einer zu verwendenden RTF-Datei';
$lang['title_unique_file_template'] = 'Vorlage für Ausgabe';
$lang['title_file_type'] = 'Einen Dateitypen wählen';
$lang['title_rtf_template_type'] = 'Einen RTF-Vorlagentypen wählen';
$lang['title_confirmation_url'] = 'URL zur Bestä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://de.php.net/manual/de/function.date.php" target="_blank">PHP-Datumsformat</a>)';
$lang['title_use_wysiwyg'] = 'WYSIWYG-Editor für den Textbereich verwenden (nur in der Administration)?';
$lang['title_submit_actions'] = 'Verhalten nach dem Formularversand';
$lang['title_submit_labels'] = 'Beschriftung der „Senden“-Knopfs';
$lang['title_sortable_field'] = 'Sortierbares Feld Nr. %s';
$lang['title_submit_help'] = 'Auf dieser Seite können Sie den Formularversand anpassen. Es wird jedoch NICHT festgelegt, wie die versandten Daten verarbeitet werden. Dafür müssen Sie Ihrem Formular ein separates Feld hinzufügen.';
$lang['title_start_year'] = 'Beginn Jahresbereich';
$lang['title_end_year'] = 'Ende Jahresbereich';
$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['title_submit_date'] = 'Datum übermittelt';
$lang['title_approval_date'] = 'Datum geprüft (durch den Administrator)';
$lang['title_user_approved'] = 'Datum geprüft (durch den Versender)';
$lang['display_text'] = 'Versand-Vorlage 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 E-Mails zu erzeugen oder andere Formular-Optionen auszuführen. Falls erwünscht, können Sie diese Templates in der „erweiterten“ Registerkarte für diese Felder festlegen.';
$lang['title_destination_page'] = 'Zielseite';
$lang['title_require_fieldnames'] = 'Erfordert Feldnamen';
$lang['title_require_fieldnames_long'] = 'Soll für die Felder ein Name festgelegt werden?';
$lang['title_unique_fieldnames'] = 'Erfordert eindeutige Feldnamen';
$lang['title_unique_fieldnames_long'] = 'Soll für die Felder ein eindeutiger Name festgelegt werden?';
$lang['title_reorder_form'] = 'Felder neu ordnen';
$lang['title_load_template'] = 'Vorlage laden';
$lang['title_add_button_text'] = 'Einen Text für den Knopf hinzufügen';
$lang['title_del_button_text'] = 'Den Text für den Knopf löschen';
$lang['title_field_helptext'] = 'Hilfetext, der für dieses Feld angezeigt wird';
$lang['title_string_or_number_eval'] = 'Variablen als Zahl oder String interpretieren';
$lang['title_order'] = 'Interpretationsreihenfolge';
$lang['title_order_help'] = 'Wenn mehr als ein Feld berechnet werden muss, werden die Berechnung von der niedrigsten zur höchsten Ordnungsnummer hin durchgeführt';
$lang['title_string_unspaced'] = 'Zeichenkette (keine Leerzeichen zwischen den Feldern)?';
$lang['title_compute_value'] = 'Zu berechnender Wert';
$lang['title_compute'] = 'Berechnet/PHP';
$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ür das Feld';
$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. Da dafür JavaScript verwendet wird, tritt ein Fehler auf, wenn Sie in dem vorgegebenen Text einfache Anführungszeichen (" oder \') verwenden. Verwenden sie daher typografisch korrekte Anführungszeichen (→ http://de.wikipedia.org/wiki/Anf%C3%BChrungszeichen#Direkte_Eingabe_per_Tastatur). Ein JavaScript-Fehler kann auch bei anderen JavaScript-unfreundlichen Zeichen auftreten.';
$lang['title_remove_file_from_server'] = 'Eine hochgeladene Datei nach der Verarbeitung (E-Mail-Versand) vom Server löschen';
$lang['title_field_javascript'] = 'JavaScript für das Feld';
$lang['title_field_javascript_long'] = 'Einen vollständigen JavaScript-Aufruf eingeben, einschließlich des Ereignisses, auf das reagiert werden soll, z. B. <code>onclick="yourfn()"</code>';
$lang['title_submit_javascript'] = 'JavaScript für den Formularversand';
$lang['title_submit_javascript_long'] = 'Einen vollständigen Javascript-Aufruf erstellen, einschließlich des Ereignisses, auf das reagiert werden soll, z. B. <code>onclick="yourfn()"</code>.<br />Dies funktioniert möglicherweise nicht richtig, wenn das Sicherheisskript verwendet wird.';
$lang['email_from_addr_help'] = 'Wählen Sie hier keine zufällige Adresse – einige Hosting-Anbieter versenden<br />keine E-Mails, wenn der Domainname nicht mit dem aktuellen<br />Hostnamen übereinstimmt (verwenden Sie zum Beispiel etwas wie name@%s)';
$lang['title_switch_advanced'] = 'Benötigen Sie noch mehr Feldtypen?';
$lang['title_switch_basic'] = 'Zu viele verwirrende Feldtypen?';
$lang['title_switch_advanced_link'] = 'In den erweiterten Modus wechseln';
$lang['title_switch_basic_link'] = 'In den einfachen Modus wechseln';
$lang['title_file_root'] = 'Datei in folgendem Verzeichnis speichern';
$lang['title_file_root_help'] = 'Für dieses Verzeichnis muss Ihr Webserver die Schreibberechtigung haben<br /> Setzen Sie diese bei Bedarf via chmod 777.<br />Außerdem sollten Sie darauf achten, dass keine PHP-Verzeichnis-Beschränkungen bestehen.';
$lang['title_newline_replacement'] = 'Zeichen, welches die Zeilenumbrüche ersetzen soll';
$lang['title_newline_replacement_help'] = 'Lassen Sie dieses Feld leer, wenn alle Zeilenumbrüche mit ausgegeben werden sollen';
$lang['title_send_usercopy'] = 'Dem Benutzer eine Kopie des Formulars schicken?';
$lang['title_send_usercopy_label'] = 'Beschriftung für das Kontrollkästchen (falls durch den Benutzer ausgewählt)';
$lang['title_send_me_a_copy'] = 'Mir eine Kopie des Formulars schicken';
$lang['title_allow_subject_override'] = 'Das Überschreiben des Betreffs erlauben?';
$lang['title_allow_subject_override_long'] = 'Damit erlauben Sie, dass der im Listenfeld festgelegte Betreff der E-Mail überschrieben werden kann.';
$lang['title_display_length'] = 'Anzeigelänge';
$lang['title_minimum_length'] = 'Minimale Antwortlänge';
$lang['title_hide'] = 'Eingabe verbergen';
$lang['title_hide_help'] = 'Sollen bei der Kennworteingabe Symbole anstatt einfachem Text angezeigt werden?';
$lang['password_does_not_match'] = 'Das Kennwort stimmt nicht mit %s überein!';
$lang['back_top'] = 'Zurück zur FormBuilder-Hauptseite';
$lang['title_headers_to_modify'] = 'Welche E-Mail-Header sollen diese Eingabe erhalten?';
$lang['title_blank_invalid'] = 'Leerzeichen nicht als gültigen Eintrag akzeptieren';
$lang['title_blank_invalid_long'] = 'Bei Pflichtfeldern muss der Benutzer alphanumerische Zeichen statt Leerzeichen eingeben.';
$lang['title_must_save_order'] = 'Sie müssen einen der „Speichern“-Knöpfe verwenden um die neue Feldreihenfolge zu übernehmen.';
$lang['title_html5'] = 'Im Text HTML5-Platzhalter anstatt Javascript verwenden';
$lang['title_email_cc_address'] = 'Adresse(n), an die eine Kopie gesendet werden soll. Mehrere Adressen durch Kommas trennen.';
$lang['title_use_bcc'] = 'Blindkopie senden';
$lang['title_send_using'] = 'E-Mail-Adressierung';
$lang['title_field_to_modify'] = 'E-Mail-Feld zum hinzufügen von CC-Adressen';
$lang['title_modifies'] = 'Kopie (CC) zu „%s“ hinzufügen';
$lang['bcc_field'] = 'Empfänger einer Blindkopie (BCC)';
$lang['cc_field'] = 'Empfänger einer Kopie (CC)';
$lang['to_field'] = 'Normale Empfänger';
$lang['bcc'] = 'Blindkopie';
$lang['cc'] = 'Kopie';
$lang['error_CompanyDirectory_module_not_available'] = 'Das CompanyDirectory-Modul ist nicht verfügbar!';
$lang['option_never'] = 'Niemals';
$lang['option_user_choice'] = 'Dem Benutzer eine Auswahl anbieten (Kontrollkästchen)';
$lang['option_always'] = 'Immer';
$lang['option_from'] = 'E-Mail-Adresse „Von“';
$lang['option_reply'] = 'E-Mail-Adresse „Antwort an“';
$lang['option_both'] = 'Beide E-Mail-Adressen („Von“ & „Antwort an“)';
$lang['option_dropdown'] = 'Aufklappmenü';
$lang['option_selectlist_single'] = 'Auswahlliste (einfach)';
$lang['option_selectlist_multiple'] = 'Auswahlliste (mehrfach)';
$lang['option_radiogroup'] = 'Radioknopf-Guppe';
$lang['title_company_field_note'] = 'Hinweis: Ausgabe im Format<br/>"Firmenname"=>"Wert"';
$lang['title_pick_categories'] = 'Wählen Sie eine Kategorie (oder mehrere)';
$lang['title_pick_fielddef'] = 'Pull a field Definition\'s value (single) <em>optional</em>';
$lang['title_choose_user_input'] = 'Wähle Benutzereingabe';
$lang['title_see_also_udt'] = '(Also take a look at the Form Submission tab if you want to set a UDT for form validation)';
$lang['title_year_end_message'] = 'Endjahr';
$lang['title_field_logic'] = 'Smarty-Daten oder -Logik, die mit diesem Feld gesendet werden sollen';
$lang['title_field_logic_long'] = 'Can be smarty data, javascript, or some other data you wan\'t to sent along with this field.<br />Goes through the Smarty compiler, so remember use {literal}{/literal} tags with <script></script>';
$lang['title_field_includelabels'] = 'Labels einschliessen';
$lang['title_field_includelabels_help'] = 'Enabling this includes labels to output. example - label: value,label2: value2';
$lang['title_field_siblings'] = 'Dieses Feld mit seinen Geschwistern verknüpfen';
$lang['title_field_siblings_help'] = 'Dropdown lists all siblings of this field and allows you to link this field to one of it\'s sibling. Makes possible controlling this field with selected sibling controls.';
$lang['title_field_hidebuttons'] = 'Verstecke Kontrollbuttons';
$lang['title_field_hidebuttons_help'] = 'Hides frontend control buttons of this field.';
$lang['title_note'] = 'Hinweis';
$lang['title_changing_triggers_reindex'] = 'Changing any of the above fields will trigger a reindex of *all* saved records, so it could take a while.';
$lang['illegal_file'] = 'Attempted upload of illegal file type (%s) from %s';
$lang['title_searchable'] = 'Einträge dem Such-Modul zugänglich machen';
$lang['title_searchable_help'] = 'Checking this will make all submitted data accessible to the Search Module. DO NOT use this if you encrypt your data -- the information gets exposed to search whether or not it is encrypted!';
$lang['uploaded_outside_webroot'] = '%s (außerhalb des Web-Wurzelverzeichnisses)';
$lang['title_fbr_edit'] = 'Veränderbar im FormBrowser-Admin?';
$lang['title_active_only'] = 'Sollen nur aktive Benuter inkludiert werden?';
$lang['error_usertag_disposition'] = 'Der benutzerdefinierte Tag hat einen Fehler zurückgegeben';
$lang['error_usertag'] = 'Der benutzerdefinierte Tag %s hat einen Fehler zurückgegeben.';
$lang['error_cataloger_module_not_available'] = '<strong>Das Cataloger-Modul scheint nicht installiert oder aktiv zu sein.</strong>';
$lang['warning'] = 'WARNUNG!';
$lang['default_template'] = 'Standardvorlage';
$lang['table_left_template'] = 'Tabellenvorlage, Titel links';
$lang['table_top_template'] = 'Tabellenvorlage, Titel oben';
$lang['form_template_name'] = 'Vorlage von %s';
$lang['template_are_you_sure'] = 'Wollen Sie wirklich Ihre Vorlage mit der ausgewählten Vorlage überschreiben? (Auch, wenn Sie dies bestätigen, müssen Sie die Änderung speichern)';
$lang['title_bad_function'] = 'Fehler beim Berechnen von „%s“.';
$lang['no_referrer_info'] = 'Keine Informationen über den HTTP_REFERER verfügbar (wahrscheinlich aufgrund der verwendeten E-Mail-Prüfung)';
$lang['validation_param_error'] = 'Fehler beim Überprüfen der Parameter. Bitte stellen Sie sicher, dass die URL aus Ihrer E-Mail korrekt kopiert wurde!';
$lang['validation_response_error'] = 'Fehler bei der Überprüfung. Bitte stellen Sie sicher, dass die URL aus Ihrer E-Mail korrekt kopiert wurde!';
$lang['validation_no_field_error'] = 'Fehler bei der Überprüfung. Dieses Formular enthält kein Feld zur Überprüfung der E-Mail!';
$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'] = 'Hinzufügen, Bearbeiten und Verwalten von interaktiven Formularen';
$lang['must_specify_one_admin'] = 'Sie müssen einen Administrator angeben';
$lang['operators_help'] = 'If you use String evaluation, the only operation available is concatenation (+). If you use Number evaluation you have basic, very simple math (, +, -, *, /, ). If you use Computed/PHP evaluation, you can
use any function you want, but you need to quote things (substitution occurs before evaluation), e.g., substr(\'$fld_22\',0,2).\'$fld_23\'.';
$lang['help_module_interface'] = 'Modul-Schnittstelle verwenden';
$lang['help_module_interface_long'] = '<b>This field is used as a gateway to other modules!</b>
Use it by creating your form elements in the templates of the other module(s) you wish to incorporate, and using the <strong>{$FBid}</strong> to tie it back to FormBuilder. For example, to include form options based on the Products module, create the following template in Products:<br/>
<pre>
{foreach from=$items item=entry}
	{assign var=MData value=\'\'}
	{assign var=Cd value=\'\'}
		{foreach from=$FBvalue item=MData}
			{assign var=MData value=\'::\'|explode:$MData}
			{if $MData[1]==$entry->id}
				{assign var=Cd value=\' checked="checked"\'}
			{/if}
		{/foreach}
	<div class="ProductDirectoryItem">
		<input type="checkbox" value="{$entry->price}::{$entry->id}" name="{$FBid}[]" {$Cd} />{$entry->product_name} ({$entry->weight}{$weight_units}) £{$entry->price}    
	</div>
{/foreach}
</pre>
<br/>
where in the input below you put something like <strong>{Products category="cat" summarytemplate="Your_FB_template"}</strong>';
$lang['title_add_tag'] = 'Ihren Tag hinzufügen';
$lang['date_january'] = 'Januar';
$lang['date_february'] = 'Februar';
$lang['date_march'] = 'Mä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['AF'] = 'Afghanistan';
$lang['AX'] = 'Aland Inseln';
$lang['AL'] = 'Albanien';
$lang['DZ'] = 'Algerien';
$lang['AS'] = 'Amerikanisch Samoa';
$lang['AD'] = 'Andorra';
$lang['AO'] = 'Angola';
$lang['AI'] = 'Anguilla';
$lang['AQ'] = 'Antarktis';
$lang['AG'] = 'Antigua und Barbuda';
$lang['AR'] = 'Argentinien';
$lang['AM'] = 'Armenien';
$lang['AW'] = 'Aruba';
$lang['AU'] = 'Australien';
$lang['AT'] = 'Österreich';
$lang['AZ'] = 'Aserbaidschan';
$lang['BS'] = 'Bahamas';
$lang['BH'] = 'Bahrain';
$lang['BB'] = 'Barbados';
$lang['BD'] = 'Bangladesch';
$lang['BY'] = 'Weißrussland';
$lang['BE'] = 'Belgien';
$lang['BZ'] = 'Belize';
$lang['BJ'] = 'Benin';
$lang['BM'] = 'Bermuda';
$lang['BT'] = 'Bhutan';
$lang['BW'] = 'Botswana';
$lang['BO'] = 'Bolivien';
$lang['BA'] = 'Bosnien und Herzegowina';
$lang['BV'] = 'Bouvet-Insel';
$lang['BR'] = 'Brasilien';
$lang['IO'] = 'Britisches Territorium im Indischen Ozean';
$lang['BN'] = 'Brunei Darussalam';
$lang['BG'] = 'Bulgarien';
$lang['BF'] = 'Burkina Faso';
$lang['BI'] = 'Burundi';
$lang['KH'] = 'Kambodscha';
$lang['CM'] = 'Kamerun';
$lang['CA'] = 'Kanada';
$lang['CV'] = 'Kap Verde';
$lang['KY'] = 'Cayman-Inseln';
$lang['CF'] = 'Zentralafrikanische Republik';
$lang['TD'] = 'Tschad';
$lang['CL'] = 'Chile';
$lang['CN'] = 'China';
$lang['CX'] = 'Weihnachtsinseln';
$lang['CC'] = 'Cocos (Keeling) Inseln';
$lang['CO'] = 'Kolumbien';
$lang['KM'] = 'Comoros';
$lang['CG'] = 'Kongo';
$lang['CD'] = 'Kongo, Demokratische Republik';
$lang['CK'] = 'Osterinseln';
$lang['CR'] = 'Costa Rica';
$lang['CI'] = 'Ivoire (Elfenbeinküste)';
$lang['HR'] = 'Kroatien (Hrvatska)';
$lang['CU'] = 'Kuba';
$lang['CY'] = 'Zypern';
$lang['CZ'] = 'Tschechische Republik';
$lang['DK'] = 'Dänemark';
$lang['DJ'] = 'Djibouti';
$lang['DM'] = 'Dominica';
$lang['DO'] = 'Dominikanische Republik';
$lang['TP'] = 'Östlicher Timor';
$lang['EC'] = 'Ecuador';
$lang['EG'] = 'Ägypten';
$lang['SV'] = 'El Salvador';
$lang['GQ'] = 'Äquatorial Guinea';
$lang['ER'] = 'Eritrea';
$lang['EE'] = 'Estland';
$lang['ET'] = 'Äthiopien';
$lang['FK'] = 'Falkland-Inseln (Malvinas)';
$lang['FO'] = 'Faroe Inseln';
$lang['FJ'] = 'Fiji';
$lang['FI'] = 'Finnland';
$lang['FR'] = 'Frankreich';
$lang['FX'] = 'Frankreich';
$lang['GF'] = 'Guernsey';
$lang['PF'] = 'Französisch Polynesien';
$lang['TF'] = 'Französische Südliche Territorien';
$lang['MK'] = 'F.Y.R.O.M. (Mazedonien)';
$lang['GA'] = 'Gabun';
$lang['GM'] = 'Gambia';
$lang['GE'] = 'Georgien';
$lang['DE'] = 'Deutschland';
$lang['GH'] = 'Ghana';
$lang['GI'] = 'Gibraltar';
$lang['GB'] = 'Großbritannien (UK)';
$lang['GR'] = 'Griechenland';
$lang['GL'] = 'Grönland';
$lang['GD'] = 'Grenada';
$lang['GP'] = 'Guadeloupe';
$lang['GU'] = 'Guam';
$lang['GT'] = 'Guatemala';
$lang['GN'] = 'Guinea';
$lang['GW'] = 'Guinea-Bissau';
$lang['GY'] = 'Guyana';
$lang['HT'] = 'Haiti';
$lang['HM'] = 'Hörten und McDonald Inseln';
$lang['HN'] = 'Honduras';
$lang['HK'] = 'Hongkong';
$lang['HU'] = 'Ungarn';
$lang['IS'] = 'Island';
$lang['IN'] = 'Indien';
$lang['ID'] = 'Indonesien';
$lang['IR'] = 'Iran';
$lang['IQ'] = 'Irak';
$lang['IE'] = 'Irland';
$lang['IL'] = 'Israel';
$lang['IM'] = 'Isle of Man';
$lang['IT'] = 'Italien';
$lang['JE'] = 'Jersey';
$lang['JM'] = 'Jamaika';
$lang['JP'] = 'Japan';
$lang['JO'] = 'Jordanien';
$lang['KZ'] = 'Kasachstan';
$lang['KE'] = 'Kenia';
$lang['KI'] = 'Kiribati';
$lang['KP'] = 'Nordkorea';
$lang['KR'] = 'Südkorea';
$lang['KW'] = 'Kuwait';
$lang['KG'] = 'Kirgisistan';
$lang['LA'] = 'Laos';
$lang['LV'] = 'Lettland';
$lang['LB'] = 'Libanon';
$lang['LI'] = 'Liechtenstein';
$lang['LR'] = 'Liberien';
$lang['LY'] = 'Libyen';
$lang['LS'] = 'Lesotho';
$lang['LT'] = 'Litauen';
$lang['LU'] = 'Luxemburg';
$lang['MO'] = 'Macau';
$lang['MG'] = 'Madagaskar';
$lang['MW'] = 'Malawi';
$lang['MY'] = 'Malaysia';
$lang['MV'] = 'Maldiven';
$lang['ML'] = 'Mali';
$lang['MT'] = 'Malta';
$lang['MH'] = 'Inseln von Marschall';
$lang['MQ'] = 'Martinique';
$lang['MR'] = 'Mauretanien';
$lang['MU'] = 'Mauritius';
$lang['YT'] = 'Mayotte';
$lang['MX'] = 'Mexiko';
$lang['FM'] = 'Mikronesien';
$lang['MC'] = 'Monako';
$lang['MD'] = 'Moldawien';
$lang['MA'] = 'Marokko';
$lang['MN'] = 'Mongolei';
$lang['MS'] = 'Montserrat';
$lang['MZ'] = 'Mosambique';
$lang['MM'] = 'Myanmar';
$lang['NA'] = 'Namibien';
$lang['NR'] = 'Nauru';
$lang['NP'] = 'Nepal';
$lang['NL'] = 'Niederlande';
$lang['AN'] = 'Niederländische Antillen';
$lang['NT'] = 'Neutrale Zone';
$lang['NC'] = 'Neukaledonien';
$lang['NZ'] = 'Neuseeland (Aotearoa)';
$lang['NI'] = 'Nikaragua';
$lang['NE'] = 'Niger';
$lang['NG'] = 'Nigeria';
$lang['NU'] = 'Niue';
$lang['NF'] = 'Norfolk-Insel';
$lang['MP'] = 'Nördliche Marianen-Inseln';
$lang['NO'] = 'Norwegen';
$lang['OM'] = 'Oman';
$lang['PK'] = 'Pakistan';
$lang['PW'] = 'Palau';
$lang['PS'] = 'Palästinensisches Territorium';
$lang['PA'] = 'Panama';
$lang['PG'] = 'Papua-Neuguinea';
$lang['PY'] = 'Paraguay';
$lang['PE'] = 'Peru';
$lang['PH'] = 'Philippinen';
$lang['PN'] = 'Pitcairn';
$lang['PL'] = 'Polen';
$lang['PT'] = 'Portugal';
$lang['PR'] = 'Puerto Rico';
$lang['QA'] = 'Qatar';
$lang['RE'] = 'Reunion';
$lang['RO'] = 'Rumänien';
$lang['RU'] = 'Russische Föderation';
$lang['RW'] = 'Ruanda';
$lang['GS'] = 'S. Georgia und S. Sandwich inseln';
$lang['KN'] = 'Saint Kitts und Nevis';
$lang['LC'] = 'Saint Lucia';
$lang['VC'] = 'Saint Vincent & Grenadinen';
$lang['WS'] = 'Samoa';
$lang['SM'] = 'San Marino';
$lang['ST'] = 'Sao Tome und Principe';
$lang['SA'] = 'Saudi-Arabien';
$lang['SN'] = 'Senegal';
$lang['SC'] = 'Seychellen';
$lang['SL'] = 'Sierra Leone';
$lang['SG'] = 'Singapur';
$lang['SI'] = 'Slowenien';
$lang['SK'] = 'Slowakische Republik';
$lang['SB'] = 'Solomon-Inseln';
$lang['SO'] = 'Somalia';
$lang['ZA'] = 'Südafrika';
$lang['ES'] = 'Spanien';
$lang['LK'] = 'Sri Lanka';
$lang['SH'] = 'St. Helena';
$lang['PM'] = 'St. Pierre und Miquelon';
$lang['SD'] = 'Sudan';
$lang['SR'] = 'Surinam';
$lang['SJ'] = 'Svalbard & Jan Mayen Inseln';
$lang['SZ'] = 'Swaziland';
$lang['SE'] = 'Schweden';
$lang['CH'] = 'Schweiz';
$lang['SY'] = 'Syrien';
$lang['TW'] = 'Taiwan';
$lang['TJ'] = 'Tadschikistan';
$lang['TZ'] = 'Tansania';
$lang['TH'] = 'Thailand';
$lang['TG'] = 'Togo';
$lang['TK'] = 'Tokelau';
$lang['TO'] = 'Tonga';
$lang['TT'] = 'Trinidad und Tobago';
$lang['TN'] = 'Tunesien';
$lang['TR'] = 'Türkei';
$lang['TM'] = 'Turkmenistan';
$lang['TC'] = 'Türken und Caicos Inseln';
$lang['TV'] = 'Tuvalu';
$lang['UG'] = 'Uganda';
$lang['UA'] = 'Ukraine';
$lang['AE'] = 'Vereinigte Arabische Emirate';
$lang['UK'] = 'Vereinigtes Königreich';
$lang['US'] = 'Vereinigte Staaten von Amerika';
$lang['UM'] = 'Abgelegenen kleine  US-Inseln';
$lang['UY'] = 'Uruguay';
$lang['UZ'] = 'Usbekistan';
$lang['VU'] = 'Vanuatu';
$lang['VA'] = 'Staat Vatikanstadt';
$lang['VE'] = 'Venezuela';
$lang['VN'] = 'Vietnam';
$lang['VG'] = 'Jungfern-Inseln (Britisch)';
$lang['VI'] = 'Jungfern-Inseln (U.S.)';
$lang['WF'] = 'Wallis und Futuna Inseln';
$lang['EH'] = 'Westsahara';
$lang['YE'] = 'Jemen';
$lang['YU'] = 'Jugoslawien';
$lang['ZM'] = 'Sambia';
$lang['ZW'] = 'Simbabwe';
$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 Ü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ärer Name %s des Typs %s)';
$lang['submission_error_file_lock'] = 'Fehler: Datei konnte nicht gesperrt werden.';
$lang['unchecked_by_default'] = 'Standard: nicht ausgewählt';
$lang['checked_by_default'] = 'Standard: ausgewählt';
$lang['email_default_template'] = 'FormBuilder-Versand';
$lang['email_template_not_set'] = '<br/>Die E-Mail-Vorlage wurde noch nicht festgelegt!';
$lang['missing_cms_mailer'] = 'FormBuilder: Konnte das erforderliche CMSMailer-Modul nicht finden!';
$lang['user_approved_submission'] = 'Benutzergeprüfte Übermittlung %s von %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Ausführen, wenn ein Formular mit dem FormBuilder versandt wurde';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Ausführen, wenn beim Versand eines FormBuilder-Formulars ein Fehler aufgetreten ist';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Ausführen, wenn ein FormBuilder-Formular angezeigt wurde';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Ausführen, wenn ein Formular mit dem 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 Formulat-ID (int)</li>
<li><em>value_<name></em> - verwendet einen vorgegebenen Wert für ein festgelegtes Feld.</li>
</ul>';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Ausfü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> - die interne Formular-ID (int)</li>
<li><em>error</em> - eine Liste aller bekannte Fehler (string)</li>
</ul>';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Ausfü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> - die interne Formular-ID (int)</li>
</ul>';
$lang['formbuilder_params_response_id'] = 'Antwort-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ür interne Operationen';
$lang['formbuilder_params_form_name'] = 'Formularname';
$lang['formbuilder_params_form_id'] = 'Formular-ID für interne Operationen';
$lang['formbuilder_params_general'] = 'Allgemeine Parameter für interne Operationen';
$lang['post_install'] = '<p>Stellen Sie sicher, dass die Berechtigung „Modify Forms“ 
für die Benutzer gesetzt ist, welche die Feedback-Formulare administrieren werden. Sollen die Werte aus dem Formular per E-Mail versandt werden, 
stellen Sie ebenfalls sicher, dass die Konfiguration entsprechend aktualisiert wurde.</p>
<p>ACHTUNG: Während der Bearbeitung darf das jeweilige Formular 
Bearbeitung nicht aktiv sein (=nutzbar für die Gäste Ihrer Homepage). Sie sollten daher den Formular-Tag erst dann in eine aktive Inhaltsseite einfügen, wenn das Formular komplett erstellt ist. Anderenfalls kann es zu fehlerhaften Ergebnissen kommen.</p>
<p>Hinweis: Diese Version unterstü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_content_general'] = '<h3>Modulbeschreibung</h3>
<p>Das FormBuilder-Modul erlaubt Ihnen, Feedback-Formulare zu erstellen, erweitert um die Fähigkeit, eingegebene Daten auch in einer Datenbank ablegen zu können. Zusammen mit dem FormBrowser-Modul können Sie einsetzen, um einfache Datenbank-Anwendungen selbst zu erstellen.</p>
<p>Die vom FormBuilder erzeugten Formulare können in Seitenvorlagen 
und/oder Seiten eingefügt werden. In die Formulaer kö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ür Email-Adressen usw. zu verwenden. </p>
<p>Einige Felder können mehrere Werte oder Namen/Werte Paare haben. Wenn Sie zuerst ein solches Feld erstellen, kann es möglich sein, dass nicht genügend Eingabefelder vorhanden sind, um die Werte einzutragen. Um mehr Möglichkeiten zu erhalten Werte einzutragen, benutzen Sie den Schalter am unteren Ende der Seite für weitere Optionen.</p>
<p>Feldern können Validierungsregeln zugewiesen werden, welche je nach Feldtyp unterschiedlich sein können. Diese Regeln helfen sicherzustellen dass der Nutzer gültige Daten eingibt. Außerdem ist es möglich, Felder seperat mit einem „wird benötigt“ zu markieren, damit wird der Nutzer sozusagen „gezwungen“ Eingaben zu machen. </p>
<p>Feldern können auch CSS-Klassen zugewiesen werden. Es werden die Eingabefelder mit einem DIV Tag und dazugehöriger CSS-Klasse umgeben; somit können Sie Ihr Formular selbst gestalten. Um dies effizient nutzen zu können, sollten in den Quelltext des Formulares gehen und dann Ihren CSS-Code schreiben. </p>';
$lang['help_content_fields'] = '<h3>Felder zum Formular hinzufügen</h3>
<h4>Standardeingabefelder</h4>
<table>
	<thead>
		<tr>
			<th scope="col">Feldtyp</th>
			<th scope="col">Beschreibung</th>
		</tr>
	</thead>
	<tbody>
		<tr>
			<th scope="row">Texteingabefeld</th>
			<td>Dies ist das Standardeingabefeld. Sie können die Länge der eigegebenen Zeichen wählen und verschiedene Validierungsfunktionen auf diese Feld anwenden.</td>
		</tr>
		<tr>
			<th scope="row">Textbereich</th>
			<td>Dies ist ein großes, formfreies, mehrzeiliges Texteingabefeld.</td>
		</tr>
		<tr>
			<th scope="row">Kontrollkästchen</th>
			<td>Dies ist das Standard-Kontrollkästchen</td>
		</tr>
		<tr>
			<th scope="row">Kontrollkästchengruppe</th>
			<td>Das ist eine Sammlung von Kontrollkästchen, die unter einem gemeinsamen Namen gruppiert sind, und wo eine Mehrfachauswahl ermöglicht wird. Weiterhin können Sie eines oder mehrere als Pflichtfeld(er) markieren. Somit ist der Nutzer gezwungen eine oder mehrere Kontrollkästchen dieser Gruppe auszuwählen.</td>
		</tr>
		<tr>
			<th scope="row">Radioknopfgruppe</th>
			<td>Das ist eine Sammlung von Radioknöpfen, bei denen nur eine einzige Auswahlmöglichkeit besteht.</td>
		</tr>
		<tr>
			<th scope="row">Auswahlfeld (einfach)</th>
			<td>Ein einfaches Auswahlfeld ermöglicht, wie eine Radioknopfgruppe, nur eine einzige Auswahl, ist aber kompakter und daher bei sehr vielen Optionen geeignet.</td>
		</tr>
		<tr>
			<th scope="row">Auswahlfeld (mehrfach)</th>
			<td>Ein mehrfaches Auswahlfeld ermöglicht, wie eine Kontrollkästchengruppe, eine Mehrfachauswahl, ist aber kompakter und daher bei sehr vielen Optionen geeignet.</td>
		</tr>
		<tr>
			<th scope="row">US-Bundesstaaten</th>
			<td>Dies ist ein Auswahlfeld (einfach) mit sämtlichen US-Bundesstaaten.</td>
		</tr>
		<tr>
			<th scope="row">Länderauswahl</th>
			<td>Dies ist ein einfaches Auswahlfeld mit allen Ländern der Erde.</td>
		</tr>
		<tr>
			<th scope="row">Datumsauswahl</th>
			<td>Dies ist eine Gruppe von drei einfachen Auswahlfeldern (je eins für Tag, Monat und Jahr), um dem Benutzer die Möglichkeit zu geben, ein Datum auszuwählen.</td>
		</tr>
	</tbody>
</table>

<ul>
<li>E-Mail-spezifische Eingabefelder
  <ul>
    <li>Email Von  Adress Feld. Hier können Sie Ihre Email-Adresse eingeben. Diese wird in der generierten Email im Feld Von (Mailadresse): angegeben.</li>
    <li>Email Von Name Feld. Hier können Sie Ihren Namen eingeben. Diese wird in der generierten Email im Feld Name (Absendername): angegeben.</li>

</ul></li>

<li>Kontrollfelder für die Anzeige<ul>
<li>Seitenumbruch - das ermöglicht Ihnen die Aufteilung Ihres Feedback-Formulars in mehrere Seiten. Die Eingaben jeder Seite werden
unabhängig voneinander geprüft. Das ist insbesondere bei Online-Umfragen äußerst vorteilhaft.</li>
<li>-Statischer Text. Damit können Sie Ihrem Formular einfachen Text hinzufügen oder es beschriften. Dies ist für Ausfüllhinweise, Hilfen usw. sehr nützlich, insbesondere wenn Sie für die Anzeige des Formulars kein angepasstes Template verwenden.</li>
</ul></li>

<li>Formular \'Handling\'
  <ul>
    <li>*Email Ergebnis basierend auf dem Pulldown. Dies ist hilfreich für Internetseiten wo Kommentare ü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ü 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ü benutzen, muss der Nutzer eine Auswahl des Betreffs wählen um das Formular abschicken zu können. Dieses Auswahlfeld ist fü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önnen Sie angeben wenn Sie ein solches Feld generieren. Das Feld und der Name ist fü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 über die Mailadresse. Dies ist ein sehr leistungsfähiges Feld. Es stellt dem Benutzer ein vorgegebenes Eingabefeld für seine Mailadresse zur Verfügung. Wenn dieser das Formular abschickt wird die Übermittlung nicht direkt ausgeführt, sondern schickt dem Nutzer eine Mail mit einem codierten Link. Erst wenn dieser Link gedrü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ö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>
</ul>
<h3>Templates fü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 keine Templates erstellen wollen, wird FormBuilder die nach seiner Einschätzung beste Lösung verwenden, die so funktioniert, wie Sie wollen oder auch nicht. Sie können jederzeit auf „Ein Muster-Template erstellen“ klicken und dann die Ergebnisse anpassen.</p>
<p>Beachten Sie, dass neu hinzugefügte Felder nicht mehr automatisch dem Template hinzugefügt werden, wenn es einmal geändert wurde. Aus diesem Grund ist es das Beste, wenn Sie erst zum Schluss das Template für das Formular erstellen.</p>';
$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->helptext</td><td>Optionaler Hilfetext</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['help_content_configuration'] = '<h3>Bekannte Probleme</h3>
<ul>
<li>Einige Feldtypen, die im FeedbackForm-Modul enthalten waren, sind in FormBuilder nicht implementiert. Wenn ein Bedarf für diese Felder vorhanden ist, werde ich sie hinzugefügen.</li>
<li>Das FormBuilder-Modul kann gegenwärtig noch nicht auf die Daten des FrontendUsers-Moduls zugreifen. Dies ist aber geplant.</li>
<li>FormBuilder unterstützt gegenwä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ü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ügen</em> lesen und verstehen.</li>
<li>Wenn Sie in einer vom FormBuilder generierten Email bestimmte Felder vermissen, überprüfen Sie, ob die Felder im Template enthalten sind, und stellen Sie sicher, dass Sie die fehlenden Felder auch tatsä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ö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ü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ößeren „Wanzen“ eingeschlichen haben, musste ich während des Testens feststellen, dass das Programm 
sieben Kakerlaken, zwei Ohrwürmer, eine kleine Familie von Blattläusen und eine Wanderstabheuschrecke enthielt. Sie fraßen auch
Nachbars bösen kleinen kläffenden Hund, wofür ich unendlich dankbar war.</p>
<p>Das finale Release wird Bugfixes, eine Dokumentation und bedingungslose Liebe enthalten.</p>
<h3>Support</h3>
<p>Dieses Modul beinhaltet keinen kommerziellen Support. Sie können jedoch über die folgende Wege Hilfe zu dem Modul erhalten:</p>
<ul>
<li>Fü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äufig im <a href="irc://irc.freenode.net/#cms">CMS IRC Channel</a> zu finden.</li>
<li>Letztlich erreichen Sie den Autor auch über eine direkte Email.</li>  
</ul>';
$lang['help_content_about'] = '<h3>Copyright und Lizenz</h3>
<p>Copyright © 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öffentlicht. Sie müssen dieser Lizenz zustimmen, bevor Sie das Modul verwenden.</p>';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/el_GR.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Δημιουργός φορμών';
$lang['field_type_'] = 'Δεν δόθηκε τύπος για το Πεδίο';
$lang['field_type_CatalogerItemsField'] = 'Επιλέξτε ένα (ή περισσότερα) cataloger αντικείμενα';
$lang['field_type_FieldsetEnd'] = '-Σετ πεδίων τέλος';
$lang['field_type_FieldsetStart'] = '-Σετ πεδίων αρχή';
$lang['field_type_TextField'] = 'Πεδίο κειμένου';
$lang['field_type_PasswordField'] = 'Κωδικός';
$lang['field_type_PasswordAgainField'] = 'Κωδικός (ξανά για επαλήθευση)';
$lang['field_type_TextFieldExpandable'] = 'Πεδίο κειμένου (Πολλαπλό)';
$lang['field_type_TextAreaField'] = 'Περιοχή κειμένου';
$lang['field_type_ButtonField'] = 'Κουμπί';
$lang['field_type_CheckboxField'] = 'Πεδίο ελέγχου';
$lang['field_type_CheckboxGroupField'] = 'Ομάδα πεδίον ελέγχου';
$lang['field_type_PulldownField'] = 'Αναπτυσσόμενος πίνακας';
$lang['field_type_YearPullDownField'] = 'Αναπτυσσόμενος πίνακας Έτους';
$lang['field_type_MultiselectField'] = 'Πολυεπιλογή';
$lang['field_type_StatePickerField'] = 'Επιλογέας πολιτείας  U.S';
$lang['field_type_ProvincePickerField'] = 'Επιλογέας  επαρχίας Καναδά';
$lang['field_type_CountryPickerField'] = 'Επιλογέας Χώρας';
$lang['field_type_DatePickerField'] = 'Επιλογέας ημερομηνίας';
$lang['field_type_TimePickerField'] = 'Επιλογέας Ώρας';
$lang['field_type_RadioGroupField'] = 'Ομάδα ράδιοεπιλογέων';
$lang['field_type_DispositionDirector'] = '* Αποστόλη με Email για τα αποτελέσματα που βασίζεται στην επιλογή Αναπτυσσόμενου πίνακα (Pulldown)';
$lang['field_type_DispositionFileDirector'] = '*Αποθήκευση σε αρχείο για τα αποτελέσματα που βασίζεται στην επιλογή Αναπτυσσόμενου πίνακα (Pulldown)';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Αποθήκευση σε αρχείο(α) που βασίζετε σε πολλαπλές επιλογές';
$lang['field_type_DispositionPageRedirector'] = '*Ανακατεύθηνση σε σελίδα, που βασίζεται στην επιλογή Αναπτυσσόμενου πίνακα (Pulldown)';
$lang['field_type_DispositionEmail'] = '*Αποστόλη με Email στην διεύθυνση(εις)';
$lang['field_type_DispositionEmailConfirmation'] = '*Επαλήθευση μέσω Email';
$lang['field_type_DispositionFromEmailAddressField'] = '*Αποστολή αντιγράφου χρησιμοποιώντας το Email απο το πεδίο "From Address".';
$lang['field_type_DispositionFile'] = '*Εγγραφη σε  Απλό αρχείο';
$lang['field_type_DispositionDatabase'] = '*Αποθήκευση σε βάση δεδομένων';
$lang['field_type_DispositionFormBrowser'] = '*Αποθήκευση Αποτελεσμάτων από την παλαιότερη έκδοση FormBrowser Module v.0.3';
$lang['field_type_DispositionUserTag'] = '*Κλήση μιας ετικέτας χρηστή μαζί με τα αποτελέσματα της φόρμας';
$lang['field_type_DispositionForm'] = '*Αποστολή σε μια ενέργεια της φόρμας';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Αποστολή Email σε μια καθοριζόμενη από τον χρηστή διεύθυνση';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Αποστολή Email στον διαχειριστή του CMS';
$lang['field_type_PageBreakField'] = '-Αλλαγή σελίδας';
$lang['field_type_FileUploadField'] = 'Μεταφόρτωση Αρχείου';
$lang['field_type_FromEmailAddressField'] = 'Εμφάνιση στο Email του πεδίου "From Address" ';
$lang['field_type_FromEmailAddressAgainField'] = 'Εμφάνιση στο Email του πεδίου  "From Address Again"';
$lang['field_type_FromEmailNameField'] = 'Εμφάνιση στο Email του πεδίου  "From Name" ';
$lang['field_type_FromEmailSubjectField'] = 'Εμφάνιση στο Email του πεδίου  "Subject"';
$lang['field_type_StaticTextField'] = '-Στατικό κείμενο';
$lang['field_type_SystemLinkField'] = '-Στατικός υπερσύνδεσμος';
$lang['field_type_LinkField'] = 'υπερσύνδεσμος (Εισαγωγή απο χρήστη)';
$lang['field_type_HiddenField'] = '-Κρυφό πεδίο';
$lang['field_type_ComputedField'] = '-Υπολογιζόμενο πεδίο';
$lang['field_type_UniqueIntegerField'] = '-Μοναδικός ακέραιος (Συριακός)';
$lang['field_type_UserTagField'] = '-Κλήση ετικέτας χρήστη';
$lang['field_type_CompanyDirectoryField'] = 'Πεδίο καταλόγου εταιρείας ';
$lang['field_type_ModuleInterfaceField'] = '-Πεδίο διεπαφής Module';
$lang['validation_none'] = 'Χωρίς Επαλήθευση';
$lang['validation_numeric'] = 'Αριθμητικό';
$lang['validation_integer'] = 'Ακέραιος';
$lang['validation_email_address'] = 'Διεύθυνση Email';
$lang['validation_usphone'] = 'Αριθμός τηλεφώνου για US';
$lang['validation_must_check'] = 'Πρέπει να επιλεχθεί';
$lang['validation_regex_match'] = 'Ταύτιση συνήθους έκφρασης (Regular Expression)';
$lang['validation_regex_nomatch'] = 'Χωρίς ταύτιση συνήθους έκφρασης (Regular Expression)';
$lang['required_field_missing'] = 'Δεν δόθηκε τιμή σε υποχρεωτικό πεδίο';
$lang['please_enter_a_value'] = 'Παρακαλώ εισάγετε μια τιμή για "%s"';
$lang['please_enter_a_number'] = 'Παρακαλώ εισάγετε μια αριθμητική τιμή για "%s"';
$lang['please_enter_valid'] = 'Παρακαλώ εισάγετε μια έγκυρη καταχώρηση για "%s"';
$lang['please_enter_an_integer'] = 'Παρακαλώ εισάγετε μια ακέραια αριθμητική τιμή για "%s"';
$lang['please_enter_an_email'] = 'Παρακαλώ εισάγετε μια έγκυρη διεύθυνση ηλεκτρονικού ταχυδρομείου για "%s"';
$lang['email_address_does_not_match'] = 'Η διεύθυνση ηλεκτρονικού ταχυδρομείου δεν ταιριάζει στην τιμή του "%s"';
$lang['please_enter_a_phone'] = 'Παρακαλώ εισάγετε έναν έγκυρο αριθμό τηλεφώνου για "%s"';
$lang['please_login'] = 'Παρακαλώ συνδεθείτε για να χρησιμοποιήσετε αυτή τη φόρμα';
$lang['not_valid_email'] = '"%s" δεν φαίνεται να είναι μια έγκυρη διεύθυνση ηλεκτρονικού ταχυδρομείου!';
$lang['please_enter_no_longer'] = 'Παρακαλώ εισάγετε μια τιμή που δεν είναι μεγαλύτερη από %s χαρακτήρες';
$lang['please_enter_at_least'] = 'Παρακαλώ εισάγετε μια τιμή που είναι τουλάχιστον %s χαρακτήρες';
$lang['title_list_delimiter'] = 'Χαρακτήρας που θα χρησιμοποιηθεί ως διαχωριστικό σε αποτελέσματα που θα επιστρέψουν περισσότερες από μία τιμές';
$lang['you_need_permission'] = 'Θα πρέπει να έχετε την "%s" άδεια για την εκτέλεση της συγκεκριμένης πράξης.';
$lang['lackpermission'] = 'Συγγνώμη! Δεν έχετε επαρκή δικαιώματα για να αποκτήσετε πρόσβαση σε αυτό το τμήμα.';
$lang['field_order_updated'] = 'Η ταξινόμηση των πεδίων ενημερώθηκε.';
$lang['form_deleted'] = 'Η φόρμα διαγράφηκε.';
$lang['field_deleted'] = 'Το πεδίο διαγράφηκε.';
$lang['configuration_updated'] = 'Ενημερώθηκαν οι ρυθμίσεις.';
$lang['you_must_check'] = 'Πρέπει να επιλέξετε το "%s" για να συνεχίσετε.';
$lang['must_specify_one_destination'] = 'Πρέπει να καθορίσετε τουλάχιστον μία διεύθυνση προορισμού!';
$lang['are_you_sure_delete_form'] = 'Είστε σίγουρος ότι θέλετε να διαγράψετε τη φόρμα %s?';
$lang['are_you_sure_delete_field'] = 'Είστε σίγουρος ότι θέλετε να διαγράψετε το πεδίο %s?';
$lang['notice_select_type'] = 'Οι προηγμένες επιλογές δεν είναι διαθέσιμες έως ότου ο τύπος πεδίου να ρυθμιστεί.';
$lang['field_name_in_use'] = 'Το όνομα του πεδίου "%s" είναι ήδη σε χρήση. Παρακαλούμε χρησιμοποιήστε μοναδικά ονόματα για τα πεδία, ή  απενεργοποιήσετε τα μοναδικά ονόματα πεδίων στις ρυθμίσεις του δημιουργού φορμων.';
$lang['field_no_name'] = 'Τα πεδία πρέπει να έχουν όνομα, εκτός αν καταργηθεί αυτή η επιλογή από τις ρυθμίσεις.';
$lang['anonymous'] = 'Ανώνυμος';
$lang['abbreviation_length'] = 'Μήκος: %s ';
$lang['boxes'] = '%s κουτιά';
$lang['options'] = '%s επιλογές';
$lang['text_length'] = '%s χαρακτηρες.';
$lang['order'] = 'Σειρά';
$lang['unspecified'] = '[ακαθόριστο]';
$lang['added'] = 'προστέθηκε';
$lang['updated'] = 'ενημερώθηκε';
$lang['sort_options'] = 'Επιλογές ταξινόμησης για την έξοδο';
$lang['select_one'] = 'Επιλογή ενός';
$lang['select_type'] = 'Επιλογή τύπου';
$lang['to'] = 'Πρός';
$lang['yes'] = 'Ναί';
$lang['no'] = 'Όχι';
$lang['recipients'] = 'παραλήπτες';
$lang['file_count'] = '%s πιθανά αρχεία';
$lang['destination_count'] = '%s προορισμοί';
$lang['save'] = 'Αποθήκευση';
$lang['add'] = 'Προσθήκη';
$lang['update'] = 'Ενημέρωση';
$lang['save_and_continue'] = 'Αποθήκευση και συνέχεια της εργασίας';
$lang['information'] = 'Πληροφορίες';
$lang['automatic'] = 'Αυτόματα';
$lang['forms'] = 'Φόρμες';
$lang['form'] = 'Φόρμα %s';
$lang['configuration'] = 'Ρυθμίσεις';
$lang['field_requirement_updated'] = 'Η απαιτουμένη κατάσταση για το πεδίο ενημερώθηκε.';
$lang['maximum_size'] = 'Μέγιστο Μέγεθος';
$lang['permitted_extensions'] = 'Τύποι';
$lang['permitted_filetypes'] = 'Επιτρεπόμενοι τύποι αρχείων';
$lang['file_too_large'] = 'Το αρχείο είναι πολύ μεγάλο! Το μέγιστο επιτρεπτό μέγεθος είναι:';
$lang['illegal_file_type'] = 'Αυτός ο τύπος αρχείου ενδέχεται να μην φορτωθεί. Παρακαλούμε βεβαιωθείτε ότι η  κατάληξη του αρχείου είναι σωστή.';
$lang['upload'] = 'Μεταφόρτωση';
$lang['form_imported'] = 'Η φόρμα εισήχθηκε.';
$lang['form_import_failed'] = 'Η εισαγωγή της φόρμας απέτυχε!! Υπάρχει κάποιο πρόβλημα με το αρχείο XML.';
$lang['rows'] = '%s σειρές';
$lang['cols'] = '%s στήλες';
$lang['12_hour'] = '12ώρο ρολόι';
$lang['24_hour'] = '24ώρο ρολόι';
$lang['hour'] = 'Ώρα';
$lang['min'] = 'Λεπτό';
$lang['merid'] = 'Μεσημβρινός';
$lang['date_range'] = 'Σειρά: %s - %s';
$lang['thanks'] = 'Ευχαριστώ! οι παρατηρήσεις σας έχουν ληφθεί.';
$lang['edit'] = 'Επεξεργασία';
$lang['delete'] = 'Διαγραφή';
$lang['day'] = 'Ημέρα';
$lang['mon'] = 'Μήνας';
$lang['year'] = 'Χρόνος';
$lang['none'] = '(τίποτα)';
$lang['css'] = 'CSS ';
$lang['uninstalled'] = 'Το Module απεγκαταστάθηκε.';
$lang['installed'] = 'Η έκδοση  %s  του Module εγκαταστάθηκε.';
$lang['upgraded'] = 'Το Module ενημερώθηκε στην έκδοση %s.';
$lang['button_previous'] = 'Πίσω...';
$lang['button_submit'] = 'Αποστολή φόρμας';
$lang['button_continue'] = 'Συνέχεια...';
$lang['value_checked'] = 'Επιλεγμένο';
$lang['value_unchecked'] = 'Απεπιλεγμένο';
$lang['tab_main'] = 'Κυρίως';
$lang['tab_symbol'] = 'Ρυθμίσεις εμφάνισης Φόρμας';
$lang['tab_submit'] = 'Αποστολή φόρμας';
$lang['tab_captcha'] = 'Ρυθμίσεις Οπτοελέγχου';
$lang['tab_advanced'] = 'Προχωρημένες ρυθμίσεις';
$lang['tab_templatelayout'] = 'Πρότυπο Φόρμας';
$lang['tab_submissiontemplate'] = 'Πρότυπο αποστολής';
$lang['tab_udt'] = 'Διασύνδεση με UDT';
$lang['canuse_smarty'] = '<em>Οι μεταβλητές Smarty είναι έγκυρες για το πεδίο.</em>';
$lang['add_options'] = 'Προσθήκη Περισσότερων Επιλογών';
$lang['delete_options'] = 'Διαγραφή των επιλεγμένων επιλογών';
$lang['add_checkboxes'] = 'Προσθήκη περισσότερον Checkboxes';
$lang['delete_checkboxes'] = 'Διαγραφή των επιλεγμένων Checkboxes';
$lang['add_address'] = 'Προσθήκη και άλλης διεύθυνσης';
$lang['delete_address'] = 'Διαγραφή των επιλεγμένων διευθύνσεων';
$lang['add_destination'] = 'Προσθέστε και άλλο προορισμό';
$lang['delete_destination'] = 'Διαγραφή των επιλεγμένων προορισμών';
$lang['suspected_spam'] = 'Πάρα πολλά μηνύματα ηλεκτρονικού ταχυδρομείου έχουν σταλθεί από την IP διεύθυνσή σας.Ο κώδικας για Anti-Spam έχει εμποδίσει την παράδοση.';
$lang['suspected_spam_log'] = 'Υποψία για spam από την IP  %s ,η οποία είναι πλέων μπλοκαρισμένη.';
$lang['reorder'] = 'Αναδιάταξη πεδίων';
$lang['cancel'] = 'Ακύρωση';
$lang['value_set'] = 'Τιμή: %s';
$lang['help_cataloger_attribute_fields'] = 'Παρακάτω είναι μια λίστα με τα χαρακτηριστικά που διατίθενται από το  module Cataloger.<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'] = 'Μια κανονική έκφραση (regular expression) που θα επιτρέψει το φιλτράρισμα των αντικείμενων cataloger κατά όνομα';
$lang['help_field_height'] = 'Το ύψος του πεδίου multiselect';
$lang['title_name_regex'] = 'Κανονική έκφραση (Regular Expression) για Όνομα Πεδίου Cataloger';
$lang['title_field_height'] = 'Ύψος πεδίου';
$lang['title_file_path'] = 'Κατάλογος προορισμού για τα αρχεία εξόδου';
$lang['title_udt_name'] = 'Ετικέτα καθοριζόμενη από τον χρήστη';
$lang['title_uploads_destpage'] = 'Σελίδα για να επιστρέψετε με συνδέσμους σε μεταφορτώσεις';
$lang['title_uploadmodule_summary'] = 'Υποβλήθηκε formbuilder';
$lang['title_uploads_category'] = 'Κατηγορίες μεταφορτώσεων';
$lang['title_sendto_uploads'] = 'Αποστολή αυτού του αρχείου στο uploads module';
$lang['title_legend'] = 'Υπόμνημα';
$lang['title_maximum_length'] = 'Μέγιστο Μήκος';
$lang['title_checkbox_label'] = 'Ετικέτα Checkbox';
$lang['title_radio_label'] = 'Ετικέτα Radio Button';
$lang['title_checked_value'] = 'Τιμή όταν επιλεγεί';
$lang['title_unchecked_value'] = 'Τιμή εάν δεν έχει επιλεγεί';
$lang['title_checkbox_details'] = 'Λεπτομέρειες ομάδας Checkbox';
$lang['title_delete'] = 'Διαγραφή?';
$lang['title_select_one_message'] = '"Επιλογή ενός" Κείμενο';
$lang['title_selection_value'] = 'Επιλογή τιμής';
$lang['title_selection_displayname'] = 'Εμφανιζόμενο Όνομα επιλογής';
$lang['title_selection_subject'] = 'Θέμα επιλογής';
$lang['title_select_default_country'] = 'Προκαθορισμένη επιλογή';
$lang['title_select_default_state'] = 'Προκαθορισμένη επιλογή';
$lang['title_select_default_province'] = 'Προκαθορισμένη επιλογή';
$lang['title_option_name'] = 'Όνομα Επιλογής';
$lang['title_option_value'] = 'Τιμή υποβλήθηκε';
$lang['title_pulldown_details'] = 'Επιλογές αναπτυσσόμενου πίνακα (Pulldown)';
$lang['title_multiselect_details'] = 'Επιλογές πολυεπιλογής (Multiselect)';
$lang['title_destination_address'] = 'Διεύθυνση Email προορισμού';
$lang['title_destination_filename'] = 'Όνομα αρχείου προορισμού';
$lang['title_email_from_name'] = '"Από όνομα"  για email';
$lang['title_relaxed_email_regex'] = 'Χρησιμοποιήστε χαλαρή επικύρωση email';
$lang['title_relaxed_regex_long'] = 'Χρησιμοποιήστε χαλαρή επικύρωση email (e.g., επέτρεψε "x@y" αντί για το συνήθως απαιτούμενο "x@y.tld")';
$lang['title_email_from_address'] = '"Από διεύθυνση" για email';
$lang['title_email_encoding'] = 'Κωδικοποίηση χαρακτήρων Email';
$lang['title_director_details'] = 'Λεπτομέρειες Emailer βασιζόμενο σε αναπτυσσόμενο πίνακα (Pulldown)';
$lang['title_file_name'] = 'Όνομα αρχείου';
$lang['title_email_subject'] = 'Θέμα Email';
$lang['title_form_name'] = 'Όνομα φόρμας';
$lang['title_form_status'] = 'Κατάσταση φόρμας';
$lang['title_ready_for_deployment'] = 'Έτοιμοι για εγκατάσταση';
$lang['title_not_ready1'] = 'Δεν είναι έτοιμο';
$lang['title_redirect_page'] = 'Σελίδα ανακατεύθυνσης μετά την αποστολή της φόρμας';
$lang['title_not_ready2'] = 'Παρακαλείσθε να προσθέσετε ένα πεδίο στη φόρμα για να χρησιμοποιηθεί στον ελέγχο τον δεδομένον του χρήστη. Μπορείτε να';
$lang['title_not_ready_link'] = 'χρησιμοποιήσετε αυτήν τη συντόμευση';
$lang['title_form_alias'] = 'Ψευδώνυμο φόρμας';
$lang['title_field_alias_short'] = 'Ψευδώνυμο';
$lang['title_form_fields'] = 'Πεδία φόρμας';
$lang['title_field_id'] = 'Id Πεδίου';
$lang['title_show_fieldaliases'] = 'Εμφάνιση Ψευδώνυμου των Πεδίων';
$lang['title_show_fieldaliases_long'] = 'Κάνοντας κλικ σε αυτό θα εμφανίζονται τα ψευδώνυμα των πεδίων κατά την προσθήκη ή την επεξεργασία μιας φόρμας';
$lang['title_field_name'] = 'Όνομα πεδίου';
$lang['title_field_alias'] = 'Ψευδώνυμο πεδίου και όνομα DOM id (CSS id)';
$lang['title_radiogroup_details'] = 'Λεπτομέρειες ομάδας Radio Button';
$lang['title_field_type'] = 'Τύπος πεδίου';
$lang['title_not_ready3'] = 'για να δημιουργήσετε ένα πεδίο χειρισμού της φόρμας.';
$lang['title_add_new_form'] = 'Προσθήκη νέας φόρμας';
$lang['title_show_version'] = 'Εμφανιση της εκδοσης του  Form Builder?';
$lang['title_show_version_long'] = 'Αυτό θα εμφανίσει τον αριθμό της έκδοσης του Form Builder  μέσα σε ένα σχόλιο, για να βοηθήσει τον εντοπισμό σφαλμάτων';
$lang['title_add_new_field'] = 'Προσθήκη νέου πεδίου';
$lang['title_form_submit_button'] = 'Κείμενο κουμπιού αποστολής';
$lang['title_button_text'] = 'Κειμενό κουμπιού';
$lang['title_submit_button_safety'] = 'Πρόσθεση κώδικα Javascript στο κουμπί αποστολής που θα βοηθήσει στην πρόληψη πολλαπλών υποβολών?';
$lang['title_submit_button_safety_help'] = 'Προσθήκη κώδικα script ασφάλειας';
$lang['title_form_next_button'] = 'Κείμενο για το κουμπί "Επόμενο"  (Χρησιμοποιείτε σε φόρμες με πολλές σελίδες)';
$lang['title_form_prev_button'] = 'Κείμενο για το κουμπί "Προηγούμενο" (Χρησιμοποιείτε σε φόρμες με πολλές σελίδες)';
$lang['title_field_validation'] = 'Επικύρωση Πεδίου';
$lang['title_field_to_validate'] = 'Πεδίο για επικύρωση';
$lang['title_field_css_id'] = 'CSS id για το πεδίο';
$lang['title_form_css_class'] = 'CSS Class για την φόρμα';
$lang['title_field_css_class'] = 'CSS Class για το πεδίο';
$lang['title_form_predisplay_udt'] = 'Ετικέτα χρήστη που καλείται πριν την εμφάνιση της Φόρμας (Καλείτε μόνο μια φορά)';
$lang['title_form_predisplay_each_udt'] = 'Ετικέτα χρήστη που καλείται πριν την εμφάνιση της Φόρμας  (Καλείτε σε κάθε σελίδα αν έχει πολλαπλές σελίδες η φόρμα)';
$lang['title_form_validate_udt'] = 'Ετικέτα χρήστη που καλείται όταν γίνεται επικύρωση της φόρμας';
$lang['title_form_required_symbol'] = 'σύμβολο που επισημάνει τα απαιτούμενα πεδία (συνήθως *)';
$lang['title_field_required'] = 'Απαιτείται';
$lang['title_field_required_long'] = 'Απαιτειται μια απάντηση γι \'αυτό το πεδίο';
$lang['title_hide_label'] = 'Απόκρυψη ετικέτας';
$lang['title_hide_label_long'] = 'Κρύβει το όνομα του πεδίου στην φόρμα';
$lang['title_text'] = 'Στατικό κείμενο για εμφάνιση';
$lang['title_field_regex'] = 'Κανόνες Regex για επικύρωση';
$lang['title_lines_to_show'] = 'Αριθμός Γραμμών για την απεικόνιση';
$lang['title_read_only'] = 'Μόνο για ανάγνωση';
$lang['no_default'] = 'Χωρίς προκαθορισμένο';
$lang['redirect_after_approval'] = 'Σελίδα ανακατεύθυνσης μετά την αποδοχή';
$lang['title_regex_help'] = 'Αυτή η κανονική έκφραση (regular expression) χρησιμοποίηται μόνο αν  το "validation type"  είναι ρυθμισμένο για   regex. Περιλαμβάνει ένα ολοκληρωμένο σετ εντολών όμοιο με της  Per, με start/stop slashes και flags (Π.Χ., "/image\\.(\\d+)/i")';
$lang['title_field_required_abbrev'] = 'Req\'d ';
$lang['title_hide_errors'] = 'Απόκρυψη σφαλμάτων';
$lang['title_form_displaytype'] = 'Τύπος απεικόνισης Φόρμας';
$lang['title_hide_errors_long'] = 'Αποτρέψται τα debug / μηνύματα λάθους από το να δουν οι χρήστες. ';
$lang['title_email_template'] = 'Πρότυπο Email';
$lang['title_maximum_size'] = 'Μέγιστο μέγεθος αρχείου για μεταφόρτωση (kilobytes)';
$lang['title_maximum_size_long'] = 'Ο περιορισμός αυτός είναι επιπλέον από οποιαδήποτε όρια καθορίζονται από την php  ή την παραμετροποίηση του διακομιστή.';
$lang['title_permitted_extensions'] = 'Επιτρεπόμενες Επεκτάσεις';
$lang['title_permitted_extensions_long'] = 'Λίστα διαχωρισμένη με κώμα , χωρίς την τελεία. (Π.Χ., "jpg,gif,jpeg"). Τα κενά αγνοούνται, αν δεν συμπληρωθεί τότε δεν υπάρχουν περιορισμοί στις επεκτάσεις των αρχείων.';
$lang['title_show_limitations'] = 'Περιορισμοί εμφάνισης?';
$lang['title_show_limitations_long'] = 'Εμφάνιση των περιορισμών μεγέθους και επεκτάσεων για το πεδίο μεταφόρτωσης?';
$lang['title_form_template'] = 'Πρότυπο για την εμφάνιση της φόρμας';
$lang['title_page_x_of_y'] = 'Σελίδα %s από %s';
$lang['title_no_advanced_options'] = 'Το πεδίο δεν έχει Field προηγμένες επιλογές';
$lang['title_form_unspecified'] = 'Κείμενο που επιστρέφετε για απροσδιόριστη τιμή πεδίου';
$lang['title_enable_fastadd_long'] = 'Ενεργοποίηση γρήγορης προσθήκης πεδίων με χρήση αναπτυσσόμενου μενού (pulldown) για τις φόρμες?';
$lang['title_enable_fastadd'] = 'Ενεργοποίηση αναπτυσσόμενου μενού (pulldown) γρήγορης προσθήκης πεδίων?';
$lang['title_fastadd'] = 'Γρήγορη προσθήκη πεδίων';
$lang['title_enable_antispam_long'] = 'Κάνοντας κλικ σε αυτό θα μπορούν να σταλούν μόνο έως 10 μηνύματα ηλεκτρονικού ταχυδρομείου από μια συγκεκριμένη διεύθυνση IP (ανά ώρα). ';
$lang['title_enable_antispam'] = 'Ενεργοποίηση απλά χαρακτηριστικά anti-spam;';
$lang['title_show_fieldids'] = 'Εμφάνιση IDs πεδίων';
$lang['title_show_fieldids_long'] = 'Κάνοντας κλικ σε αυτό θα επιτρέψει την εμφάνιση των ids  των πεδίων κατά την προσθήκη ή την επεξεργασία μιας φόρμας ';
$lang['title_xml_to_upload'] = 'Μεταφόρτωση φόρμας από αρχείο XML';
$lang['title_xml_upload_formname'] = 'Χρήση αυτού του ονόματος φόρμας';
$lang['title_import_legend'] = 'Εισαγωγη φορμάς XML';
$lang['title_xml_upload_formalias'] = 'Χρήση αυτού του ψευδώνυμου φόρμας';
$lang['title_html_email'] = 'Δημιουργία HTML email?';
$lang['title_link_autopopulate'] = 'Αυτόματο URL?';
$lang['title_link_autopopulate_help'] = 'Να συμπληρωθεί αυτόματα το  URL από την σελίδα που βρίσκεται η φόρμα? (αυτό υπερισχύει της επιλογής συνδέσμου παρακάτω)';
$lang['title_default_link'] = 'URL Προκαθορισμένου συνδέσμου';
$lang['title_default_link_title'] = 'Κείμενο Προκαθορισμένου συνδέσμου';
$lang['title_link_to_sitepage'] = 'Σύνδεσμος σε σελίδα του Ιστότοπου';
$lang['title_captcha_not_installed'] = 'Μπορείτε να χρησιμοποιήσετε Οπτοέλεγχο <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">"Captcha"</a> για την προστασία της φόρμας αν έχετε εγκαταστημένο το Captcha module. για περισσότερες πληροφορίες , <a href="http://dev.cmsmadesimple.org/projects/captcha/">δείτε το Captcha project</a>.';
$lang['title_use_captcha'] = 'Χρήση Οπτοελέγχου για την προστασία από κακόβουλες αποστολές?';
$lang['title_use_captcha_help'] = 'Επιλεξτε για προστασία της φάρμας με την μέθοδο του Οπτοελέγχου  <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">"Captcha"</a>.';
$lang['title_user_captcha'] = 'Παρακαλώ πληκτρολογήστε το κείμενο που φαίνεται στην εικόνα.';
$lang['title_user_captcha_error'] = 'Λανθασμένο κείμενο Οπτοελέγχου';
$lang['wrong_captcha'] = 'Ο Οπτοέλεγχος δεν ειναι σωστός.';
$lang['title_title_user_captcha'] = 'Κείμενο βοηθείας για τον Οπτοέλεγχο';
$lang['title_dont_submit_unchecked'] = 'Να μην υποβληθούν οι τιμές από τα απεπιλεγμένα κουτιά (checkbox)';
$lang['title_dont_submit_unchecked_help'] = 'Τσέκαρε το αν θέλετε μόνο τα επιλεγμένα κουτιά(checkbox) να επιστρέψουν τιμές.';
$lang['link_label'] = 'Ετικέτα Link';
$lang['link_destination'] = ' URL συνδέσμου προορισμού';
$lang['title_default_set'] = 'Επιλεγμένο απο προεπιλογή?';
$lang['title_24_hour'] = 'Χρήση 24ωρου ρολογιού?';
$lang['title_before_noon'] = 'ΠΜ';
$lang['title_after_noon'] = 'ΜΜ';
$lang['title_smarty_eval'] = 'Χρήση smarty tags για το πεδίο?';
$lang['title_textarea_rows'] = 'Σειρές (σημείωση: αυτό μπορεί να παρακαμφθεί από CSS)';
$lang['title_textarea_cols'] = 'Στήλες (σημείωση: αυτό μπορεί να παρακαμφθεί από CSS)';
$lang['title_form_main'] = 'Λεπτομέρειες κύριας φόρμας';
$lang['title_default_blank'] = 'Προεπιλογή σε κενό';
$lang['title_default_blank_help'] = 'Προκαθορισμένο σε κενό (Αποεπιλέξτε για την σημερινή ημερομηνία ως προκαθορισμένο)';
$lang['title_show_username'] = 'Εμφάνιση του ψευδώνυμου του χρήστη?';
$lang['title_show_userfirstname'] = 'Εμφάνιση του ονόματος του χρήστη?';
$lang['title_show_userlastname'] = 'Εμφάνιση του επιθέτου του χρήστη?';
$lang['title_restrict_to_group'] = 'Περιορίσει τον κατάλογο των χρηστών στους χρήστες συγκεκριμένης ομάδας';
$lang['title_encrypt_database_data'] = 'Κρυπτογράφηση δεδομένων που αποθηκεύονται στη βάση δεδομένων';
$lang['title_crypt_cert'] = 'Πιστοποιητικό (Certificate) για την κρυπτογράφηση των δεδομένων';
$lang['title_encryption_keyfile'] = 'Συνθηματική φράση ή την διαδρομή προς το αρχείο που περιέχει συνθηματική φράση. (Αν χρησιμοποιείτε OpenSSL, αυτή είναι η συνθηματική φράση για το ιδιωτικό κλειδί)';
$lang['title_encrypt_sortfields'] = 'Ταξινόμηση για πεδία με κρυπτογράφηση Hash?';
$lang['title_private_key'] = 'Ιδιωτικό κλειδί για να το χρησιμοποιήσετε στην κρυπτογράφηση δεδομένων';
$lang['title_encrypt_sortfields_help'] = 'Αυτό κριπτογραφει τα πεδία ταξινόμησης, αλλά αφήνει τα πρώτα γράμματα χωρίς κρυπτογράφηση. Κρυπτογραφικά, αυτό δημιουργεί μια ευπάθεια, αλλά για τους περισσότερους χρήστες, είναι αποδεκτό.
Είναι συμβιβασμός μεταξύ της ασφάλειας και τη δυνατότητα να ταξινομήσετε τις εγγραφές.  Η ταξινόμηση γίνεται κατά προσέγγιση, αλλά αρκετά καλά. Εάν δεν χρησιμοποιήσετε αυτήν την επιλογή, τα πεδία αποθηκεύονται σε καθαρό κείμενο.';
$lang['title_encryption_functions'] = 'Η κρυπτογράφηση της αποθήκευσης δεν είναι διαθέσιμη';
$lang['title_install_crypto'] = 'Παρακαλείσθε να εγκαταστήσετε το OpenSSL module ή την  υποστήριξη mcrypt  εάν  επιθυμείτε την κρυπτογράφηση δεδομένων.';
$lang['title_install_curl'] = 'Παρακαλώ  βεβαιωθείτε ότι έχετε την υποστήριξη CURL ενεργοποιημένη στην PHP. Δείτε http://www.php.net/manual/en/book.curl.php';
$lang['title_mle_version'] = 'Χρήση στην έκδοση MLE';
$lang['title_mle_version_long'] = 'Αλλαγη για την υποστηρηξη του CMSMS Multi-Language Edition .  Μην το επιλέξετε αν δεν έχετε την έκδοση MLE!.';
$lang['title_ensure_cert_key_match'] = 'Βεβαιωθείτε ότι έχετε επιλέξει το ιδιωτικό κλειδί που είναι κατάλληλο για το πιστοποιητικό που χρησιμοποιείτε για την κρυπτογράφηση';
$lang['choose_crypt'] = 'Βιβλιοθήκη Κρυπτογράφησης';
$lang['title_encrypt_database_long'] = 'Ελέγξτε αυτό για να κρυπτογραφηθούν τα αποθηκευμένα δεδομένα. Αυτό καθιστά ακόμη πιο δύσκολο (αλλά όχι αδύνατο) για τους χάκερ  να δουν τις πληροφορίες.';
$lang['choose_crypt_long'] = 'Οι παρακάτω επιλογές ισχύουν μόνο αν χρησιμοποιείτε την βιβλιοθήκη κρυπτογράφησης OpenSSL';
$lang['title_crypt_lib'] = 'Βιβλιοθήκη Κρυπτογράφησης';
$lang['openssl'] = 'Βιβλιοθήκη OpenSSL';
$lang['mcrypt'] = 'Βιβλιοθήκη PHP mcrypt';
$lang['title_feu_binding'] = 'Σύνδεση με χρήστη Frontend';
$lang['title_install_feu'] = 'Εγκαταστήστε το Frontend module για να συνδέσετε μια φόρμα και τα δεδομένα της σε ένα συγκεκριμένο χρήστη';
$lang['title_feu_bind_help'] = 'Επιλέξτε αυτό  για την σύνδεση δεδομένων μόνο με τους συνδεδεμένους front-end χρήστες.';
$lang['title_encryption'] = 'Κρυπτογράφηση';
$lang['title_export_form_to_udt'] = 'Εξαγωγή φόρμας με αναφορά σε UDT ως $params[\'FORM\']?(Μην το κάνετε αυτό, αν πρόκειται να χρησιμοποιήσετε την print_r($params))';
$lang['title_url_help'] = 'Ολόκληρο το URL, να περιλαμβάνει το πρωτόκολλο και την διαδρομή (Π.Χ., http://myhost.com/form_handler.cgi)';
$lang['title_url'] = 'URL υποβολής φόρμας';
$lang['title_method'] = 'Μέθοδος φόρμας';
$lang['title_maps_to'] = 'Συσχετισμός του πεδίου  "%s" σε μεταβλητή αποστολής της φόρμας';
$lang['title_additional'] = 'Συμπληρωματικά σχόλια';
$lang['title_additional_help'] = 'Οτιδήποτε που θα προσαρτάται στην υποβολή, σε URL-κωδικοποιημένη μορφή (. Π.Χ., "user =Steve+Jobs&employee_number=1)';
$lang['title_include_in_submission'] = 'Συμπεριλάβετε πεδίο στην Υποβολή';
$lang['title_data_stored_in_fbr'] = 'Τα δεδομένα θα αποθηκεύονται σε μορφή XML στο [PREFIX _module_fb_frombrowser] πίνακα της βάσης δεδομένων.';
$lang['error_has_no_fb_field'] = 'Σφάλμα! Είτε το έντυπο δεν έχει καμία σχέση με form_builder, ή δεν μπόρεσε να αρχικοποιηθεί (λόγω  προβλημάτων μνήμης?)';
$lang['restricted_to_group'] = 'Μόνο στην ομάδα %s';
$lang['title_show_to_user'] = 'Εμφάνιση στον χρήστη?';
$lang['help_leaveempty'] = 'Το πεδίο πρέπει να μείνει κενό';
$lang['help_variables_for_template'] = 'Μεταβλητές για πρότυπο';
$lang['help_variables_for_computation'] = 'Διαθέσιμες Μεταβλητές';
$lang['help_php_variable_name'] = 'Μεταβλητή PHP ';
$lang['help_submission_date'] = 'Ημερομηνία Υποβολής';
$lang['help_server_name'] = 'Ο διακομιστής σας';
$lang['help_sub_source_ip'] = 'Η διεύθυνση IP του ατόμου που χρησιμοποιείσαι την φόρμα';
$lang['help_sub_url'] = 'URL της σελίδας που περιέχει την φόρμα';
$lang['help_fb_version'] = 'Έκδοση FormBuilder';
$lang['help_tab'] = 'Χαρακτήρας Tab';
$lang['help_other_fields'] = 'Τα ψευδώνυμα των πεδίων μπορούν να χρησιμοποιηθούν εναλλακτικά(ιδιαίτερα χρήσιμο αν το Smarty δεν συνεργάζεται με χαρακτήρες άλλους εκτός του ASCII 32-126) ';
$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'] = 'Δείτε <a href="http://www.php.net/manual/en/function.date.php" target=_NEW>το  εγχειρίδιο της PHP </a> για βοήθεια στην μορφοποίησή ημερομηνίας.';
$lang['help_variable_name'] = 'Μεταβλητή';
$lang['help_form_field'] = 'Αντιπροσώπευση πεδίου';
$lang['link_back_to_form'] = '« Πίσω στην φόρμα';
$lang['title_create_sample_template'] = 'Δημιουργία δείγματος προτύπου';
$lang['title_create_sample_html_template'] = 'Δημιουργία δείγματος προτύπου HTML';
$lang['title_create_sample_header_template'] = 'Δημιουργία δείγματος προτύπου Κεφαλίδας';
$lang['title_create_sample_footer_template'] = 'Δημιουργία δείγματος προτύπου Υποσέλιδου';
$lang['title_create_sample_header'] = 'Δημιουργία δείγματος Κεφαλίδας';
$lang['help_tab_symbol'] = 'ο χαρακτήρας tab';
$lang['title_file_template'] = 'Πρότυπο για μια γραμμή του αρχείου εξόδου';
$lang['title_file_header'] = 'Πρότυπο για την κεφαλίδα του αρχείου εξόδου';
$lang['title_file_footer'] = 'Πρότυπο για το υποσέλιδο του αρχείου εξόδου';
$lang['title_confirmation_url'] = 'Διεύθυνση URL για να κάνετε κλικ για την επαλήθευση της φόρμας';
$lang['title_value'] = 'Μεταβλητή (Δες την καρτέλα για Προχωρημένους αν γίνετε χρήση ετικετών Smarty )';
$lang['title_date_format'] = 'Μορφή ημερομηνία (βασισμένο στο <a href="http://www.php.net/manual/en/function.date.php"> πρότυπο ημερομηνιών της PHP</a>)';
$lang['title_use_wysiwyg'] = 'Χρήση WYSIWYG για της περιοχες κειμένου (Από την μεριά του διαχειριστή μόνο)?';
$lang['title_submit_actions'] = 'Συμπεριφορά  Υποβολής Φόρμας';
$lang['title_submit_labels'] = 'Ετικέτες για τα κουμπιά υποβολής';
$lang['title_sortable_field'] = 'Ταξινόμηση πεδίων #%s';
$lang['title_submit_help'] = 'Αυτή η σελίδα σας επιτρέπει να προσαρμόσετε την υποβολή της φόρμας. Δεν ασχολείται με το τι γίνονται τα υποβαλλόμενα δεδομένα. Μπορείτε να το ορίσετε αυτό  με την προσθήκη πεδίων "Διάθεσης" στην φόρμα σας.';
$lang['title_start_year'] = 'Εκκίνηση περιόδου ετών';
$lang['title_end_year'] = 'Τέλος περιόδου ετών';
$lang['title_default_year'] = 'Προκαθορισμένο έτος';
$lang['title_default_year_help'] = '(Ρύθμιση σε -1 για να είναι το τρέχον έτος το προκαθορισμένο)';
$lang['title_submit_action'] = 'Μετά την υποβολή της φόρμας';
$lang['title_submit_response'] = 'Εμφάνιση Απάντησης';
$lang['title_submit_date'] = 'Ημερομηνία Υποβολής';
$lang['title_approval_date'] = 'Ημερομηνία έγκρισης (απο τον διαχειριστή)';
$lang['title_user_approved'] = 'Ημερομηνία έγκρισης (απο τον αποστολέα)';
$lang['display_text'] = 'Εμφάνιση  "Προτυπου αποστολης"';
$lang['redirect_to_page'] = 'Ανακατεύθυνση στην σελίδα του Ιστότοπου';
$lang['title_submit_response_help'] = 'Αυτό το πρότυπο εμφανίζετε στον χρήστη μετά την υποβολή της φόρμας. Αυτό το πρότυπο δεν έχει επίπτωση στα μηνύματα ηλεκτρονικού ταχυδρομείου ή σε άλλες μορφές διάθεσης των δεδομένον - εσείς ορίζετε αυτά τα πρότυπα (κατά περίπτωση) στην  καρτέλα για "προχωρημένους".';
$lang['title_destination_page'] = 'Σελίδα προορισμού';
$lang['title_require_fieldnames'] = 'Απαιτούνται ονόματα πεδίων';
$lang['title_require_fieldnames_long'] = 'Απαιτείται τα πεδία να έχουν όνομα?';
$lang['title_unique_fieldnames'] = 'Απαιτούνται μοναδικά ονόματα πεδίων';
$lang['title_unique_fieldnames_long'] = 'Να απαιτούνται μοναδικά ονόματα για τα πεδία?';
$lang['title_reorder_form'] = 'Αναδιάταξη πεδίων';
$lang['title_load_template'] = 'Φόρτωση προτύπου';
$lang['title_add_button_text'] = 'Κείμενο κουμπιού προσθήκης';
$lang['title_del_button_text'] = 'Κείμενο κουμπιού διαγραφής';
$lang['title_field_helptext'] = 'Κείμενο βοήθειας για αυτό το πεδίο';
$lang['title_string_or_number_eval'] = 'Επεξεργασία των μεταβλητών ως αριθμούς ή συμβολοσειρές';
$lang['title_order'] = 'Ταξινόμηση Επεξεργασίας';
$lang['title_order_help'] = 'Εάν υπάρχουν περισσότερα από ένα υπολογιζόμενα Πεδία ,ο υπολογισμός θα γίνει από τον μικρότερο αριθμό ταξινόμησης προς τον υψηλότερο αριθμό ';
$lang['title_compute_value'] = 'Τιμή για τον υπολογισμό';
$lang['title_string'] = 'Αλφαριθμητικό';
$lang['title_numeric'] = 'Αριθμητικό';
$lang['title_inline_form'] = 'Απεικόνιση της φόρμας  inline?';
$lang['title_inline_form_help'] = 'Το Inline σημαίνει οτι  κάθε φόρμα που ακολουθεί αντικαθιστά την ετικέτα {FormBuilder}, ενω αν ειναι non-inline αντικαθιστά την ετικέτα {content} .';
$lang['title_field_default_value'] = 'Προκαθορισμένη τιμή πεδίου';
$lang['title_clear_default'] = 'Καθαρισμός του προκαθορισμένου με κλικ?';
$lang['title_clear_default_help'] = 'Επιλέξτε  για να καταργείσετε την προεπιλεγμένη τιμή όταν ο χρήστης κάνει κλικ σε αυτό το πεδίο. Δεδομένου ότι αυτό χρησιμοποιεί κώδικα javascript  αν βάλετε μονά εισαγωγικά (\') στο προεπιλεγμένο κείμενο, θα αποτύχει. Άλλοι μη φιλικοί προς javascript  χαρακτήρες μπορούν επίσης να προκαλέσουν πρόβλημα.';
$lang['title_remove_file_from_server'] = 'Διαγραφή του αρχείου που μεταφορτώθηκε από τον server μετα την επεξεργασία του (κανόνες email)';
$lang['title_field_javascript'] = 'Javascript για το Πεδίο';
$lang['title_field_javascript_long'] = 'Συντάξτε πλήρως την κλήση  Javascript, συμπεριλαμβανομένου του γεγονότος που θέλετε να παγιδεύσετε, Π.Χ., onclick="yourfn()"';
$lang['title_submit_javascript'] = 'Javascript Φόρμας αποστολής';
$lang['title_submit_javascript_long'] = 'Συντάξτε πλήρως την κλήση  Javascript, συμπεριλαμβανομένου του γεγονότος που θέλετε να παγιδεύσετε, Π.Χ., onclick="yourfn()"<br />Αυτό πιθανόν να μην λειτουργεί καλά και αν χρησιμοποιείτε την επιλογή "σενάριο ασφαλείας" παραπάνω.';
$lang['email_from_addr_help'] = 'Μην επιλέξετε μια τυχαία διεύθυνση εδώ - πολλοί ISPs  <br /> δεν θα παραδώσουν το ταχυδρομείο αν χρησιμοποιείτε ένα διαφορετικό όνομα τομέα από το πραγματικό<br />(Π.Χ., χρησιμοποιήστε κατι σαν όνομα@%s)';
$lang['title_switch_advanced'] = 'Χρειάζεστε περισσοτέρους τύπους πεδίων? ';
$lang['title_switch_basic'] = 'Πάρα πολλοί συγκεχυμένοι τύποι πεδίων? ';
$lang['title_switch_advanced_link'] = 'Αλλαγή σε Προχωρημένο περιβάλλον';
$lang['title_switch_basic_link'] = 'Αλλαγή σε Απλό περιβάλλον';
$lang['title_file_root'] = 'Φάκελος για την αποθήκευση του αρχείου';
$lang['title_file_root_help'] = 'Πρέπει να είναι κατάλογος του web server που έχετε τη δικαιοδοσία να γράψετε. <br /> Χρησιμοποιήστε την chmod 777, αν έχετε προβλήματα. <br /> Επίσης, ελέγξτε για να δείτε ότι δεν έχετε περιορισμούς του καταλόγου στην PHP.';
$lang['title_newline_replacement'] = 'Χαρακτήρας αντικατάστασης για τον χαρακτήρα αλλαγής γραμμής(NL) και τον χαρακτήρα επιστροφής(LF)';
$lang['title_newline_replacement_help'] = 'Αφήστε το κενό για να επιτρέπονται οι χαρακτήρες αλλαγής γραμμής και επαναφοράς στην έξοδο';
$lang['title_send_usercopy'] = 'Να στέλνετε αντίγραφο της αποστολής στον χρήστη?';
$lang['title_send_usercopy_label'] = 'Ετικέτα για το  Checkbox (εάν το επιλέξει ο χρήστης)';
$lang['title_send_me_a_copy'] = 'Στείλε μου αντίγραφο της φόρμας';
$lang['title_allow_subject_override'] = 'Να επιτρέπετε αντικατάσταση του Θέματος?';
$lang['title_allow_subject_override_long'] = 'Επιτρέπει το πεδίο "Θέμα" του Email να αντικαθιστάτε από επιλογή του αναπτυσσόμενου μενού ( pulldown).';
$lang['title_display_length'] = 'Μήκος προβολής';
$lang['title_minimum_length'] = 'Ελάχιστο μήκος απάντησης';
$lang['title_hide'] = 'Απόκρυψη εισόδου';
$lang['title_hide_help'] = 'Να δείχνει σύμβολα αντί για απλό κείμενο όταν ο χρήστης εισάγει τον κωδικό πρόσβασης?';
$lang['password_does_not_match'] = 'Ο Κωδικός πρόσβασης δεν ταιριάζει %s';
$lang['back_top'] = 'Επιστροφή στην κύρια σελίδα του  δημιουργού φορμών';
$lang['title_headers_to_modify'] = 'Ποιες κεφαλίδες ηλεκτρονικού ταχυδρομείου θα πρέπει να έχει αυτή η είσοδος?';
$lang['title_blank_invalid'] = 'Μην αποδέχεστε το κενό, ως έγκυρη απάντηση';
$lang['title_blank_invalid_long'] = 'Εάν ένα πεδίο απαιτείται, τότε ο έλεγχος θα απαιτήσει ότι ο χρήστης θα δώσει μερικούς αλφαριθμητικούς χαρακτήρες και όχι κενά';
$lang['error_CompanyDirectory_module_not_available'] = 'Το Company Directory module δεν είναι διαθέσιμο!';
$lang['option_never'] = 'Ποτέ';
$lang['option_user_choice'] = 'Δώστε στον χρήστη επιλογή (checkbox)';
$lang['option_always'] = 'Πάντα';
$lang['option_from'] = 'Διεύθυνση email "Από" ';
$lang['option_reply'] = 'Διεύθυνση email "Απάντηση-Σε"';
$lang['option_both'] = 'Διεύθυνση email και στα δυο "Από" και "Απάντηση-Σε"';
$lang['option_dropdown'] = 'Αναπτυσσόμενο μενού (Dropdown)';
$lang['option_selectlist_single'] = 'Επιλογή λίστας (μονή)';
$lang['option_selectlist_multiple'] = 'Επιλογή λίστας (πολλαπλή)';
$lang['option_radiogroup'] = 'Radio Group ';
$lang['title_company_field_note'] = 'Σημείωση: Η έξοδος θα είναι υπό τη μορφή <br/> "το όνομα της εταιρείας"=>"τιμή"';
$lang['title_pick_categories'] = 'Επιλέξτε κατηγορία (πολλαπλή)';
$lang['title_pick_fielddef'] = 'Δείξτε την τιμή επεξήγησης του πεδίου(μονό)<em>προαιρετικό</ em>';
$lang['title_choose_user_input'] = 'Επιλογή εισόδου χρήστη';
$lang['title_see_also_udt'] = '(Επίσης, ρίξτε μια ματιά στην καρτέλα Υποβολή Φόρμας, αν θέλετε να ορίσετε το UDT για επικύρωση φόρμας)';
$lang['title_year_end_message'] = 'Τέλος έτους';
$lang['title_field_logic'] = 'Στοιχεία Smarty ή  λογική που είναι απαραίτητο να σταλεί με αυτό το πεδίο';
$lang['title_field_logic_long'] = 'Can be smarty data, javascript, or some other data you wan\'t to sent along with this field.<br />Goes trought smarty compiler, so remeber use {literal}{/literal} tags with <script></script>';
$lang['title_field_includelabels'] = 'Να συμπεριλαμβάνει ετικέτες';
$lang['title_field_includelabels_help'] = 'Με την ενεργοποίηση περιλαμβάνονταί ετικέτες στην έξοδο. παράδειγμα - label: value,label2: value2';
$lang['title_field_siblings'] = 'Σύνδεσή αυτού του πεδίου με την προεπιλογή';
$lang['title_field_siblings_help'] = 'Το αναπτυσσόμενο μενού (Dropdown) παραθέτει όλες της προεπιλογές του εν λόγω πεδίου και σας επιτρέπει να συνδέσετε αυτό το πεδίο σε μια από τις προεπιλογές. Επιτρέπει τον έλεγχο του πεδίου με τα επιλεγμένα κοντρόλ.';
$lang['title_field_hidebuttons'] = 'Κρύβει τα κουμπιά ελέγχου';
$lang['title_field_hidebuttons_help'] = 'Κρύβει τα εμπρόσθια (frondend) κουμπιά ελέγχου για αυτό το πεδίο';
$lang['error_usertag_disposition'] = 'Η ετικέτα χρήστη επέστρεψε σφάλμα.';
$lang['error_usertag'] = 'Η ετικέτα χρήστη %s επέστρεψε σφάλμα.';
$lang['error_cataloger_module_not_available'] = '<strong>Το Cataloger module δεν είναι εγκατεστημένο/ενεργοποιημένο.</strong>';
$lang['warning'] = 'ΠΡΟΣΟΧΗ!';
$lang['default_template'] = 'Προκαθορισμένο πρότυπο';
$lang['table_left_template'] = 'Πρότυπο πίνακα, οι Τίτλοι αριστερά';
$lang['table_top_template'] = 'Πρότυπο πίνακα, οι Τίτλοι επάνω';
$lang['form_template_name'] = 'Πρότυπο από %s';
$lang['template_are_you_sure'] = 'Είστε σίγουροι ότι θέλετε να αντικαταστήσετε το πρότυπό σας με το επιλεγμένο πρότυπο; (Ακόμα κι αν πείτε εντάξει, θα πρέπει να αποθηκεύσετε τις αλλαγές)';
$lang['title_bad_function'] = 'Σφάλμα κατά τον υπολογισμό του "%s".';
$lang['no_referrer_info'] = 'Δεν υπάρχουν πληροφορίες HTTP_REFERER διαθέσιμες (κατά πάσα πιθανότητα λόγω της χρήσης της επικύρωσης  Email Χρήστη)';
$lang['validation_param_error'] = 'Σφάλμα παραμέτρου επικύρωσης.  Παρακαλώ βεβαιωθείτε ότι αντιγράψατε τη διεύθυνση URL από το email σας σωστά!';
$lang['validation_response_error'] = 'Σφάλμα επικύρωσης. Παρακαλώ βεβαιωθείτε ότι αντιγράψατε τη διεύθυνση URL από το email σας σωστά!';
$lang['validation_no_field_error'] = 'Σφάλμα επικύρωσης. Δεν υπάρχει πεδίο επικύρωσης e-mail σε αυτή την φόρμα!';
$lang['upgrade03to04'] = 'Το Πρότυπο της φόρμας ενημερώθηκε στο πλαίσιο της αναβάθμισης της έκδοσης από 0.3 σε 0.4. Μπορεί να χρειαστεί να γίνουν ορισμένες διορθώσεις. Αν χρησιμοποιείτε την προεπιλεγμένη φόρμα, απλά αντικαταστήστε αυτό το πρότυπο με το "Προκαθορισμένο" χρησιμοποιώντας το αναπτυσσόμενο μενού (pulldown) παραπάνω.';
$lang['admindesc'] = 'Προσθήκη, επεξεργασία και διαχείριση των διαδραστικών Φορμών';
$lang['operators_help'] = 'Εάν χρησιμοποιείτε το αξιολόγηση αλφαριθμητικού (String) , η μόνη λειτουργία που διατίθεται είναι η αλληλουχία (+), ενώ αν χρησιμοποιήσετε αριθμητική (Numeric) αξιολόγηση έχετε τις βασικές , απλά μαθηματικά (, +, -, *, /,).';
$lang['help_module_interface'] = 'Χρησιμοποίηση της διεπαφής του Module';
$lang['help_module_interface_long'] = '<b>Το πεδίο αυτό χρησιμοποιείται ως πύλη εισόδου για άλλα modules!</b>
Use it by creating your form elements in the templates of the other module(s) you wish to incorporate, and using the <strong>{$FBid}</strong> to tie it back to FormBuilder. For example, to include form options based on the Products module, create the following template in Products:<br/>
<pre>
{foreach from=$items item=entry}
	{assign var=MData value=\'\'}
	{assign var=Cd value=\'\'}
		{foreach from=$FBvalue item=MData}
			{assign var=MData value=\'::\'|explode:$MData}
			{if $MData[1]==$entry->id}
				{assign var=Cd value=\' checked="checked"\'}
			{/if}
		{/foreach}
	<div class="ProductDirectoryItem">
		<input type="checkbox" value="{$entry->price}::{$entry->id}" name="{$FBid}[]" {$Cd} />{$entry->product_name} ({$entry->weight}{$weight_units}) £{$entry->price}    
	</div>
{/foreach}
</pre>
<br/>
where in the input below you put something like <strong>{Products category="cat" summarytemplate="Your_FB_template"}</strong>';
$lang['title_add_tag'] = 'Προσθήκη ετικέτας σας';
$lang['date_january'] = 'Ιανουάριος';
$lang['date_february'] = 'Φεβρουάριος';
$lang['date_march'] = 'Μάρτιος';
$lang['date_april'] = 'Απρίλιος';
$lang['date_may'] = 'Μάιος';
$lang['date_june'] = 'Ιούνιος';
$lang['date_july'] = 'Ιούλιος';
$lang['date_august'] = 'Αύγουστος';
$lang['date_september'] = 'Σεπτέμβριος';
$lang['date_october'] = 'Οκτώβριος';
$lang['date_november'] = 'Νοέμβριος';
$lang['date_december'] = 'Δεκέμβριος';
$lang['submission_error'] = 'Συγγνώμη! Υπήρξε ένα λάθος στην υποβολή της φόρμας σας.';
$lang['submit_error'] = 'FormBuilder λάθος αποστολής: %s';
$lang['uploads_error'] = 'Σφάλμα αποστολής αρχείου στο uploads module: %s';
$lang['nouploads_error'] = 'Δεν βρίσκω το uploads module';
$lang['upload_attach_error'] = 'Σφάλμα Μεταφόρτωσης/Συνημμένου αρχείου για %s (tmp_name:%s, του τύπου %s)';
$lang['submission_error_file_lock'] = 'Σφάλμα.  Δεν μπορώ να κλειδώσω το αρχείο.';
$lang['unchecked_by_default'] = 'Προεπιλογή: απεπιλεγμένο';
$lang['checked_by_default'] = 'Προεπιλογή: επιλεγμένο';
$lang['email_default_template'] = 'FormBuilder Υποβολή';
$lang['email_template_not_set'] = '<br/>Δεν έχει ρυθμιστεί πρότυπο για Email ακόμα!';
$lang['missing_cms_mailer'] = 'FormBuilder: Δέν βρίσκω το module CMSMailer!';
$lang['user_approved_submission'] = 'Ο χρήστης ενέκρινε την υποβολή %s από %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Γεγονός που ενεργοποιείται όταν μια φόρμα του FormBuilder αποστέλνεται';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Γεγονός που ενεργοποιείται όταν υπάρξει λάθος κατά την αποστολή φόρμας του FormBuilder';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Γεγονός που ενεργοποιείται όταν όταν μια φόρμα του FormBuilder εμφανίζεται';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Γεγονός που ενεργοποιείται όταν μια φόρμα του FormBuilder αποστέλνεται.</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>Γεγονός που ενεργοποιείται όταν υπάρξει λάθος κατά την αποστολή φόρμας του FormBuilder</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>Γεγονός που ενεργοποιείται όταν όταν μια φόρμα του FormBuilder εμφανίζεται</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 απάντησης. Χρησιμοποιείται από FormBrowser';
$lang['formbuilder_params_passed_from_tag'] = 'Προκαθορισμένες τιμές πεδίων;  Δες την βοήθεια του module';
$lang['formbuilder_params_field_id'] = 'ID πεδιου για εσωτερικές διεργασίες';
$lang['formbuilder_params_form_name'] = 'Όνομα φόρμας';
$lang['formbuilder_params_form_id'] = 'ID φόρμας για εσωτερικές διεργασίες';
$lang['formbuilder_params_general'] = 'Γενικές παράμετροι για εσωτερικές διεργασίες.';
$lang['template_variable_help'] = '<h3>Μεταβλητές για Πρότυπο Φόρμας</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->helptext</td><td>the field\'s help text</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->alias</td><td>the alias specified for this field</td></tr>
<tr><td>field->id</td><td>the internal / opaque id FormBuilder uses for this field</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 the case of a multipage form, you will also have access to the value of previous fields. They
are in the $previous array, or accessible by their names (e.g., {$myfield->value} ).
You can use this in Static Text fields as well, which is a nice way to personalize forms!</p>

<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>in_formbrowser</td><td>1 if form is being viewed from FormBrowser</td></tr>
<tr><td>in_admin</td><td>1 if form is being viewed via FormBrowser admin</td></tr>
<tr><td>fbr_id</td><td>Response ID if form is being viewed from FormBrowser</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'] = 'Ο Δημιουργός φορμών (FormBuilder) εγκαταστάθηκε.Παρακαλώ συμβουλευτείτε την βοήθεια για το module.';
$lang['help'] = '<h3>Τί κάνει αυτό?</h3>
<p>The Form Builder Module allows you to create 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 {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 ("), 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>Button. This doens\'t do anything, but you can hook it into some Javascript.</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>Password. This is an asterisked-out text field, useful for passwords.</li>
<li>Password Again (verify). This is a field that must match a Password field for submission
to succeed.</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>
<li>-User Tag. This calls the specified User Defined Tag, and displays anything it returns. The UDT gets called any time the field would be visible.</li>
</ul></li>
<li>-Module Include Tag. This allows you to embed other module output into your form, e.g., a list of products from the Products module.</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 $params[\'field_name\'], and as $params[\'field_alias\'] (if defined).</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 "From Address" Field, and send copy. This works like the Email "From Address" Field described above, but it provides options for sending a copy of the results to the user.</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. <strong>Deprecated.</strong> Use Store Results for FormBrowser Module instead! 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.0.3. Stores the form results in an XML structure as a single database record. This is the only interface to Form Browser. See section below.</li>
<li>*Submit to an arbitrary form action. Craft an HTTP GET or POST, and transmit it using cURL to the specified URL. This lets you use FormBuilder as a front-end to any CGI or Form Handling script out there.</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>{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 unwieldy or contain characters that don\'t work well with Smarty. So there is an
alternative like this:</p>
<p>{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 its 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. As of version 0.5, variables also have aliases, which you can use.</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>Use with FormBrowser v3</h3>
<p>There are some special features when using FormBuilder with FormBrowser. The new approach stores the form results in XML, so that far fewer
queries are needed to retrieve records. This means you can use FormBrowser with hundreds or even thousands of records. It also means you
will have to choose up front which fields you will want to be able to sort by. You can choose up to five. Changing these after there are submitted records will result in improper sorting! A re-index function will be added to a future version.</p>
<p>In advanced options, you can tie a form to Frontend Users. That means each user gets one record for the form; they can create it
a single time, subsequent times they will be editing their record. The record will not be visible to any other users (excluding admins).
This form should be added to your page using the syntax {FormBuilder action=\'feuserform\' form=\'form_name\'}.</p>
<p>For greater data safety, you can encrypt the stored forms in the database. You can use the built-in mycrypt library or the OpenSSL module.
In either case, for the passphrase, you can either enter text in the field or a file name. If you specify a file name, the contents of that
file will be used as the passphrase for encrypting.</p>
<p>If you encrypt, be aware that the fields you use for sorting are <strong>not</strong> encrypted. You can choose to hash them; the cheat here
is that the first four letters are left intact to allow for sorting. The sorting may not be perfect, and this weakens the security since it
exposes some cleartext, but it is better than nothing.</p>
<p><strong>DISCLAIMER</strong>. The encryption offered here should be considered just one more hurdle for a hacker, not as a guarantee that
your information will be secure. A smart hacker who has found some exploit to view database records may well be smart enough to get at
the module source code, and find their way to the passphrase. This will not protect you against an enemy who has full access to your
server, some familiarity with PHP, and the time to poke around. <em><strong>Do not</strong> use this to protect high-value information such as financial data,
sensitive political information, human rights data, or anything else that might be of value to a repressive government or organized crime
cartel.</em></p>
<h3>Using with User Defined Tags (UDTs)</h3>
<p>Several options for customizing behavior via UDTs is provided (thanks to kind code contributions, see credits).</p>

<ul><li>Call User Defined Tag With the Form Results. This field type submits the human-readable form results to the User-Defined
Tag you specify. The UDT can handle the results however it wants. Values are passed as $params[\'field_name\'], and
as $params[\'field_alias\'] (if defined). As per a suggestion, it also populates all of the Smarty values that would be visible to the Submission Template too!</li>
<li>User Tag Field. This calls the specified UDT, and displays anything it returns. The UDT gets called any time the field would be visible.</li>
<li>Validation UDT. Set this for a form, and the UDT will receive all of the form\\\'s human-readable results. The UDT should do whatever
validation it wants, and return an array with the first value being true or false (indication whether the form validates), and the second
value being error messages (if any).</li>
<li>User defined tag to call before form is displayed the first time (only called once). This
is set in the Form Admin in the UDT Integration tab. The UDT gets called on the first display
of the form.</li>
<li>User defined tag to call before form is displayed (called on every page of multipage
forms). This is set in the Form Admin in the UDT Integration tab. The UDT gets called
every time any page of the form is displayed (including when validation fails).</li>
</ul>
<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>Run in MLE Mode. This changes some queries against the content table to try to prevent ugly crashes under the MLE fork. Checking this will cause ugly crashes if you are NOT running the MLE fork.</li>
<li>Hide Errors. This is no longer set by default. Checking it will hide the more detailed errors that would 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>After a bit of nagging on the part of people who actually respect standards, FormBuilder no longer encourages tricks like embedding CSS in 
static text fields. Instead, it creates a stylesheet called "FormBuilder Default" that you are encouraged to attach to the page template
that you use for pages that contain your form.</p>  
<p>This default CSS was graciously provided by Paul Noone.</p>


<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->helptext</td><td>the field\'s help text</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->alias</td><td>the alias specified for this field</td></tr>
<tr><td>field->id</td><td>the internal / opaque id FormBuilder uses for this field</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 the case of a multipage form, you will also have access to the value of previous fields. They
are in the $previous array, or accessible by their names (e.g., {$myfield->value} ).
You can use this in Static Text fields as well, which is a nice way to personalize forms!</p>

<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>in_formbrowser</td><td>1 if form is being viewed from FormBrowser</td></tr>
<tr><td>in_admin</td><td>1 if form is being viewed via FormBrowser admin</td></tr>
<tr><td>fbr_id</td><td>Response ID if form is being viewed from FormBrowser</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>Credits</h3>
<p>Many people have contributed code, bug reports, cash, and ideas to FormBuilder. Among them (alphabetically):
<ul>
<li><a href="http://www.bpti.eu">Baltic institute of advanced technology</a> - funding </li>
<li>Jeremy Bass - code and suggestions</li>
<li>Alberto Benati - code</li>
<li>Tyler Boespflug - funding and ideas</li>
<li>Jeff Bosch - UDT Validation</li>
<li>Robert Campbell - numerous code contributions</li>
<li>Nuno Costa - suggestions</li>
<li>Marc Geldon - code</li>
<li>Kevin Grandon - code</li>
<li>Ronny Krijt - code</li>
<li>Paul Noone - CSS and ideas</li>
<li>Morten Poulsen - code</li>
<li>Simon Schaufelberger - code</li>
</ul>
<p>I apologize for any omissions - notify me, and I\'ll correct the omission!</p>
<h3>Miscellaneous Notes</h3>
<ul>
<li>Any fields that sends email to a specified email address will also accept a comma-separated list of email addresses.</li>
</ul>
<h3>Known Issues</h3>
<ul>
<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>FormBuilder/FormBrowser <strong>requires</strong> PHP 5 or later to function correctly.</li>
<li>First step is to check you\'re running CMS 1.6 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> Make sure you can successfully send email via the test in the CMSMailer Module. It\'s simply amazing how many problems boil down to a misconfigured CMSMailer.</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>
<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 <em>hundreds and hundreds of hours</em> 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><form action="https://www.paypal.com/cgi-bin/webscr" method="post">
<input type="hidden" name="cmd" value="_s-xclick">
<input type="image" src="https://www.paypal.com/en_US/i/btn/btn_donateCC_LG.gif" border="0" name="submit" alt="PayPal - The safer, easier way to pay online!">
<img alt="" border="0" src="https://www.paypal.com/en_US/i/scr/pixel.gif" width="1" height="1">
<input type="hidden" name="encrypted" value="-----BEGIN PKCS7-----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-----END PKCS7-----
">
</form><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 © 2009, 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['qca'] = 'P0-1966352329-1275231321191';
$lang['utmz'] = '156861353.1275232337.1.2.utmcsr=google|utmccn=(organic)|utmcmd=organic|utmctr=cmsms download module translate';
$lang['utma'] = '156861353.1311637510.1275231321.1275244952.1275330989.3';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/es_ES.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Constructor de Formularios';
$lang['field_type_DispositionEmailFromFEUProperty'] = '*Email a usuarios que coincidan con una propiedad de FEU';
$lang['field_type_'] = 'Tipo de Campo sin configurar';
$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_HTML5NumberField'] = 'Entrada de n&uacute;mero HTML5';
$lang['field_type_HTML5EmailField'] = 'Entrada de Email HTML5 ';
$lang['field_type_HTML5URLField'] = 'Entrada de URL HTML5 ';
$lang['field_type_SiteAdminField'] = 'Administrador de Sitio';
$lang['field_type_PasswordField'] = 'Password-';
$lang['field_type_PasswordAgainField'] = 'Repetir Password (verificar)';
$lang['field_type_TextFieldExpandable'] = 'Entrada de Texto (M&uacute;ltiple)';
$lang['field_type_TextAreaField'] = '&Aacute;rea de Texto';
$lang['field_type_ButtonField'] = 'Bot&oacute;n';
$lang['field_type_CheckboxField'] = 'Caja de Tilde';
$lang['field_type_CheckboxGroupField'] = 'Grupo Cajas de Tilde';
$lang['field_type_PulldownField'] = 'Desplegable';
$lang['field_type_YearPullDownField'] = 'Selector de A&ntilde;o';
$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 Lista Desplegable';
$lang['field_type_DispositionFileDirector'] = '*Guardar Resultados a Archivo Basado en  Lista 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 Lista 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_DispositionUniqueFile'] = '*Guardar resultados a un &uacute;nico archivo plano por cada env&iacute;o';
$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_DispositionForm'] = '*Enviar a una acci&oacute;n de formulario arbitraria';
$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_DispositionEmailBasedFrontendFields'] = '*Enviar Email de resultados basado en campos del frontend';
$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_CCEmailAddressField'] = 'Email Carbon Copy (CC) Address Field';
$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['field_type_UserTagField'] = '-Llamar a Tag Definida por el Usuario (UDT';
$lang['field_type_CompanyDirectoryField'] = 'Campo Directorio de la Compa&ntilde;&iacute;a';
$lang['field_type_ModuleInterfaceField'] = '-Campo de Interfaz de M&oacute;dulo';
$lang['field_type_CheckboxExtendedField'] = 'Checkbox extendido';
$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['validation_empty'] = 'Can&#039;t be empty';
$lang['required'] = 'Requerido';
$lang['not_required'] = 'No Requerido';
$lang['not_available'] = 'No Disponible';
$lang['error_emailfromfeuprop'] = 'Error en configuraci&oacute;n de Campo';
$lang['error_nofeu'] = 'No se pudo encontrar el m&oacute;dulo FrontEndUseres. Este campo no funcionar&aacute;';
$lang['error_nofeudefns'] = 'No se encontr&oacute; ninguna propiedad FEU. Este campo no tendr&aacute; ninguna funci&oacute;n';
$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['please_login'] = 'Por favor inicie sesi&oacute;n para utilizar este formulario';
$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['please_enter_at_least'] = 'Por favor introduzca un valor con al menos %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['no_field_assigned'] = 'No hay campo asignado para  %s';
$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['fields'] = 'campos';
$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! Hubo 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['css'] = 'CSS';
$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['tab_udt'] = 'Integraci&oacute;n UDT';
$lang['title_feu_property'] = 'Propiedad de FrontEndUsers';
$lang['info_feu_property'] = 'S&oacute;lo cierto tipo de propiedades pueden utlizarse para ser cotejados (listas desplegables, campos multi-selecci&oacute;n, etc)';
$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['title_textfield_label'] = 'Etiqueta de Campo de Texto';
$lang['title_show_textfield'] = 'Mostrar Campo de Texto?';
$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_allow_overwrite'] = '&iquest;Permitir la sobreescritura de archivos previos al subir?';
$lang['title_allow_overwrite_long'] = 'El archivo subido deber&iacute;a reemplazar el archivo anterior si tienen el mismo nombre?';
$lang['overwrite'] = 'Permitir Sobreescritura';
$lang['nooverwrite'] = 'No Sobreescribir';
$lang['file_already_exists'] = 'El archivo %s ya existe, y no puede ser sobreescrito';
$lang['title_file_rename'] = 'Plantilla de Nombre de Archivo';
$lang['original_file_extension'] = 'Original file extension (includes the &quot;.&quot;)';
$lang['title_suppress_filename'] = 'Eliminar el nombre de archivo en emails y formularios que el usuario puede ver';
$lang['title_suppress_attachment'] = 'No poermitir adjuntar archivos con emails';
$lang['file_rename_help'] = 'Para renombrar los archivos al subir, crear la plantilla aqu&iacute;. Deje en blanco para preservar el nombre de archivo original.';
$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_field_alias_short'] = 'Alias';
$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_button_text'] = 'Texto del Bot&oacute;n';
$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_field_css_id'] = 'id CSS para este campo';
$lang['title_form_css_class'] = 'Clase CSS para este formulario';
$lang['title_field_css_class'] = 'Clase CSS para este campo';
$lang['title_form_predisplay_udt'] = 'UDT a ser llamada antes de que el formulario sea mostrado por primera vez (s&oacute;lo se llama una sola vez)';
$lang['title_form_predisplay_each_udt'] = 'UDT a ser llamada antes de que el formulario sea desplegado todas las veces (es llamada en cada p&aacute;gina de formularios multip&aacute;gina)';
$lang['title_form_validate_udt'] = 'UDT a ser llamada durante la validaci&oacute;n';
$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_textarea_length'] = 'Longitud m&aacute;xima del contenido del campo (0 = ilimitado)';
$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['title_read_only'] = 'Solo Lectura';
$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'] = 'Requerido';
$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_file_destination'] = 'Directorio en donde guardar los archivos';
$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_default_blank'] = 'Por defecto en blanco';
$lang['title_default_blank_help'] = 'Por defecto en blanco (Desmarque para que por defecto sea la fecha actual)';
$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['title_encrypt_database_data'] = 'Encriptar datos guardados en la base de datos';
$lang['title_crypt_cert'] = 'Certificado para encriptaci&oacute;n de datos.';
$lang['title_encryption_keyfile'] = 'Passphrase or path to file containing passphrase. (If using OpenSSL, this is the passphrase for the private key)';
$lang['title_encrypt_sortfields'] = '&iquest;Ordenar campos por Hash?';
$lang['title_private_key'] = 'LLave privada a utilizar para encriptar datos.';
$lang['title_encrypt_sortfields_help'] = 'This hashes the sort fields, but leaves the first few letters unencrypted. Cryptographically, this creates a vulnerability, but for most users it is an acceptable tradeoff between security and the ability to sort records. Sorting becomes approximate, but will remain pretty good. If you do not use this option, sort fields are stored in plaintext.';
$lang['title_encryption_functions'] = 'Encriptaci&oacute;n de almacenamiento no disponible';
$lang['title_install_crypto'] = 'Please install the OpenSSL module or mcrypt support if you would like to enable database encryption.';
$lang['title_install_curl'] = 'Please make sure you have CURL support active in your PHP install. See http://www.php.net/manual/en/book.curl.php';
$lang['title_mle_version'] = 'Ejecutar en modo MLE';
$lang['title_mle_version_long'] = 'Cambia/Soporta el fork CMSMS Multi-Lenguaje. No marque esta opci&oacute;n si no est&aacute; corriendo la versi&oacute;n MLE';
$lang['title_ensure_cert_key_match'] = 'Ensure that you select the private key that is appropriate for the certificate you are using for encryption!';
$lang['choose_crypt'] = 'Librer&iacute;a de encriptaci&oacute;n';
$lang['title_encrypt_database_long'] = 'Check this to encrypt the stored data. This makes it more difficult (but not impossible) for hackers to view the information.';
$lang['choose_crypt_long'] = 'Las siguientes opciones s&oacute;lo est&aacute;n disponibles si usted est&aacute; usando la librer&iacute;a de encriptaci&oacute;n OpenSSL';
$lang['title_crypt_lib'] = 'Librer&iacute;a de Encriptaci&oacute;n';
$lang['openssl'] = 'Librer&iacute;a OpenSSL';
$lang['mcrypt'] = 'Librer&iacute;a PHP mcrypt';
$lang['title_feu_binding'] = 'Frontend User binding';
$lang['title_install_feu'] = 'Please install the Frontend User module to connect a form and its data to a specific user';
$lang['title_feu_bind_help'] = 'Check this to lock front-end access to this form&#039;s data to the logged-in front-end user.';
$lang['title_encryption'] = 'Encriptaci&oacute;n';
$lang['title_export_form_to_udt'] = 'Export form reference to UDT as $params[&#039;FORM&#039;]? (do not do this if you are going to print_r($params) )';
$lang['title_url_help'] = 'URL completa, incluyendo protocolo y ruta (ej. http://myhost.com/form_handler.cgi)';
$lang['title_url'] = 'URL de env&iacute;o de Formulario';
$lang['title_method'] = 'M&eacute;todo de Formulario';
$lang['title_maps_to'] = 'Map field &quot;%s&quot; to form submission variable';
$lang['title_additional'] = 'Env&iacute;os adicionales';
$lang['title_additional_help'] = 'Anything to be appended to the submission payload, in URL-encoded form (.e.g, &quot;user=steve+jobs&amp;employee_number=1)';
$lang['title_include_in_submission'] = 'Incluir campo en Env&iacute;o';
$lang['title_date_order'] = 'Date component field order (for input)';
$lang['title_data_stored_in_fbr'] = 'Los datos ser&aacute;n almacenados en la tabla [PREFIX]_module_fb_formbrowser de la base de datos.';
$lang['error_has_no_fb_field'] = '&iexcl;Error! El formulario no tiene campo de disposici&oacute;n para Form Browser, o &eacute;ste fall&oacute; en instanciarse (&iquest;debido a problemas de memoria?)';
$lang['help_date_order'] = 'Use &quot;m&quot; para Mes, &quot;d&quot; para D&iacute;a, y &quot;y&quot; para A&ntilde;o. Separe los elementos con guiones.';
$lang['restricted_to_group'] = 'Solo en el grupo %s';
$lang['title_show_to_user'] = 'Mostrar al usuario?';
$lang['title_use_random_generator'] = 'Usar generador de n&uacute;meros aleatorios en vez de est&aacute;tico';
$lang['title_numbers_to_generate'] = 'Cuantos numeros a generar en el proceso';
$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_ignored_if_upload'] = '(este campo se ignora si usa el m&oacute;dulo Uploads para manejar los archivos)';
$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['help_rtf_file_template'] = 'Especifique un archivo localizado en el directorio FormBuilder/templates/
Este campo ser&aacute; ignorado si usa TXT como tipo de archivo.';
$lang['help_rtf_template_type'] = 'Basic: Use the textarea below to layout the field names/values in a single block.<br />
Advanced: Specify Smarty variables in the RTF Template File as you would below, but arrange them however you like and add formatting.<br />
&nbsp;You can still use the %%HEADER%% and %%FOOTER%% sections in the RTF file.';
$lang['help_unique_file_template'] = 'For TXT, this will be immediately after the Header Template.<br />
For RTF, this will replace the %%FIELDS%% string in the template file if RTF Template Type is set to &quot;Basic&quot;.<br />
This field will be ignored if using &quot;RTF&quot; as File Type and &quot;Advanced&quot; as RTF Template Type.';
$lang['help_file_header_template'] = 'For TXT, this will be placed at the top of the file. For RTF, this will replace the %%HEADER%% string in the template file.';
$lang['help_file_footer_template'] = 'For TXT, this will be placed at the bottom of the file. For RTF, this will replace the %%FOOTER%% string in the template file.';
$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_footer_template'] = 'Crear plantilla de Pi&eacute; de Formulario';
$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_file_footer'] = 'Plantilla del pi&eacute; del archivo de salida';
$lang['title_rtf_file_template'] = 'Plantilla a usar por el archivo RTF';
$lang['title_unique_file_template'] = 'Plantilla de Resultados';
$lang['title_file_type'] = 'Seleccione un tipo de archivo para usar';
$lang['title_rtf_template_type'] = 'Selecciones una plantilla RTF';
$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['title_submit_date'] = 'Fecha de env&iacute;o';
$lang['title_approval_date'] = 'Fecha de aprobaci&oacute;n (por admin)';
$lang['title_user_approved'] = 'Fecha de aprobaci&oacute;n (por quien env&iacute;a)';
$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_field_helptext'] = 'Texto de ayuda a mostrar con este campo';
$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_string_unspaced'] = 'Cadena (sin espacios entre campos)?';
$lang['title_compute_value'] = 'Valor a computar';
$lang['title_compute'] = 'Computado/PHP';
$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'] = 'No utilice cualquier direcci&oacute;n al azar -- Muchos ISP<br /> no enviaran el email si utiliza un dominio diferente a su verdadero <br />nombre de host (ej. use algo como nombre@%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'] = 'Este necesita ser un directorio al cual su servidor web tenga permisos de escritura.<br />
Chmod 777 Si tiene problemas/dudas <br />
Tambi&eacute;n verifique que no tiene restricciones en el directorio PHP.';
$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['title_allow_subject_override'] = '&iquest;Permitir que el asunto sea sobreescrito?';
$lang['title_allow_subject_override_long'] = '
Allow &#039;Email &quot;Subject&quot; Fields&#039; to override the subject specified in the pulldown.';
$lang['title_display_length'] = 'Longitud a mostrar';
$lang['title_minimum_length'] = 'M&iacute;nima longitud de respuesta';
$lang['title_hide'] = 'Esconder entrada';
$lang['title_hide_help'] = 'Utilizar s&iacute;mbolos en vez de texto plano cuando el usuario introduce su password?';
$lang['password_does_not_match'] = 'Los password no coinciden %s';
$lang['back_top'] = 'Volver a la P&aacute;gina Principal de FormBuilder';
$lang['title_headers_to_modify'] = '&iquest;Cuales encabezados de email deber&iacute;a de poblar este campo?';
$lang['title_blank_invalid'] = 'No aceptar espacio en blanco como respuesta v&aacute;lida';
$lang['title_blank_invalid_long'] = 'Si un campo es requerido, Marcar esto requerir&aacute; que los usuarios pongan caracteres alfanum&eacute;ricos y no solamente espacios.';
$lang['title_must_save_order'] = 'You must click one of the &quot;save&quot; buttons to make your new field order permanent.';
$lang['title_html5'] = 'Utilizar marcador de posici&oacute;n (placeholder) HTML5 en lugar de Javascript';
$lang['title_email_cc_address'] = 'Address(es) to email as Carbon copy (CC). Use commas to delimit multiple addresses.';
$lang['title_use_bcc'] = 'Use Blind carbon copy (BCC instead of CC)';
$lang['title_send_using'] = 'Mail Addressing';
$lang['title_field_to_modify'] = 'Email field to add CC address';
$lang['title_modifies'] = 'Add CC to &quot;%s&quot;';
$lang['bcc_field'] = '&quot;BCC&quot; recipients';
$lang['cc_field'] = '&quot;CC&quot; recipients';
$lang['to_field'] = 'Normal (&quot;To&quot; recipients)';
$lang['bcc'] = 'BCC';
$lang['cc'] = 'CC';
$lang['error_CompanyDirectory_module_not_available'] = 'Company Directory module is not available!';
$lang['option_never'] = 'Nunca';
$lang['option_user_choice'] = 'Dar opci&oacute;n al usuario (caja de tildar)';
$lang['option_always'] = 'Siempre';
$lang['option_from'] = '&quot;From&quot; email address';
$lang['option_reply'] = '&quot;Reply-To&quot; email address';
$lang['option_both'] = 'Both &quot;From&quot; and &quot;Reply-To&quot; email addresses';
$lang['option_dropdown'] = 'Dropdown';
$lang['option_selectlist_single'] = 'Select List (single)';
$lang['option_selectlist_multiple'] = 'Select List (multiple)';
$lang['option_radiogroup'] = 'Radio Group';
$lang['title_company_field_note'] = 'Note: Output will be in the form of<br/>&quot;company name&quot;=>&quot;value&quot;';
$lang['title_pick_categories'] = 'Pick a category (multiple)';
$lang['title_pick_fielddef'] = 'Pull a field Definition&#039;s value (single) <em>optional</em>';
$lang['title_choose_user_input'] = 'Choose User input';
$lang['title_see_also_udt'] = '(Also take a look at the Form Submission tab if you want to set a UDT for form validation)';
$lang['title_year_end_message'] = 'A&ntilde;o Final';
$lang['title_field_logic'] = 'Smarty data or logic that is meant to be sent with this field';
$lang['title_field_logic_long'] = 'Can be smarty data, javascript, or some other data you want to sent along with this field.<br />Goes through the Smarty compiler, so remember use {literal}{/literal} tags with <script></script>';
$lang['title_field_includelabels'] = 'Incluir etiquetas';
$lang['title_field_includelabels_help'] = 'Enabling this includes labels to output. example - label: value,label2: value2';
$lang['title_field_siblings'] = 'Link this field to it&#039;s sibling';
$lang['title_field_siblings_help'] = 'Dropdown lists all siblings of this field and allows you to link this field to one of it&#039;s sibling. Makes possible controlling this field with selected sibling controls.';
$lang['title_field_hidebuttons'] = 'Ocultar botones de control';
$lang['title_field_hidebuttons_help'] = 'Ocultar botones de control en el frontend para este campo';
$lang['title_note'] = 'Nota';
$lang['title_changing_triggers_reindex'] = 'Changing any of the above fields will trigger a reindex of *all* saved records, so it could take a while.';
$lang['illegal_file'] = 'Attempted upload of illegal file type (%s) from %s';
$lang['title_searchable'] = 'Make records accessible to Search Module';
$lang['title_searchable_help'] = 'Checking this will make all submitted data accessible to the Search Module. DO NOT use this if you encrypt your data -- the information gets exposed to search whether or not it is encrypted!';
$lang['uploaded_outside_webroot'] = '%s (outside web root)';
$lang['title_fbr_edit'] = 'Editable in FormBrowser Admin?';
$lang['title_active_only'] = 'Only include active users?';
$lang['error_usertag_disposition'] = 'User defined tag returned an error';
$lang['error_usertag'] = 'User defined tag %s returned an error.';
$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['must_specify_one_admin'] = 'Debe especificar un administrador';
$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 (, +, -, *, /, ). Si utliza evaluaci&oacute;n Computada/PHP, puede utilizar cualquier funci&oacute;n pero necesita entrecomillar las cosas (hay substituci&oacute;n antes de la evaluaci&oacute;n, por ej. substr(&#039;$fld_22&#039;,0,2).&#039;$fld_23&#039;.';
$lang['help_module_interface'] = 'Using Module Interface';
$lang['help_module_interface_long'] = '<b>This field is used as a gateway to other modules!</b>
Use it by creating your form elements in the templates of the other module(s) you wish to incorporate, and using the <strong>{$FBid}</strong> to tie it back to FormBuilder. For example, to include form options based on the Products module, create the following template in Products:<br/>
<pre>
{foreach from=$items item=entry}
	{assign var=MData value=&#039;&#039;}
	{assign var=Cd value=&#039;&#039;}
		{foreach from=$FBvalue item=MData}
			{assign var=MData value=&#039;::&#039;|explode:$MData}
			{if $MData[1]==$entry->id}
				{assign var=Cd value=&#039; checked=&quot;checked&quot;&#039;}
			{/if}
		{/foreach}
	<div class=&quot;ProductDirectoryItem&quot;>
		<input type=&quot;checkbox&quot; value=&quot;{$entry->price}::{$entry->id}&quot; name=&quot;{$FBid}[]&quot; {$Cd} />{$entry->product_name} ({$entry->weight}{$weight_units}) &pound;{$entry->price}    
	</div>
{/foreach}
</pre>
<br/>
where in the input below you put something like <strong>{Products category=&quot;cat&quot; summarytemplate=&quot;Your_FB_template&quot;}</strong>';
$lang['title_add_tag'] = 'Agregue su etiqueta';
$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['AF'] = 'Afghanistan';
$lang['AX'] = 'Aland Islands';
$lang['AL'] = 'Albania';
$lang['DZ'] = 'Algeria';
$lang['AS'] = 'American Samoa';
$lang['AD'] = 'Andorra';
$lang['AO'] = 'Angola';
$lang['AI'] = 'Anguilla';
$lang['AQ'] = 'Antarctica';
$lang['AG'] = 'Antigua and Barbuda';
$lang['AR'] = 'Argentina';
$lang['AM'] = 'Armenia';
$lang['AW'] = 'Aruba';
$lang['AU'] = 'Australia';
$lang['AT'] = 'Austria';
$lang['AZ'] = 'Azerbaijan';
$lang['BS'] = 'Bahamas';
$lang['BH'] = 'Bahrain';
$lang['BB'] = 'Barbados';
$lang['BD'] = 'Bangladesh';
$lang['BY'] = 'Bielorusia';
$lang['BE'] = 'B&eacute;lgica';
$lang['BZ'] = 'Belize';
$lang['BJ'] = 'Benin';
$lang['BM'] = 'Bermuda';
$lang['BT'] = 'Bhutan';
$lang['BW'] = 'Botswana';
$lang['BO'] = 'Bolivia';
$lang['BA'] = 'Bosnia and Herzegovina';
$lang['BV'] = 'Bouvet Island';
$lang['BR'] = 'Brazil';
$lang['IO'] = 'British Indian Ocean Territory';
$lang['BN'] = 'Brunei Darussalam';
$lang['BG'] = 'Bulgaria';
$lang['BF'] = 'Burkina Faso';
$lang['BI'] = 'Burundi';
$lang['KH'] = 'Cambodia';
$lang['CM'] = 'Cameroon';
$lang['CA'] = 'Canada';
$lang['CV'] = 'Cape Verde';
$lang['KY'] = 'Cayman Islands';
$lang['CF'] = 'Central African Republic';
$lang['TD'] = 'Chad';
$lang['CL'] = 'Chile';
$lang['CN'] = 'China';
$lang['CX'] = 'Christmas Island';
$lang['CC'] = 'Cocos (Keeling) Islands';
$lang['CO'] = 'Colombia';
$lang['KM'] = 'Comoros';
$lang['CG'] = 'Congo';
$lang['CD'] = 'Congo,  Democratic Republic';
$lang['CK'] = 'Cook Islands';
$lang['CR'] = 'Costa Rica';
$lang['CI'] = 'Ivoire (Ivory Coast)';
$lang['HR'] = 'Croatia (Hrvatska)';
$lang['CU'] = 'Cuba';
$lang['CY'] = 'Cyprus';
$lang['CZ'] = 'Czech Republic';
$lang['DK'] = 'Denmark';
$lang['DJ'] = 'Djibouti';
$lang['DM'] = 'Dominica';
$lang['DO'] = 'Dominican Republic';
$lang['TP'] = 'East Timor';
$lang['EC'] = 'Ecuador';
$lang['EG'] = 'Egypt';
$lang['SV'] = 'El Salvador';
$lang['GQ'] = 'Equatorial Guinea';
$lang['ER'] = 'Eritrea';
$lang['EE'] = 'Estonia';
$lang['ET'] = 'Ethiopia';
$lang['FK'] = 'Falkland Islands (Malvinas)';
$lang['FO'] = 'Faroe Islands';
$lang['FJ'] = 'Fiji';
$lang['FI'] = 'Finland';
$lang['FR'] = 'France';
$lang['FX'] = 'France,  Metropolitan';
$lang['GF'] = 'Guernsey';
$lang['PF'] = 'French Polynesia';
$lang['TF'] = 'French Southern Territories';
$lang['MK'] = 'F.Y.R.O.M. (Macedonia)';
$lang['GA'] = 'Gabon';
$lang['GM'] = 'Gambia';
$lang['GE'] = 'Georgia';
$lang['DE'] = 'Germany';
$lang['GH'] = 'Ghana';
$lang['GI'] = 'Gibraltar';
$lang['GB'] = 'Great Britain (UK)';
$lang['GR'] = 'Greece';
$lang['GL'] = 'Greenland';
$lang['GD'] = 'Grenada';
$lang['GP'] = 'Guadeloupe';
$lang['GU'] = 'Guam';
$lang['GT'] = 'Guatemala';
$lang['GN'] = 'Guinea';
$lang['GW'] = 'Guinea-Bissau';
$lang['GY'] = 'Guyana';
$lang['HT'] = 'Haiti';
$lang['HM'] = 'Heard and McDonald Islands';
$lang['HN'] = 'Honduras';
$lang['HK'] = 'Hong Kong';
$lang['HU'] = 'Hungary';
$lang['IS'] = 'Iceland';
$lang['IN'] = 'India';
$lang['ID'] = 'Indonesia';
$lang['IR'] = 'Iran';
$lang['IQ'] = 'Iraq';
$lang['IE'] = 'Ireland';
$lang['IL'] = 'Israel';
$lang['IM'] = 'Isle of Man';
$lang['IT'] = 'Italy';
$lang['JE'] = 'Jersey';
$lang['JM'] = 'Jamaica';
$lang['JP'] = 'Japan';
$lang['JO'] = 'Jordan';
$lang['KZ'] = 'Kazakhstan';
$lang['KE'] = 'Kenya';
$lang['KI'] = 'Kiribati';
$lang['KP'] = 'Korea (North)';
$lang['KR'] = 'Korea (South)';
$lang['KW'] = 'Kuwait';
$lang['KG'] = 'Kyrgyzstan';
$lang['LA'] = 'Laos';
$lang['LV'] = 'Latvia';
$lang['LB'] = 'Lebanon';
$lang['LI'] = 'Liechtenstein';
$lang['LR'] = 'Liberia';
$lang['LY'] = 'Libya';
$lang['LS'] = 'Lesotho';
$lang['LT'] = 'Lithuania';
$lang['LU'] = 'Luxembourg';
$lang['MO'] = 'Macau';
$lang['MG'] = 'Madagascar';
$lang['MW'] = 'Malawi';
$lang['MY'] = 'Malaysia';
$lang['MV'] = 'Maldives';
$lang['ML'] = 'Mali';
$lang['MT'] = 'Malta';
$lang['MH'] = 'Marshall Islands';
$lang['MQ'] = 'Martinique';
$lang['MR'] = 'Mauritania';
$lang['MU'] = 'Mauritius';
$lang['YT'] = 'Mayotte';
$lang['MX'] = 'Mexico';
$lang['FM'] = 'Micronesia';
$lang['MC'] = 'Monaco';
$lang['MD'] = 'Moldova';
$lang['MA'] = 'Morocco';
$lang['MN'] = 'Mongolia';
$lang['MS'] = 'Montserrat';
$lang['MZ'] = 'Mozambique';
$lang['MM'] = 'Myanmar';
$lang['NA'] = 'Namibia';
$lang['NR'] = 'Nauru';
$lang['NP'] = 'Nepal';
$lang['NL'] = 'Netherlands';
$lang['AN'] = 'Netherlands Antilles';
$lang['NT'] = 'Neutral Zone';
$lang['NC'] = 'New Caledonia';
$lang['NZ'] = 'New Zealand (Aotearoa)';
$lang['NI'] = 'Nicaragua';
$lang['NE'] = 'Niger';
$lang['NG'] = 'Nigeria';
$lang['NU'] = 'Niue';
$lang['NF'] = 'Norfolk Island';
$lang['MP'] = 'Northern Mariana Islands';
$lang['NO'] = 'Norway';
$lang['OM'] = 'Oman';
$lang['PK'] = 'Pakistan';
$lang['PW'] = 'Palau';
$lang['PS'] = 'Palestinian Territory';
$lang['PA'] = 'Panama';
$lang['PG'] = 'Papua New Guinea';
$lang['PY'] = 'Paraguay';
$lang['PE'] = 'Peru';
$lang['PH'] = 'Philippines';
$lang['PN'] = 'Pitcairn';
$lang['PL'] = 'Poland';
$lang['PT'] = 'Portugal';
$lang['PR'] = 'Puerto Rico';
$lang['QA'] = 'Qatar';
$lang['RE'] = 'Reunion';
$lang['RO'] = 'Romania';
$lang['RU'] = 'Russian Federation';
$lang['RW'] = 'Rwanda';
$lang['GS'] = 'S. Georgia and S. Sandwich Isls.';
$lang['KN'] = 'Saint Kitts and Nevis';
$lang['LC'] = 'Saint Lucia';
$lang['VC'] = 'Saint Vincent &amp; the Grenadines';
$lang['WS'] = 'Samoa';
$lang['SM'] = 'San Marino';
$lang['ST'] = 'Sao Tome and Principe';
$lang['SA'] = 'Saudi Arabia';
$lang['SN'] = 'Senegal';
$lang['SC'] = 'Seychelles';
$lang['SL'] = 'Sierra Leone';
$lang['SG'] = 'Singapore';
$lang['SI'] = 'Slovenia';
$lang['SK'] = 'Slovak Republic';
$lang['SB'] = 'Solomon Islands';
$lang['SO'] = 'Somalia';
$lang['ZA'] = 'South Africa';
$lang['ES'] = 'Spain';
$lang['LK'] = 'Sri Lanka';
$lang['SH'] = 'St. Helena';
$lang['PM'] = 'St. Pierre and Miquelon ';
$lang['SD'] = 'Sudan';
$lang['SR'] = 'Suriname';
$lang['SJ'] = 'Svalbard &amp; Jan Mayen Islands';
$lang['SZ'] = 'Swaziland';
$lang['SE'] = 'Sweden';
$lang['CH'] = 'Switzerland';
$lang['SY'] = 'Syria';
$lang['TW'] = 'Taiwan';
$lang['TJ'] = 'Tajikistan';
$lang['TZ'] = 'Tanzania';
$lang['TH'] = 'Thailand';
$lang['TG'] = 'Togo';
$lang['TK'] = 'Tokelau';
$lang['TO'] = 'Tonga';
$lang['TT'] = 'Trinidad and Tobago';
$lang['TN'] = 'Tunisia';
$lang['TR'] = 'Turkey';
$lang['TM'] = 'Turkmenistan';
$lang['TC'] = 'Turks and Caicos Islands';
$lang['TV'] = 'Tuvalu';
$lang['UG'] = 'Uganda';
$lang['UA'] = 'Ukraine';
$lang['AE'] = 'United Arab Emirates';
$lang['UK'] = 'United Kingdom';
$lang['US'] = 'United States';
$lang['UM'] = 'US Minor Outlying Islands';
$lang['UY'] = 'Uruguay';
$lang['UZ'] = 'Uzbekistan';
$lang['VU'] = 'Vanuatu';
$lang['VA'] = 'Vatican City State (Holy See)';
$lang['VE'] = 'Venezuela';
$lang['VN'] = 'Viet Nam';
$lang['VG'] = 'Virgin Islands (British)';
$lang['VI'] = 'Virgin Islands (U.S.)';
$lang['WF'] = 'Wallis and Futuna Islands';
$lang['EH'] = 'Western Sahara';
$lang['YE'] = 'Yemen';
$lang['YU'] = 'Yugoslavia';
$lang['ZM'] = 'Zambia';
$lang['ZW'] = 'Zimbabwe';
$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['utma'] = '156861353.696388730.1360287252.1360287252.1360287252.1';
$lang['utmb'] = '156861353';
$lang['utmz'] = '156861353.1360287252.1.1.utmccn=(direct)|utmcsr=(direct)|utmcmd=(none)';
$lang['utmc'] = '156861353';
?>]]></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'] = 'Lomakerakentaja';
$lang['field_type_DispositionEmailFromFEUProperty'] = '* L&auml;het&auml; s&auml;hk&ouml;postia k&auml;ytt&auml;jille, jotka vastaavat Front End Users -lis&auml;osan asetusta';
$lang['field_type_'] = 'Kent&auml;n tyyppi&auml; ei ole asetettu';
$lang['field_type_CatalogerItemsField'] = 'Valitse yksi tai useampia katalogikohde';
$lang['field_type_FieldsetEnd'] = '- Kentt&auml;ryhm&auml;n (fieldset) alku';
$lang['field_type_FieldsetStart'] = '- Kentt&auml;ryhm&auml;n (fieldset) loppu';
$lang['field_type_TextField'] = 'Tekstikentt&auml;';
$lang['field_type_HTML5NumberField'] = 'HTML5 numerokentt&auml;';
$lang['field_type_HTML5EmailField'] = 'HTML5 s&auml;hk&ouml;postikentt&auml;';
$lang['field_type_HTML5URLField'] = 'HTML5 URL-kentt&auml;';
$lang['field_type_SiteAdminField'] = 'Sivuston yll&auml;pit&auml;j&auml;';
$lang['field_type_PasswordField'] = 'Salasana';
$lang['field_type_PasswordAgainField'] = 'Salasana uudelleen (varmennus)';
$lang['field_type_TextFieldExpandable'] = 'Tekstikentt&auml; (useita)';
$lang['field_type_TextAreaField'] = 'Tekstialue';
$lang['field_type_ButtonField'] = 'Painike';
$lang['field_type_CheckboxField'] = 'Valintalaatikko';
$lang['field_type_CheckboxGroupField'] = 'Valintalaatikkoryhm&auml;';
$lang['field_type_PulldownField'] = 'Alasvetovalikko';
$lang['field_type_YearPullDownField'] = 'Vuosialasvetovalikko';
$lang['field_type_MultiselectField'] = 'Monivalinta';
$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 mukaisesti';
$lang['field_type_DispositionPageRedirector'] = '* Ohjaa sivulle alasvetovalikon mukaan';
$lang['field_type_DispositionEmail'] = '* L&auml;het&auml; vastaukset asetettuihin s&auml;hk&ouml;postiosoitteisiin';
$lang['field_type_DispositionEmailConfirmation'] = '* Tarkistas&auml;hk&ouml;postiosoite';
$lang['field_type_DispositionFromEmailAddressField'] = '* S&auml;hk&ouml;posti &quot;S&auml;hk&ouml;postiosoitteesta&quot; kent&auml;st&auml;, ja l&auml;het&auml; kopioi';
$lang['field_type_DispositionFile'] = '* Tallenna vastaukset tiedostoon';
$lang['field_type_DispositionUniqueFile'] = '* Kirjoita tulokset erilliseen tiedostoon jokaisella l&auml;hetyskerralla';
$lang['field_type_DispositionDatabase'] = '* Tallenna vastaukset tietokantaan';
$lang['field_type_DispositionFormBrowser'] = '* Tallenna tulokset FormBrowser v.3 moduulille';
$lang['field_type_DispositionUserTag'] = '* Kutsu k&auml;ytt&auml;j&auml;n m&auml;&auml;rittelem&auml;&auml; tagia lomakkeen tuloksilla';
$lang['field_type_DispositionForm'] = '* L&auml;het&auml; vapaavalintaiseen lomake toimintoon';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '* L&auml;het&auml; k&auml;ytt&auml;j&auml;n m&auml;&auml;rittelem&auml;&auml;n s&auml;hk&ouml;postiosoitteeseen';
$lang['field_type_DispositionEmailSiteAdmin'] = '* L&auml;het&auml; s&auml;hk&ouml;posti CMS:n yll&auml;pitok&auml;ytt&auml;j&auml;lle';
$lang['field_type_DispositionEmailBasedFrontendFields'] = '* L&auml;het&auml; tulokset s&auml;hk&ouml;postilla riippuen julkisen puolen kentist&auml;';
$lang['field_type_PageBreakField'] = '- Sivunvaihto';
$lang['field_type_FileUploadField'] = 'Tiedoston lataus';
$lang['field_type_FromEmailAddressField'] = 'S&auml;hk&ouml;postin &quot;L&auml;hett&auml;j&auml;&quot; kentt&auml;';
$lang['field_type_FromEmailAddressAgainField'] = 'S&auml;hk&ouml;postin &quot;L&auml;hett&auml;j&auml;&quot; kentt&auml; uudelleen';
$lang['field_type_FromEmailNameField'] = 'S&auml;hk&ouml;postin &quot;Nimi&quot; kentt&auml;&quot;';
$lang['field_type_FromEmailSubjectField'] = 'S&auml;hk&ouml;postin &quot;Aihe&quot; kentt&auml;';
$lang['field_type_CCEmailAddressField'] = 'S&auml;hk&ouml;postin kopiokentt&auml; (CC)';
$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['field_type_UserTagField'] = '- K&auml;ytt&auml;j&auml;n m&auml;&auml;rittelem&auml; tagikutsu';
$lang['field_type_CompanyDirectoryField'] = 'Yrityshakemiston kentt&auml;';
$lang['field_type_ModuleInterfaceField'] = '- Moduulin liittym&auml;n kentt&auml;';
$lang['field_type_CheckboxExtendedField'] = 'Valintaruutu laajennettu';
$lang['validation_none'] = 'Ei tarkistusta';
$lang['validation_numeric'] = 'Numeerinen';
$lang['validation_integer'] = 'Kokonaisluku';
$lang['validation_email_address'] = 'S&auml;hk&ouml;postiosoite';
$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['validation_empty'] = 'Ei voi olla tyhj&auml;';
$lang['required'] = 'Pakollinen';
$lang['not_required'] = 'Vapaaehtoinen';
$lang['not_available'] = 'Ei saatavilla';
$lang['error_emailfromfeuprop'] = 'Virhe kent&auml;n asetuksissa';
$lang['error_nofeu'] = 'FrontEndUsers-lis&auml;osaa ei l&ouml;ytynyt. T&auml;m&auml; kentt&auml; ei toimi.';
$lang['error_nofeudefns'] = 'Sopivaa FrontEndUsers-asetusta ei l&ouml;ytynyt. T&auml;m&auml; kentt&auml; ei toimi.';
$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'] = 'Arvo ei ole 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; s&auml;hk&ouml;postiosoite kentt&auml;&auml;n &quot;%s&quot;';
$lang['email_address_does_not_match'] = 'S&auml;hk&ouml;postiosoitteen arvo ei vastaa arvoa kent&auml;ss&auml; &quot;%s&quot;';
$lang['please_enter_a_phone'] = 'Sy&ouml;t&auml; puhelinnumero kentt&auml;&auml;n &quot;%s&quot;';
$lang['please_login'] = 'Ole hyv&auml; ja kirjaudu sis&auml;lle k&auml;ytt&auml;en t&auml;t&auml; lomaketta';
$lang['not_valid_email'] = '&quot;%s&quot; ei n&auml;yt&auml; olevan s&auml;hk&ouml;postiosoite';
$lang['please_enter_no_longer'] = 'Kent&auml;n maksimipituus on %s merkki&auml;';
$lang['please_enter_at_least'] = 'Anna arvo, joka on v&auml;hint&auml;&auml;n %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['no_field_assigned'] = 'Kentt&auml;&auml; ei ole m&auml;&auml;ritelty: %s';
$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 annettu]';
$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'] = 'Vastaanottaja';
$lang['yes'] = 'Kyll&auml;';
$lang['no'] = 'Ei';
$lang['recipients'] = 'vastaanottajat';
$lang['fields'] = 'kent&auml;t';
$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'] = 'Tiedot';
$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'] = 'Maksimikoko';
$lang['permitted_extensions'] = 'P&auml;&auml;tteet';
$lang['permitted_filetypes'] = 'Sallitut tiedostotyypit';
$lang['file_too_large'] = 'L&auml;hetetty 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-tiedoston muodossa oli virhe.';
$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['css'] = 'CSS';
$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 malli';
$lang['tab_submissiontemplate'] = 'L&auml;hetysmalli';
$lang['tab_udt'] = 'UDT-integraatio';
$lang['title_feu_property'] = 'FrontEndUsers-asetus';
$lang['info_feu_property'] = 'Ainoastaan tiettyj&auml; asetustyyppej&auml; voidaan k&auml;ytt&auml;&auml; vastaavuuksien etsimiseen (pudotusvalikot, monivalintakent&auml;t jne.)';
$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 s&auml;hk&ouml;postia. Roskapostitunnistus on est&auml;nyt l&auml;hetykset.';
$lang['suspected_spam_log'] = 'Mahdollinen roskaposti IP-osoitteesta %s estetty.';
$lang['reorder'] = 'Uudelleenj&auml;rjest&auml; kentti&auml;';
$lang['cancel'] = 'Peru';
$lang['value_set'] = 'Arvo: %s';
$lang['help_cataloger_attribute_fields'] = 'Alla on listattuna attribuutteja, jotka ovat k&auml;yt&ouml;ss&auml; Kataloogimoduuissa.<br />Voit my&ouml;s vaihtoehtoisesti antaa sallittuja arvojen laajuuksia, arvoja tai useita arvoja, joilla suodatetaan lista kohteista, jotka k&auml;ytt&auml;j&auml;lle n&auml;ytet&auml;&auml;n.<br/>
<br/>
<strong>Arvojen laajuudet:</strong><br/>
Laajuudet voivat olla m&auml;&auml;riteltylt&auml; minimi- ja maksimiarvojen mukaan t&auml;ll&auml; syntaksilla: &quot;range: minarvo to maxarvo&quot;<br/>
<br/>
<strong>Useampi arvo:</strong><br/>
M&auml;&auml;ritell&auml;ksesi useamman arvon atttribuutille, k&auml;yt&auml; syntaksia &quot;multi: arvo1|arvo2|arvo3&quot;<br/>
<br/>
<strong>Piilotettujen kenttien arvot</strong><br/>
M&auml;&auml;ritell&auml;ksi arvon piilotetusta kent&auml;st&auml;, k&auml;yt&auml; syntaksia {$fld_id}<br/>
<br/>';
$lang['title_textfield_label'] = 'Tekstikent&auml;n nimike';
$lang['title_show_textfield'] = 'N&auml;yt&auml; tekstikentt&auml;?';
$lang['help_name_regex'] = 'S&auml;&auml;nn&ouml;llinen muuttuja, joka sallii katalogikohteeden suodattamisen nimen mukaan';
$lang['help_field_height'] = 'Monivalintakent&auml;n korkeus';
$lang['title_name_regex'] = 'Katalogikohteen nimen s&auml;&auml;nn&ouml;llinen muuttuja';
$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'] = 'Sivu, jolle palataan l&auml;hetyslinkeist&auml;';
$lang['title_uploadmodule_summary'] = 'L&auml;hetetty lomakerakentajan kautta';
$lang['title_uploads_category'] = 'L&auml;hetyksen kategoria';
$lang['title_sendto_uploads'] = 'L&auml;het&auml; t&auml;m&auml; tiedosto l&auml;hetysmoduulille';
$lang['title_allow_overwrite'] = 'Salli l&auml;hetyksen ylikirjoittaa vanhat tiedostot?';
$lang['title_allow_overwrite_long'] = 'Pit&auml;isik&ouml; l&auml;hetett&auml;v&auml;n tiedoston ylikirjoittaa olemassaoleva tiedosto, jos se on saman niminen?';
$lang['overwrite'] = 'Salli ylikirjoitus';
$lang['nooverwrite'] = '&Auml;l&auml; salli ylikirjoitusta';
$lang['file_already_exists'] = 'Tiedosto %s on jo olemassa eik&auml; sit&auml; voida ylikirjoittaa.';
$lang['title_file_rename'] = 'Tiedostonimipohja';
$lang['original_file_extension'] = 'Alkuper&auml;inen tiedostop&auml;&auml;te (sis&auml;lt&auml;&auml; &quot;.&quot;-merkin)';
$lang['title_suppress_filename'] = 'Supista tiedostonimi s&auml;hk&ouml;posteissa ja lomakkeissa, jotka k&auml;ytt&auml;j&auml; n&auml;kee.';
$lang['title_suppress_attachment'] = 'Est&auml; tiedoston liitt&auml;minen s&auml;hk&ouml;posteihin';
$lang['file_rename_help'] = 'Luo pohja t&auml;ss&auml;, jos tiedosto uudelleennimet&auml;&auml;n l&auml;hetyksen yhteydess&auml;. J&auml;t&auml; tyhj&auml;ksi, jos alkuper&auml;inen nimi s&auml;ilytet&auml;&auml;n.';
$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 valittuna';
$lang['title_unchecked_value'] = 'Arvo valitsemattomana';
$lang['title_checkbox_details'] = 'Valintalaatikkoryhm&auml;n tiedot';
$lang['title_delete'] = 'Poista?';
$lang['title_select_one_message'] = '&quot;Valitse yksi&quot; teksti';
$lang['title_selection_value'] = 'Valinnan arvo';
$lang['title_selection_displayname'] = 'Valinnan n&auml;ytett&auml;v&auml; 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'] = 'L&auml;hetetty arvo';
$lang['title_pulldown_details'] = 'Alasvetovalikon valinnat';
$lang['title_multiselect_details'] = 'Monivalinnan vaihtoehdot';
$lang['title_destination_address'] = 'Vastaanottajan s&auml;hk&ouml;postiosoite';
$lang['title_destination_filename'] = 'Kohdetiedoston nimi';
$lang['title_email_from_name'] = '&quot;Nimi&quot; s&auml;hk&ouml;postiin';
$lang['title_relaxed_email_regex'] = 'K&auml;yt&auml; l&ouml;ys&auml;&auml; s&auml;hk&ouml;postiosoitteen tarkistusta';
$lang['title_relaxed_regex_long'] = 'K&auml;yt&auml; l&ouml;ys&auml;&auml; s&auml;hk&ouml;postiosoitteen tarkistusta (esimerkiksi salli &quot;x@y&quot;, sen sijaan ett&auml; vaaditaan&quot;x@y.tld&quot;)';
$lang['title_email_from_address'] = '&quot;L&auml;hett&auml;j&auml;n osoite&quot; s&auml;hk&ouml;postiin';
$lang['title_email_encoding'] = 'S&auml;hk&ouml;postin merkist&ouml;koodaus';
$lang['title_director_details'] = 'Alasvetovalikkoon perustuvat l&auml;hett&auml;j&auml;n tiedot';
$lang['title_file_name'] = 'Tiedostonimi';
$lang['title_email_subject'] = 'S&auml;hk&ouml;postin aihe';
$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'] = 'Lis&auml;&auml; lomakkeeseen kentt&auml;, jotta k&auml;ytt&auml;j&auml;n antama tieto k&auml;sitell&auml;&auml;n. Voit';
$lang['title_not_ready_link'] = 'k&auml;ytt&auml;&auml; t&auml;t&auml; oikopolkua';
$lang['title_form_alias'] = 'Lomakkeen alias';
$lang['title_field_alias_short'] = 'Alias';
$lang['title_form_fields'] = 'Lomakkeen kent&auml;t';
$lang['title_field_id'] = 'Kent&auml;n tunniste';
$lang['title_show_fieldaliases'] = 'N&auml;yt&auml; kenttien aliakset';
$lang['title_show_fieldaliases_long'] = 'T&auml;m&auml;n klikkaaminen n&auml;ytt&auml;&auml; kenttien aliakset, kun lis&auml;t&auml;&auml;n tai muokataan lomaketta';
$lang['title_field_name'] = 'Kent&auml;n nimi';
$lang['title_field_alias'] = 'Kent&auml;n alias ja DOM id (CSS id) attribuutti';
$lang['title_radiogroup_details'] = 'Valintaryhm&auml;n tiedot';
$lang['title_field_type'] = 'Kent&auml;n tyyppi';
$lang['title_not_ready3'] = 'luodaksesi lomakkeen k&auml;sittelykent&auml;n';
$lang['title_add_new_form'] = 'Lis&auml;&auml; uusi lomake';
$lang['title_show_version'] = 'N&auml;yt&auml; lomake-editorin versio?';
$lang['title_show_version_long'] = 'T&auml;m&auml; liitt&auml;&auml; asennettuna olevan Lomakerakentajan version kommenttiin virheiden etsimisen helpottamiseksi';
$lang['title_add_new_field'] = 'Lis&auml;&auml; uusi kentt&auml;';
$lang['title_form_submit_button'] = 'Lomakkeen L&auml;het&auml;-painikkeen teksti';
$lang['title_button_text'] = 'Painikkeen teksti';
$lang['title_submit_button_safety'] = 'Lis&auml;&auml; lomakkeen L&auml;het&auml;-painikkeeseen JavaScript-koodi, joka auttaa est&auml;m&auml;&auml;n useammat l&auml;hetykset?';
$lang['title_submit_button_safety_help'] = 'Lis&auml;&auml; turvakoodi';
$lang['title_form_next_button'] = 'Lomakkeen Seuraava-painikkeen teksti (K&auml;ytet&auml;&auml;n vain monisivuisilla lomakkeilla)';
$lang['title_form_prev_button'] = 'Lomakkeen Edellinen-painikkeen teksti (K&auml;ytet&auml;&auml;n vain monisivuisilla lomakkeilla)';
$lang['title_field_validation'] = 'Kent&auml;n tarkistus';
$lang['title_field_to_validate'] = 'Tarkistettava kentt&auml;';
$lang['title_field_css_id'] = 'CSS-id t&auml;lle kent&auml;lle';
$lang['title_form_css_class'] = 'Lomakkeen CSS-luokka';
$lang['title_field_css_class'] = 'Kent&auml;n CSS-luokka';
$lang['title_form_predisplay_udt'] = 'K&auml;ytt&auml;j&auml;n m&auml;&auml;rittelem&auml; tagi, jota kutsutaan ennen kuin lomake n&auml;ytet&auml;&auml;n ensimm&auml;inen kerran (kutsutaan vain kerran)';
$lang['title_form_predisplay_each_udt'] = 'K&auml;ytt&auml;j&auml;n m&auml;&auml;rittelem&auml; tagi, jota kutsutaan ennen kuin lomake n&auml;ytet&auml;&auml;n ensimm&auml;inen kerran (kutsutaan jokaisella monisivuisen lomakkeen sivulla)';
$lang['title_form_validate_udt'] = 'K&auml;ytt&auml;j&auml;n m&auml;&auml;rittelem&auml; tagi, jota kutsutaan lomakkeen tarkistuksessa';
$lang['title_form_required_symbol'] = 'Vaadittujen kenttien symboli';
$lang['title_field_required'] = 'Vaaditaan';
$lang['title_field_required_long'] = 'Vaaditaan vastaus t&auml;h&auml;n kentt&auml;&auml;n';
$lang['title_hide_label'] = 'Piilota otsikko';
$lang['title_hide_label_long'] = 'Piilota kent&auml;n nimi lomakkeella';
$lang['title_textarea_length'] = 'Kent&auml;n sis&auml;ll&auml;n maksimipituus (0 tai tyhj&auml; tarkoittaa rajoittamatonta)';
$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['title_read_only'] = 'Vain luku';
$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'] = 'T&auml;t&auml; s&auml;&auml;nn&ouml;llist&auml; muuttujaa k&auml;ytet&auml;&auml;n, jos tarkistustyyppin&auml; on regexiin liittyv&auml; valinta. Sis&auml;lt&auml;&auml; koko Perl-tyylisen regexin, mukaan lukien aloitus/pys&auml;ytys vinoviivat ja liput (esim. &quot;/image\.(\d+)/i&quot;)';
$lang['title_field_required_abbrev'] = 'Pakollinen';
$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_file_destination'] = 'Hakemisto, jonne tiedostot tallennetaan';
$lang['title_permitted_extensions'] = 'Sallitut tiedostop&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'] = 'N&auml;yt&auml; kent&auml;lle m&auml;&auml;ritellyt koko- ja tiedostotyyppirajoitukset?';
$lang['title_form_template'] = 'Lomakkeen n&auml;ytt&auml;miseen k&auml;ytett&auml;v&auml; malli';
$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'] = 'Teksti, joka n&auml;ytet&auml;&auml;n m&auml;&auml;rittelem&auml;tt&ouml;mille kenttien arvoille';
$lang['title_enable_fastadd_long'] = 'Aktivoi kenttien pikalis&auml;ys lomakkeisiin pudotusvalikosta?';
$lang['title_enable_fastadd'] = 'Aktivoi kenttien pikalis&auml;ys?';
$lang['title_fastadd'] = 'Pikalis&auml;ys';
$lang['title_enable_antispam_long'] = 'T&auml;m&auml; valinta sallii maksimissaan 10 s&auml;hk&ouml;postia samasta IP-osoittesta tunnissa';
$lang['title_enable_antispam'] = 'Aktivoi roskapostiestot?';
$lang['title_show_fieldids'] = 'N&auml;yt&auml; kenttien id:t';
$lang['title_show_fieldids_long'] = 'T&auml;m&auml;n klikkaaminen sallii kenttien tunnisteiden n&auml;ytt&auml;misen, kun luodaan tai muokataan lomaketta';
$lang['title_xml_to_upload'] = 'L&auml;het&auml; lomake XML-tiedostosta';
$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'] = 'Luo HTML-muotoinen s&auml;hk&ouml;posti?';
$lang['title_link_autopopulate'] = 'T&auml;yt&auml; automaattisesti';
$lang['title_link_autopopulate_help'] = 'T&auml;yt&auml; automaattisesti URL-osoitteella, jossa lomake sijaitsee? (t&auml;m&auml; ylikirjoittaa sivuston sivulinkki -asetuksen alapuolella)';
$lang['title_default_link'] = 'Oletus URL-linkki';
$lang['title_default_link_title'] = 'Oletus teksti linkille';
$lang['title_link_to_sitepage'] = 'Linkki sivuston sivuun';
$lang['title_captcha_not_installed'] = 'Voit k&auml;ytt&auml;&auml; <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captchaa&quot;</a> suojataksesi lomakkeiden l&auml;hett&auml;misen, jos asennat Captcha-moduulin. <a href="http://dev.cmsmadesimple.org/projects/captcha/">Lis&auml;tietoa Captcha-projektista</a>.';
$lang['title_use_captcha'] = 'K&auml;ytet&auml;&auml;nk&ouml; Captcha-suojausta tiedostojen siirrossa?';
$lang['title_use_captcha_help'] = 'Valitse, jos haluat suojata lomakkeen <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">Captchalla</a>.';
$lang['title_user_captcha'] = 'Ole hyv&auml; ja kirjoita alapuolella olevat kirjaimet. Varmistamme t&auml;m&auml;n avulla, ettet ole roskapostirobotti.';
$lang['title_user_captcha_error'] = 'Captcha teksti oli virheellinen';
$lang['wrong_captcha'] = 'Captcha ei ollut oikein.';
$lang['title_title_user_captcha'] = 'Avusteteksti Captchalle';
$lang['title_dont_submit_unchecked'] = '&Auml;l&auml; l&auml;het&auml; arvoja valintalaatikoille, joita ei ole valittu';
$lang['title_dont_submit_unchecked_help'] = 'Valitse t&auml;m&auml;, jos haluat ett&auml; ainoastaan valitut valintalaatikot palauttavat arvon.';
$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'] = 'K&auml;sittele smartytagit kent&auml;ss&auml;?';
$lang['title_textarea_rows'] = 'Rivi&auml; (huomaa: voit ylikirjoittaa t&auml;m&auml;n CSS:ll&auml;)';
$lang['title_textarea_cols'] = 'Saraketta (huomaa: voit ylikirjoittaa t&auml;m&auml;n CSS:ll&auml;)';
$lang['title_form_main'] = 'Lomakkeen perustiedot';
$lang['title_default_blank'] = 'Oletuksena tyhj&auml;';
$lang['title_default_blank_help'] = 'Oletuksena tyhj&auml; (ota valinta pois, jos haluat ett&auml; oletuksena on t&auml;m&auml; p&auml;iv&auml;)';
$lang['title_show_username'] = 'N&auml;yt&auml; k&auml;ytt&auml;j&auml;tunnus?';
$lang['title_show_userfirstname'] = 'N&auml;yt&auml; k&auml;ytt&auml;j&auml;n etunimi?';
$lang['title_show_userlastname'] = 'N&auml;yt&auml; k&auml;ytt&auml;j&auml;n sukunimi?';
$lang['title_restrict_to_group'] = 'Rajoita k&auml;ytt&auml;j&auml;lista vain tietyn ryhm&auml;n j&auml;seniin';
$lang['title_encrypt_database_data'] = 'Suojaa tietokantaan tallennetut tiedot';
$lang['title_crypt_cert'] = 'Suojatun tiedon sertifikaatti';
$lang['title_encryption_keyfile'] = 'Salainen lause tai polku tiedostoon, jossa on salainen lause. (Jos k&auml;yt&auml;t OpenSSL:&auml;&auml;, t&auml;m&auml; on salainen lause yksityiselle avaimelle)';
$lang['title_encrypt_sortfields'] = 'Sekoita jaottelukent&auml;t';
$lang['title_private_key'] = 'Yksityinen avain, jota k&auml;ytet&auml;&auml;n tiedon suojaamiseen';
$lang['title_encrypt_sortfields_help'] = 'T&auml;m&auml; sekoittaa jaottelukent&auml;t, mutta j&auml;tt&auml;&auml; ensimm&auml;iset kirjaimet suojaamatta. Kryptologian kannalta, t&auml;m&auml; luo tietoturva-aukon, mutta on useimmille k&auml;ytt&auml;j&auml;lle hyv&auml;ksytt&auml;v&auml; ratkaisu turvallisuuden ja tietojen j&auml;rjest&auml;misen mahdollisuuden v&auml;lill&auml;. Tietojen j&auml;rjestelyst&auml; tulee likiarvoista, mutta silti suhteellisen paikkansa pit&auml;v&auml;&auml;. Jos et k&auml;yt&auml; t&auml;t&auml; asetusta, j&auml;rjestyskent&auml;t tallennetaan tavallisena tekstin&auml;.';
$lang['title_encryption_functions'] = 'Varaston suojaus ei ole saatavilla';
$lang['title_install_crypto'] = 'Asenna OpenSSL moduuli tai mcrypt tuki, jos haluat laittaa tietokannan suojauksen p&auml;&auml;lle.';
$lang['title_install_curl'] = 'Tarkista, ett&auml; sinulla on CURL-tuki aktiivisena PHP-asennuksessa. Katso http://www.php.net/manual/en/book.curl.php';
$lang['title_mle_version'] = 'Aja MLE-tilassa';
$lang['title_mle_version_long'] = 'Muuttaa ja tukee CMSMS Multi-Language Edition runkoa. &Auml;l&auml; valitse t&auml;t&auml;, jos et k&auml;yt&auml; MLE-versiota.';
$lang['title_ensure_cert_key_match'] = 'Varmista, ett&auml; valitset yksityisen avaimen, joka on sopiva sertifikaatille, jota k&auml;yt&auml;t tietojen suojaamiseen.';
$lang['choose_crypt'] = 'Suojauskirjasto';
$lang['title_encrypt_database_long'] = 'Valitse t&auml;m&auml;, jos haluat suojata tallennetun tiedon. T&auml;m&auml; tekee hakkerien vaikeammaksi (mutta ei mahdottomaksi) n&auml;hd&auml; tietoja.';
$lang['choose_crypt_long'] = 'Alla olevat asetukset p&auml;tev&auml;t ainoastaan, jos k&auml;yt&auml;t OpenSSL-suojauskirjastoa.';
$lang['title_crypt_lib'] = 'Suojauskirjasto';
$lang['openssl'] = 'OpenSSL-kirjasto';
$lang['mcrypt'] = 'PHP:n mcrypt-kirjasto';
$lang['title_feu_binding'] = 'Sivuston k&auml;ytt&auml;j&auml;sidos';
$lang['title_install_feu'] = 'Asenna Frontend User -moduuli, jos haluat yhdist&auml;&auml; lomakkeen ja sen tiedot tiettyyn k&auml;ytt&auml;j&auml;&auml;n.';
$lang['title_feu_bind_help'] = 'Aseta p&auml;&auml;lle, jos haluat lukita p&auml;&auml;syn t&auml;h&auml;n lomakkeeseen ainoastaan sis&auml;lle kirjautuneille k&auml;ytt&auml;jille.';
$lang['title_encryption'] = 'Suojaus';
$lang['title_export_form_to_udt'] = 'Export form reference to UDT as $params[&#039;FORM&#039;]? (do not do this if you are going to print_r($params) )';
$lang['title_url_help'] = 'Koko url-osoite, mukaan lukien protokolla ja polku (esim. http://myhost.com/form_handler.cgi)';
$lang['title_url'] = 'Lomakkeen l&auml;hetyksen URL-osoite';
$lang['title_method'] = 'Lomakkeen tapa';
$lang['title_maps_to'] = 'Map field &quot;%s&quot; to form submission variable';
$lang['title_additional'] = 'Lis&auml;l&auml;hetys';
$lang['title_additional_help'] = 'Mit&auml; tahansa l&auml;hetykseen lis&auml;tt&auml;v&auml;&auml; tietoa, url-koodatussa muodossa (esim. &quot;user=steve+jobs&amp;employee_number=1)';
$lang['title_include_in_submission'] = 'Sis&auml;llyt&auml; kentt&auml; l&auml;hetykseen';
$lang['title_date_order'] = 'Date component field order (for input)';
$lang['title_data_stored_in_fbr'] = 'Tiedot tallennetaan XML-muodossa [PREFIX]_module_fb_frombrowser tietokantatauluun.';
$lang['error_has_no_fb_field'] = 'Virhe! Joko lomakkeella ei ole form_builder m&auml;&auml;rett&auml;, tai sen lataaminen ep&auml;onnistui (mahdollinen muistiongelma?)';
$lang['help_date_order'] = 'Use &quot;m&quot; for Month, &quot;d&quot; for Day, and &quot;y&quot; for Year. Separate the items by hyphens.';
$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['title_use_random_generator'] = 'Use random number generator instead of static';
$lang['title_numbers_to_generate'] = 'How many numbers to generate in process';
$lang['help_leaveempty'] = 'Kentt&auml; voidaan j&auml;tt&auml;&auml; tyhj&auml;ksi';
$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'] = 'Lomakkeen k&auml;ytt&auml;j&auml;n IP-osoite';
$lang['help_sub_url'] = 'Lomakesivun url-osoite';
$lang['help_fb_version'] = 'Lomakerakentajan versio';
$lang['help_tab'] = 'Sarkainmerkki';
$lang['help_ignored_if_upload'] = '(This field ignored if you use the Uploads module to manage files)';
$lang['help_other_fields'] = 'Vaihtoehtoisia kenttien nimi&auml; voidaan k&auml;ytt&auml;&auml; ristiin (k&auml;yt&auml;nn&ouml;llist&auml; erityisesti, jos Smarty tukehtii merkkeihin, jotka ovat ASCII 32-126:n ulkopuolella). <br />Muut kent&auml;t ovat k&auml;ytett&auml;viss&auml;, kun lis&auml;&auml;t niit&auml; lomakkeeseen.';
$lang['help_array_fields'] = 'J&auml;lleen uusi tapa, jolla voidaan p&auml;&auml;st&auml; k&auml;siksi kenttien arvoihin, tyyliin $fieldname_obj, $alias_obj, or $fld_#_obj, miss&auml; jokainen kentt&auml; on objekti sis&auml;lt&auml;en:<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'] = 'Katso <a href="http://www.php.net/manual/en/function.date.php" target=_NEW>PHP:n manuaalista</a> ohjeita muotoiluun.';
$lang['help_variable_name'] = 'Muuttuja';
$lang['help_form_field'] = 'Uudelleenn&auml;ytett&auml;v&auml; kentt&auml;';
$lang['help_rtf_file_template'] = 'Specify a file located in the FormBuilder/templates/ folder. This field is ignored if you use TXT as your file type.';
$lang['help_rtf_template_type'] = 'Basic: Use the textarea below to layout the field names/values in a single block.<br />
Advanced: Specify Smarty variables in the RTF Template File as you would below, but arrange them however you like and add formatting.<br />
&nbsp;You can still use the %%HEADER%% and %%FOOTER%% sections in the RTF file.';
$lang['help_unique_file_template'] = 'For TXT, this will be immediately after the Header Template.<br />
For RTF, this will replace the %%FIELDS%% string in the template file if RTF Template Type is set to &quot;Basic&quot;.<br />
This field will be ignored if using &quot;RTF&quot; as File Type and &quot;Advanced&quot; as RTF Template Type.';
$lang['help_file_header_template'] = 'For TXT, this will be placed at the top of the file. For RTF, this will replace the %%HEADER%% string in the template file.';
$lang['help_file_footer_template'] = 'For TXT, this will be placed at the bottom of the file. For RTF, this will replace the %%FOOTER%% string in the template file.';
$lang['link_back_to_form'] = '&laquo; Takaisin lomakkeeseen';
$lang['title_create_sample_template'] = 'Luo esimerkkipohja';
$lang['title_create_sample_html_template'] = 'Luo HTML-pohjan esimerkki';
$lang['title_create_sample_header_template'] = 'Luo yl&auml;tunnistepohjan esimerkki';
$lang['title_create_sample_footer_template'] = 'Luo alatunnistepohjan esimerkki';
$lang['title_create_sample_header'] = 'Luo yl&auml;tunnisteen esimerkki';
$lang['help_tab_symbol'] = 'saraken&auml;pp&auml;in';
$lang['title_file_template'] = 'Pohja, jota k&auml;ytet&auml;&auml;n tulostettavan tiedoston yksitt&auml;isess&auml; riviss&auml;';
$lang['title_file_header'] = 'Pohja, jota k&auml;ytet&auml;&auml;n tulostettavan tiedoston yl&auml;tunnisteessa';
$lang['title_file_footer'] = 'Pohja, jota k&auml;ytet&auml;&auml;n tulostettavan tiedoston alatunnisteessa';
$lang['title_rtf_file_template'] = 'Template RTF file to use';
$lang['title_unique_file_template'] = 'Template for output';
$lang['title_file_type'] = 'Choose a file type to use';
$lang['title_rtf_template_type'] = 'Choose an RTF template type';
$lang['title_confirmation_url'] = 'Url-osoite, jota klikataan lomakkeen vahvistamiseksi';
$lang['title_value'] = 'Arvo (katso Monipuolinen v&auml;lilehti, jos k&auml;yt&auml;t smartytageja)';
$lang['title_date_format'] = 'P&auml;iv&auml;m&auml;&auml;r&auml;n muoto (oletus <a href="http://www.php.net/manual/en/function.date.php">PHP:n p&auml;iv&auml;m&auml;&auml;r&auml;n muodot</a>)';
$lang['title_use_wysiwyg'] = 'K&auml;yt&auml; WYSIWYG-editoria tekstikentiss&auml; (ainoastaan yll&auml;pito-osiossa)?';
$lang['title_submit_actions'] = 'Lomakkeen l&auml;hett&auml;misen k&auml;ytt&auml;ytyminen';
$lang['title_submit_labels'] = 'L&auml;hetyspainikkeiden otsikot';
$lang['title_sortable_field'] = 'J&auml;rjestelt&auml;v&auml; kentt&auml; #%s';
$lang['title_submit_help'] = 'T&auml;m&auml; sivu sallii sinun muokata lomakkeen l&auml;hett&auml;mist&auml;. Se ei m&auml;&auml;rittele mit&auml; l&auml;hetetyille tiedoille tehd&auml;&auml;n. Voit m&auml;&auml;ritell&auml; sen lis&auml;&auml;m&auml;ll&auml; lomakkeeseen k&auml;sittelykentti&auml;.';
$lang['title_start_year'] = 'Vuosijakson alku';
$lang['title_end_year'] = 'Vuosijakson loppu';
$lang['title_default_year'] = 'Oletusvuosi';
$lang['title_default_year_help'] = '(Aseta arvoksi -1, jos oletuksena on kuluva vuosi)';
$lang['title_submit_action'] = 'Lomakkeen l&auml;hett&auml;misen j&auml;lkeen';
$lang['title_submit_response'] = 'N&auml;ytett&auml;v&auml; vastaus';
$lang['title_submit_date'] = 'L&auml;hetetty';
$lang['title_approval_date'] = 'Hyv&auml;ksymispvm (yll&auml;pit&auml;j&auml;)';
$lang['title_user_approved'] = 'Hyv&auml;ksymispvm (l&auml;hett&auml;j&auml;)';
$lang['display_text'] = 'N&auml;yt&auml; &quot;L&auml;hetyspohja&quot;';
$lang['redirect_to_page'] = 'Ohjaa sivuston sivulle';
$lang['title_submit_response_help'] = 'T&auml;t&auml; pohjaa k&auml;ytet&auml;&auml;n, kun n&auml;ytet&auml;&auml;n sivu k&auml;ytt&auml;j&auml;lle lomakkeen l&auml;hett&auml;misen j&auml;lkeen. T&auml;m&auml; ei vaikuta luotuihin s&auml;hk&ouml;posteihin tai lomakkeen k&auml;sittelyyn -- asetat ne pohjat (siell&auml; miss&auml; tarpeellista) &quot;Monipuolinen&quot; v&auml;lilehdess&auml; niiss&auml; k&auml;sittelykentiss&auml;.';
$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'] = 'Lis&auml;&auml; painikkeen teksti';
$lang['title_del_button_text'] = 'Poista painikkeen teksti';
$lang['title_field_helptext'] = 'T&auml;m&auml;n kent&auml;n kanssa n&auml;ytett&auml;v&auml; ohjeteksti';
$lang['title_string_or_number_eval'] = 'Tulkitse arvot joko numeroiksi tai merkkijonoiksi';
$lang['title_order'] = 'Tulkintaj&auml;rjestys';
$lang['title_order_help'] = 'Jos laskettavia kentti&auml; on enemm&auml;n kuin yksi, ne lasketaan alemmasta j&auml;rjestysnumerosta isoimpaan';
$lang['title_string_unspaced'] = 'String (no spaces between fields)?';
$lang['title_compute_value'] = 'Laskettava arvo';
$lang['title_compute'] = 'Computed/PHP';
$lang['title_string'] = 'Merkkijono';
$lang['title_numeric'] = 'Numeerinen';
$lang['title_inline_form'] = 'N&auml;yt&auml; lomake sijoitettuna?';
$lang['title_inline_form_help'] = 'Sijoitettu tarkoittaa, ett&auml; lomakkeen jatko korvaa {cms_module} tagin, sijoittamaton korvaa {content} tagin.';
$lang['title_field_default_value'] = 'Kent&auml;n oletusarvo';
$lang['title_clear_default'] = 'Tyhjenn&auml; oletusarvot?';
$lang['title_clear_default_help'] = 'Valitse t&auml;m&auml;, jos haluat tyhjent&auml;&auml; oletusarvot kentist&auml;, kun k&auml;ytt&auml;j&auml; klikkaa niihin. Koska t&auml;m&auml; k&auml;ytt&auml;&auml; JavaScripti&auml; vertaamiseen, se ei toimi, jos laitat lainausmerkkej&auml; (&#039;) oletustekstiisi. Muut JavaScriptin kanssa ep&auml;yhteensopivat merkit voivat my&ouml;s tuottaa ongelmia.';
$lang['title_remove_file_from_server'] = 'Poista l&auml;hetetty tiedosto palvelimelta k&auml;sittelyn j&auml;lkeen (s&auml;hk&ouml;postin j&auml;rjestely)';
$lang['title_field_javascript'] = 'Kent&auml;n JavaScript';
$lang['title_field_javascript_long'] = 'Tee t&auml;st&auml; koko JavaScript kutsu, mukaan lukien tapahtuman, jonka haluat napata, esim. onclick=&quot;yourfn()&quot;';
$lang['title_submit_javascript'] = 'Lomakkeen l&auml;hetyksen JavaScript';
$lang['title_submit_javascript_long'] = 'Tee t&auml;st&auml; koko JavaScript kutsu, mukaan lukien tapahtuman, jonka haluat napata, esim. onclick=&quot;yourfn()&quot;.<br />T&auml;m&auml; ei todenn&auml;k&ouml;isesti toimi, jos k&auml;yt&auml;t &quot;turvascripti&quot; asetusta yl&auml;puolella.';
$lang['email_from_addr_help'] = '&Auml;l&auml; valitse vain sattumanvaraista osoitetta t&auml;h&auml;n -- monet palveluntarjoajat eiv&auml;t l&auml;het&auml; s&auml;hk&ouml;postia, jos muusta kuin omasta domainosoitteesta (eli esimerkiksi nimi@%s)';
$lang['title_switch_advanced'] = 'Tarvitsetko lis&auml;&auml; kentt&auml;tyyppej&auml;?';
$lang['title_switch_basic'] = 'Liian monta sekoittavaa kentt&auml;tyyppi&auml;?';
$lang['title_switch_advanced_link'] = 'Vaihda edistyneeseen tilan';
$lang['title_switch_basic_link'] = 'Vaihda perustilaan';
$lang['title_file_root'] = 'Hakemisto, johon tiedosto tallennetaan';
$lang['title_file_root_help'] = 'T&auml;m&auml;n t&auml;ytyy olla hakemisto, johon palvelimella voidaan kirjoittaa<br />Aseta CHMOD 777, jos sinulla on ongelmia.<br />Tarkista my&ouml;s, ett&auml; sinulla ei ole PHP:n hakemistorajoituksia.';
$lang['title_newline_replacement'] = 'Uudet rivit ja rivinvaihdot korvaava merkki';
$lang['title_newline_replacement_help'] = 'J&auml;t&auml; tyhj&auml;ksi, jos sallit uudet rivit ja rivinvaihdot tulosteessa';
$lang['title_send_usercopy'] = 'L&auml;het&auml; k&auml;ytt&auml;j&auml;lle kopioi viestist&auml;?';
$lang['title_send_usercopy_label'] = 'Otsikko valintaruudulle (jos k&auml;ytt&auml;j&auml;n valitsema)';
$lang['title_send_me_a_copy'] = 'L&auml;het&auml; minulle kopioi lomakkeesta';
$lang['title_allow_subject_override'] = 'Salli aiheen korvaaminen';
$lang['title_allow_subject_override_long'] = 'Salli &#039;Email &quot;Subject&quot; Fields&#039; korvata pudotusvalikon aihe.';
$lang['title_display_length'] = 'N&auml;ytett&auml;v&auml; pituus';
$lang['title_minimum_length'] = 'Vastauksen minimipituus';
$lang['title_hide'] = 'Piilota sy&ouml;te';
$lang['title_hide_help'] = 'N&auml;yt&auml; symbolit tavallisten merkkien sijasta salasanojen kohdalla?';
$lang['password_does_not_match'] = 'Salasana ei vastaa %s';
$lang['back_top'] = 'Takaisin Lomakerakentajan p&auml;&auml;sivulle';
$lang['title_headers_to_modify'] = 'Mitk&auml; s&auml;hk&ouml;postin otsakkeet t&auml;m&auml;n sy&ouml;tteen pit&auml;isi t&auml;ytt&auml;&auml;?';
$lang['title_blank_invalid'] = '&Auml;l&auml; salli pelkki&auml; v&auml;lily&ouml;ntej&auml; vastauksessa';
$lang['title_blank_invalid_long'] = 'Jos kentt&auml; on pakollinen, t&auml;m&auml;n valitseminen vaatii, ett&auml; k&auml;ytt&auml;j&auml;t kirjoittavat kirjaimia tai numeroita, eiv&auml;tk&auml; ainoastaan v&auml;lily&ouml;ntej&auml;';
$lang['title_must_save_order'] = 'You must click one of the &quot;save&quot; buttons to make your new field order permanent.';
$lang['title_html5'] = 'Use HTML5 placeholder text instead of Javascript';
$lang['title_email_cc_address'] = 'Address(es) to email as Carbon copy (CC). Use commas to delimit multiple addresses.';
$lang['title_use_bcc'] = 'Use Blind carbon copy (BCC instead of CC)';
$lang['title_send_using'] = 'Mail Addressing';
$lang['title_field_to_modify'] = 'Email field to add CC address';
$lang['title_modifies'] = 'Add CC to &quot;%s&quot;';
$lang['bcc_field'] = '&quot;BCC&quot; recipients';
$lang['cc_field'] = '&quot;CC&quot; recipients';
$lang['to_field'] = 'Normal (&quot;To&quot; recipients)';
$lang['bcc'] = 'BCC';
$lang['cc'] = 'CC';
$lang['error_CompanyDirectory_module_not_available'] = 'Yrityshakemisto-moduuli ei ole saatavilla!';
$lang['option_never'] = 'Ei koskaan';
$lang['option_user_choice'] = 'Anna k&auml;ytt&auml;j&auml;n valita (valintaruutu)';
$lang['option_always'] = 'Aina';
$lang['option_from'] = '&quot;From&quot; s&auml;hk&ouml;postiosoite';
$lang['option_reply'] = '&quot;Reply-To&quot; s&auml;hk&ouml;postiosoite';
$lang['option_both'] = 'Sek&auml; &quot;From&quot; ett&auml; &quot;Reply-To&quot; s&auml;hk&ouml;postiosoitteet';
$lang['option_dropdown'] = 'Pudotusvalikko';
$lang['option_selectlist_single'] = 'Valintalista (yksi)';
$lang['option_selectlist_multiple'] = 'Valintalista (useampi)';
$lang['option_radiogroup'] = 'Valintapalloryhm&auml;';
$lang['title_company_field_note'] = 'Huomaa: Tulostus on muodossa<br/>&quot;company name&quot;=>&quot;value&quot;';
$lang['title_pick_categories'] = 'Valitse kategoria (useampi)';
$lang['title_pick_fielddef'] = 'Hae kent&auml;n m&auml;&auml;rityksen arvo (yksitt&auml;inen) <em>vapaaehtoinen</em>';
$lang['title_choose_user_input'] = 'Valitse k&auml;ytt&auml;j&auml;n sy&ouml;tt&auml;m&auml; tieto';
$lang['title_see_also_udt'] = '(Katso my&ouml;s Lomakkeen l&auml;hetys -v&auml;lilehte&auml;, jos haluat asettaa UDT:n lomakkeen tarkistukselle)';
$lang['title_year_end_message'] = 'P&auml;&auml;ttymisvuosi';
$lang['title_field_logic'] = 'Smartytagi tai logiikka, joka l&auml;hetet&auml;&auml;n t&auml;m&auml;n kent&auml;n mukana';
$lang['title_field_logic_long'] = 'Voi smartydata, javascript tai muu data, jonka haluat l&auml;hett&auml;&auml; t&auml;m&auml;n kent&auml;n mukana.<br />Menee smartyrakentajan l&auml;pi, joten muista k&auml;ytt&auml;&auml; {literal}{/literal} tageja <script></script> kanssa.';
$lang['title_field_includelabels'] = 'Lis&auml;&auml; otsikot';
$lang['title_field_includelabels_help'] = 'T&auml;m&auml;n asettaminen p&auml;&auml;lle liitt&auml;&auml; otsikot tulostukseen. esimerkiksi - label: value,label2: value2';
$lang['title_field_siblings'] = 'Linkit&auml; t&auml;m&auml; kentt&auml; sen sisaruksiin';
$lang['title_field_siblings_help'] = 'Pudotusvalikko kaikista t&auml;m&auml;n kent&auml;n sisaruksista ja sallii sinun linkitt&auml;&auml; t&auml;m&auml;n kent&auml;n johonkin sen sisarukseen. Mahdollistaa my&ouml;s kent&auml;n hallinnan valittujen sisarusten kontrolleilla.';
$lang['title_field_hidebuttons'] = 'Piilota hallintapainikkeet';
$lang['title_field_hidebuttons_help'] = 'Piilottaa julkisten sivujen hallintapainikkeet t&auml;lt&auml; kent&auml;lt&auml;.';
$lang['title_note'] = 'Note';
$lang['title_changing_triggers_reindex'] = 'Changing any of the above fields will trigger a reindex of *all* saved records, so it could take a while.';
$lang['illegal_file'] = 'Attempted upload of illegal file type (%s) from %s';
$lang['title_searchable'] = 'Make records accessible to Search Module';
$lang['title_searchable_help'] = 'Checking this will make all submitted data accessible to the Search Module. DO NOT use this if you encrypt your data -- the information gets exposed to search whether or not it is encrypted!';
$lang['uploaded_outside_webroot'] = '%s (outside web root)';
$lang['title_fbr_edit'] = 'Editable in FormBrowser Admin?';
$lang['title_active_only'] = 'Only include active users?';
$lang['error_usertag_disposition'] = 'K&auml;ytt&auml;j&auml;n m&auml;&auml;rittelem&auml; tagi palautti virheen';
$lang['error_usertag'] = 'K&auml;ytt&auml;j&auml;n m&auml;&auml;rittelem&auml; tagi %s palautti virheen.';
$lang['error_cataloger_module_not_available'] = '<strong>Kataloogimoduulia ei ole asennettu tai se ei ole aktiivisena.</strong>';
$lang['warning'] = 'VAROITUS!';
$lang['default_template'] = 'Oletuspohja';
$lang['table_left_template'] = 'Taulukkopohja, otsikko vasemmalla';
$lang['table_top_template'] = 'Taulukkopohja, otsikko yl&auml;puolella';
$lang['form_template_name'] = 'Sivupohja %s';
$lang['template_are_you_sure'] = 'Oletko varma, ett&auml; haluat korvata sivupohjan valitulla pohjalla? (Vaikka valitset OK, sinun t&auml;ytyy silti tallentaa muutokset)';
$lang['title_bad_function'] = 'Virhe laskettaessa &quot;%s&quot;.';
$lang['no_referrer_info'] = 'HTTP_REFERER tietoa ei ole saatavilla (luultavasti johtuu k&auml;ytt&auml;j&auml;n s&auml;hk&ouml;postin tarkistuksesta)';
$lang['validation_param_error'] = 'Tarkistusparametrin virhe. Tarkista, ett&auml; kopioit url-osoitteen s&auml;hk&ouml;postistasi oikein!';
$lang['validation_response_error'] = 'Tarkistusvirhe. Tarkista, ett&auml; kopioit url-osoitteen s&auml;hk&ouml;postistasi oikein!';
$lang['validation_no_field_error'] = 'Tarkistusvirhe. T&auml;ss&auml; lomakkeessa ei ole s&auml;hk&ouml;postin tarkistuskentt&auml;&auml;!';
$lang['upgrade03to04'] = 'Lomakkeen pohja p&auml;ivitettiin automaattisesti versiosta 0.3 versioon 0.4 p&auml;ivityksen osana. Sinun tarvitsee ehk&auml; tehd&auml; korjauksia. Jos k&auml;yt&auml;t oletuslomaketta, yksinkertaisesti korvaa pohja &quot;oletuksella&quot; yl&auml;puolella olevassa pudotusvalikossa.';
$lang['admindesc'] = 'Lis&auml;&auml;, muokkaa ja hallinnoi interaktiivia lomakkeita.';
$lang['must_specify_one_admin'] = 'Must specify an Admin';
$lang['operators_help'] = 'Jos k&auml;yt&auml;t merkkijonojen tarkistusta, ainoa toimenpide saatavilla on lis&auml;ys (+), jos taas k&auml;yt&auml;t numeerista tarkistusta, voit k&auml;ytt&auml;&auml; yksinkertaista matematiikkaa (, +, -, *, /, ).';
$lang['help_module_interface'] = 'K&auml;ytet&auml;&auml;n moduulik&auml;ytt&ouml;liittym&auml;&auml;';
$lang['help_module_interface_long'] = '<b>This field is used as a gateway to other modules!</b>
Use it by creating your form elements in the templates of the other module(s) you wish to incorporate, and using the <strong>{$FBid}</strong> to tie it back to FormBuilder. For example, to include form options based on the Products module, create the following template in Products:<br/>
<pre>
{foreach from=$items item=entry}
	{assign var=MData value=&#039;&#039;}
	{assign var=Cd value=&#039;&#039;}
		{foreach from=$FBvalue item=MData}
			{assign var=MData value=&#039;::&#039;|explode:$MData}
			{if $MData[1]==$entry->id}
				{assign var=Cd value=&#039; checked=&quot;checked&quot;&#039;}
			{/if}
		{/foreach}
	<div class=&quot;ProductDirectoryItem&quot;>
		<input type=&quot;checkbox&quot; value=&quot;{$entry->price}::{$entry->id}&quot; name=&quot;{$FBid}[]&quot; {$Cd} />{$entry->product_name} ({$entry->weight}{$weight_units}) &pound;{$entry->price}    
	</div>
{/foreach}
</pre>
<br/>
where in the input below you put something like <strong>{Products category=&quot;cat&quot; summarytemplate=&quot;Your_FB_template&quot;}</strong>';
$lang['title_add_tag'] = 'Lis&auml;&auml; tagisi';
$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['AF'] = 'Afghanistan';
$lang['AX'] = 'Aland Islands';
$lang['AL'] = 'Albania';
$lang['DZ'] = 'Algeria';
$lang['AS'] = 'American Samoa';
$lang['AD'] = 'Andorra';
$lang['AO'] = 'Angola';
$lang['AI'] = 'Anguilla';
$lang['AQ'] = 'Antarctica';
$lang['AG'] = 'Antigua and Barbuda';
$lang['AR'] = 'Argentina';
$lang['AM'] = 'Armenia';
$lang['AW'] = 'Aruba';
$lang['AU'] = 'Australia';
$lang['AT'] = 'Austria';
$lang['AZ'] = 'Azerbaijan';
$lang['BS'] = 'Bahamas';
$lang['BH'] = 'Bahrain';
$lang['BB'] = 'Barbados';
$lang['BD'] = 'Bangladesh';
$lang['BY'] = 'Belarus';
$lang['BE'] = 'Belgium';
$lang['BZ'] = 'Belize';
$lang['BJ'] = 'Benin';
$lang['BM'] = 'Bermuda';
$lang['BT'] = 'Bhutan';
$lang['BW'] = 'Botswana';
$lang['BO'] = 'Bolivia';
$lang['BA'] = 'Bosnia and Herzegovina';
$lang['BV'] = 'Bouvet Island';
$lang['BR'] = 'Brazil';
$lang['IO'] = 'British Indian Ocean Territory';
$lang['BN'] = 'Brunei Darussalam';
$lang['BG'] = 'Bulgaria';
$lang['BF'] = 'Burkina Faso';
$lang['BI'] = 'Burundi';
$lang['KH'] = 'Cambodia';
$lang['CM'] = 'Cameroon';
$lang['CA'] = 'Canada';
$lang['CV'] = 'Cape Verde';
$lang['KY'] = 'Cayman Islands';
$lang['CF'] = 'Central African Republic';
$lang['TD'] = 'Chad';
$lang['CL'] = 'Chile';
$lang['CN'] = 'China';
$lang['CX'] = 'Christmas Island';
$lang['CC'] = 'Cocos (Keeling) Islands';
$lang['CO'] = 'Colombia';
$lang['KM'] = 'Comoros';
$lang['CG'] = 'Congo';
$lang['CD'] = 'Congo,  Democratic Republic';
$lang['CK'] = 'Cook Islands';
$lang['CR'] = 'Costa Rica';
$lang['CI'] = 'Ivoire (Ivory Coast)';
$lang['HR'] = 'Croatia (Hrvatska)';
$lang['CU'] = 'Cuba';
$lang['CY'] = 'Cyprus';
$lang['CZ'] = 'Czech Republic';
$lang['DK'] = 'Denmark';
$lang['DJ'] = 'Djibouti';
$lang['DM'] = 'Dominica';
$lang['DO'] = 'Dominican Republic';
$lang['TP'] = 'East Timor';
$lang['EC'] = 'Ecuador';
$lang['EG'] = 'Egypt';
$lang['SV'] = 'El Salvador';
$lang['GQ'] = 'Equatorial Guinea';
$lang['ER'] = 'Eritrea';
$lang['EE'] = 'Estonia';
$lang['ET'] = 'Ethiopia';
$lang['FK'] = 'Falkland Islands (Malvinas)';
$lang['FO'] = 'Faroe Islands';
$lang['FJ'] = 'Fiji';
$lang['FI'] = 'Finland';
$lang['FR'] = 'France';
$lang['FX'] = 'France,  Metropolitan';
$lang['GF'] = 'Guernsey';
$lang['PF'] = 'French Polynesia';
$lang['TF'] = 'French Southern Territories';
$lang['MK'] = 'F.Y.R.O.M. (Macedonia)';
$lang['GA'] = 'Gabon';
$lang['GM'] = 'Gambia';
$lang['GE'] = 'Georgia';
$lang['DE'] = 'Germany';
$lang['GH'] = 'Ghana';
$lang['GI'] = 'Gibraltar';
$lang['GB'] = 'Great Britain (UK)';
$lang['GR'] = 'Greece';
$lang['GL'] = 'Greenland';
$lang['GD'] = 'Grenada';
$lang['GP'] = 'Guadeloupe';
$lang['GU'] = 'Guam';
$lang['GT'] = 'Guatemala';
$lang['GN'] = 'Guinea';
$lang['GW'] = 'Guinea-Bissau';
$lang['GY'] = 'Guyana';
$lang['HT'] = 'Haiti';
$lang['HM'] = 'Heard and McDonald Islands';
$lang['HN'] = 'Honduras';
$lang['HK'] = 'Hong Kong';
$lang['HU'] = 'Hungary';
$lang['IS'] = 'Iceland';
$lang['IN'] = 'India';
$lang['ID'] = 'Indonesia';
$lang['IR'] = 'Iran';
$lang['IQ'] = 'Iraq';
$lang['IE'] = 'Ireland';
$lang['IL'] = 'Israel';
$lang['IM'] = 'Isle of Man';
$lang['IT'] = 'Italy';
$lang['JE'] = 'Jersey';
$lang['JM'] = 'Jamaica';
$lang['JP'] = 'Japan';
$lang['JO'] = 'Jordan';
$lang['KZ'] = 'Kazakhstan';
$lang['KE'] = 'Kenya';
$lang['KI'] = 'Kiribati';
$lang['KP'] = 'Korea (North)';
$lang['KR'] = 'Korea (South)';
$lang['KW'] = 'Kuwait';
$lang['KG'] = 'Kyrgyzstan';
$lang['LA'] = 'Laos';
$lang['LV'] = 'Latvia';
$lang['LB'] = 'Lebanon';
$lang['LI'] = 'Liechtenstein';
$lang['LR'] = 'Liberia';
$lang['LY'] = 'Libya';
$lang['LS'] = 'Lesotho';
$lang['LT'] = 'Lithuania';
$lang['LU'] = 'Luxembourg';
$lang['MO'] = 'Macau';
$lang['MG'] = 'Madagascar';
$lang['MW'] = 'Malawi';
$lang['MY'] = 'Malaysia';
$lang['MV'] = 'Maldives';
$lang['ML'] = 'Mali';
$lang['MT'] = 'Malta';
$lang['MH'] = 'Marshall Islands';
$lang['MQ'] = 'Martinique';
$lang['MR'] = 'Mauritania';
$lang['MU'] = 'Mauritius';
$lang['YT'] = 'Mayotte';
$lang['MX'] = 'Mexico';
$lang['FM'] = 'Micronesia';
$lang['MC'] = 'Monaco';
$lang['MD'] = 'Moldova';
$lang['MA'] = 'Morocco';
$lang['MN'] = 'Mongolia';
$lang['MS'] = 'Montserrat';
$lang['MZ'] = 'Mozambique';
$lang['MM'] = 'Myanmar';
$lang['NA'] = 'Namibia';
$lang['NR'] = 'Nauru';
$lang['NP'] = 'Nepal';
$lang['NL'] = 'Netherlands';
$lang['AN'] = 'Netherlands Antilles';
$lang['NT'] = 'Neutral Zone';
$lang['NC'] = 'New Caledonia';
$lang['NZ'] = 'New Zealand (Aotearoa)';
$lang['NI'] = 'Nicaragua';
$lang['NE'] = 'Niger';
$lang['NG'] = 'Nigeria';
$lang['NU'] = 'Niue';
$lang['NF'] = 'Norfolk Island';
$lang['MP'] = 'Northern Mariana Islands';
$lang['NO'] = 'Norway';
$lang['OM'] = 'Oman';
$lang['PK'] = 'Pakistan';
$lang['PW'] = 'Palau';
$lang['PS'] = 'Palestinian Territory';
$lang['PA'] = 'Panama';
$lang['PG'] = 'Papua New Guinea';
$lang['PY'] = 'Paraguay';
$lang['PE'] = 'Peru';
$lang['PH'] = 'Philippines';
$lang['PN'] = 'Pitcairn';
$lang['PL'] = 'Poland';
$lang['PT'] = 'Portugal';
$lang['PR'] = 'Puerto Rico';
$lang['QA'] = 'Qatar';
$lang['RE'] = 'Reunion';
$lang['RO'] = 'Romania';
$lang['RU'] = 'Russian Federation';
$lang['RW'] = 'Rwanda';
$lang['GS'] = 'S. Georgia and S. Sandwich Isls.';
$lang['KN'] = 'Saint Kitts and Nevis';
$lang['LC'] = 'Saint Lucia';
$lang['VC'] = 'Saint Vincent &amp; the Grenadines';
$lang['WS'] = 'Samoa';
$lang['SM'] = 'San Marino';
$lang['ST'] = 'Sao Tome and Principe';
$lang['SA'] = 'Saudi Arabia';
$lang['SN'] = 'Senegal';
$lang['SC'] = 'Seychelles';
$lang['SL'] = 'Sierra Leone';
$lang['SG'] = 'Singapore';
$lang['SI'] = 'Slovenia';
$lang['SK'] = 'Slovak Republic';
$lang['SB'] = 'Solomon Islands';
$lang['SO'] = 'Somalia';
$lang['ZA'] = 'South Africa';
$lang['ES'] = 'Spain';
$lang['LK'] = 'Sri Lanka';
$lang['SH'] = 'St. Helena';
$lang['PM'] = 'St. Pierre and Miquelon ';
$lang['SD'] = 'Sudan';
$lang['SR'] = 'Suriname';
$lang['SJ'] = 'Svalbard &amp; Jan Mayen Islands';
$lang['SZ'] = 'Swaziland';
$lang['SE'] = 'Sweden';
$lang['CH'] = 'Switzerland';
$lang['SY'] = 'Syria';
$lang['TW'] = 'Taiwan';
$lang['TJ'] = 'Tajikistan';
$lang['TZ'] = 'Tanzania';
$lang['TH'] = 'Thailand';
$lang['TG'] = 'Togo';
$lang['TK'] = 'Tokelau';
$lang['TO'] = 'Tonga';
$lang['TT'] = 'Trinidad and Tobago';
$lang['TN'] = 'Tunisia';
$lang['TR'] = 'Turkey';
$lang['TM'] = 'Turkmenistan';
$lang['TC'] = 'Turks and Caicos Islands';
$lang['TV'] = 'Tuvalu';
$lang['UG'] = 'Uganda';
$lang['UA'] = 'Ukraine';
$lang['AE'] = 'United Arab Emirates';
$lang['UK'] = 'United Kingdom';
$lang['US'] = 'United States';
$lang['UM'] = 'US Minor Outlying Islands';
$lang['UY'] = 'Uruguay';
$lang['UZ'] = 'Uzbekistan';
$lang['VU'] = 'Vanuatu';
$lang['VA'] = 'Vatican City State (Holy See)';
$lang['VE'] = 'Venezuela';
$lang['VN'] = 'Viet Nam';
$lang['VG'] = 'Virgin Islands (British)';
$lang['VI'] = 'Virgin Islands (U.S.)';
$lang['WF'] = 'Wallis and Futuna Islands';
$lang['EH'] = 'Western Sahara';
$lang['YE'] = 'Yemen';
$lang['YU'] = 'Yugoslavia';
$lang['ZM'] = 'Zambia';
$lang['ZW'] = 'Zimbabwe';
$lang['submission_error'] = 'Lomakkeen l&auml;hetyksess&auml; tapahtui virhe.';
$lang['submit_error'] = 'FormBuilderin l&auml;hetysvirhe: %s';
$lang['uploads_error'] = 'Virhe tiedoston antamisessa l&auml;hetysmoduulille: %s';
$lang['nouploads_error'] = 'L&auml;hetysmoduulia ei l&ouml;ytynyt';
$lang['upload_attach_error'] = 'Tapahtui virhe l&auml;hetett&auml;ess&auml; tai liitett&auml;ess&auml; tiedostoa %s (tmp_name: %s, tyyppi %s)';
$lang['submission_error_file_lock'] = 'Virhe. Tiedostoa ei voida lukita.';
$lang['unchecked_by_default'] = 'Oletus: valitsematta';
$lang['checked_by_default'] = 'Oletus: valittu';
$lang['email_default_template'] = 'FormBuilderin l&auml;hetys';
$lang['email_template_not_set'] = '<br/>S&auml;hk&ouml;postipohjaa ei ole asetettu!';
$lang['missing_cms_mailer'] = 'Lomakerakentajar: Vaadittua moduulia CMSMailer ei l&ouml;ydy!';
$lang['user_approved_submission'] = 'K&auml;ytt&auml;j&auml;n hyv&auml;ksym&auml; l&auml;hetys %s %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Tapahtuma, jota kutsutaan, kun Lomakerakentajan lomake l&auml;hetet&auml;&auml;n';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Tapahtuma, jota kutsutaan, kun tapahtuu virhe Lomakerakentajan lomakkeen l&auml;hett&auml;misess&auml;';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Tapahtuma, jota kutsutaan, kun Lomakerakentajan lomake n&auml;ytet&auml;&auml;n';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Tapahtuma, jota kutsutaan, kun Lomakerakentajan lomake l&auml;hetet&auml;&auml;n.</p>
<h4>Parametrit</h4>
<ul>
<li><em>form_name</em> - Lomakkeen nimi (string)</li>
<li><em>form_id</em> - Sis&auml;inen lomakkeen tunniste (int)</li>
<li><em>value_<name></em> - Anna oletusarvo kent&auml;lle, jolla on m&auml;&auml;ritelty nimi.</li>
</ul> ';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Tapahtuma, jota kutsutaan, kun Lomakerakentajan lomakkeen l&auml;hett&auml;misess&auml; tapahtuu virhe</p>
<h4>Parametrit</h4>
<ul>
<li><em>form_name</em> - Lomakkeen nimi (string)</li>
<li><em>form_id</em> - Sis&auml;inen lomakkeen tunniste (int)</li>
<li><em>error</em> - Lista tunnetuista virheist&auml; (string)</li>
</ul> ';
$lang['event_help_OnFormBuilderFormDisplay'] = '<p>Tapahtuma, jota kutsutaan, kun Lomakerakentajan lomake n&auml;ytet&auml;&auml;n</p>
<h4>Parametrit</h4>
<ul>
<li><em>form_name</em> - Lomakkeen nimi (string)</li>
<li><em>form_id</em> - Sis&auml;inen lomakkeen tunniste (int)</li>
</ul> ';
$lang['formbuilder_params_response_id'] = 'Vastaustunniste. T&auml;t&auml; k&auml;ytt&auml;&auml; FormBrowser';
$lang['formbuilder_params_passed_from_tag'] = 'Kenttien oletusarvot; katso lis&auml;tietoa moduulin ohjeista';
$lang['formbuilder_params_field_id'] = 'Kent&auml;n tunniste sis&auml;isille toiminnoille';
$lang['formbuilder_params_form_name'] = 'Lomakkeen nimi';
$lang['formbuilder_params_form_id'] = 'Lomakkeen tunniste sis&auml;isille toiminnoille';
$lang['formbuilder_params_general'] = 'Yleiset parametrit sis&auml;isille toiminnoille';
$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['qca'] = 'P0-975058195-1309584694735';
$lang['utma'] = '156861353.1361895121.1314888648.1314888648.1314888648.1';
$lang['utmc'] = '156861353';
$lang['utmz'] = '156861353.1314888648.1.1.utmcsr=(direct)|utmccn=(direct)|utmcmd=(none)';
$lang['utmb'] = '156861353.1.10.1314888648';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/fr_FR.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Formulaires (Form Builder)';
$lang['field_type_DispositionEmailFromFEUProperty'] = '*Envoyer aux utilisateurs FEU qui correspondent à une certaine propriété';
$lang['field_type_'] = 'Type de champ non renseigné';
$lang['field_type_CatalogerItemsField'] = 'Sélectionner un (ou plusieurs) items de Cataloger';
$lang['field_type_FieldsetEnd'] = '-Fin de champ renseigné';
$lang['field_type_FieldsetStart'] = '-Début de champ renseigné';
$lang['field_type_TextField'] = 'Ligne de texte simple';
$lang['field_type_HTML5NumberField'] = 'Entrée Nombre HTML5';
$lang['field_type_HTML5EmailField'] = 'Entrée Email HTML5';
$lang['field_type_HTML5URLField'] = 'Entrée URL HTML5';
$lang['field_type_SiteAdminField'] = 'Administration du site';
$lang['field_type_PasswordField'] = 'Mot de passe';
$lang['field_type_PasswordAgainField'] = 'Mot de passe (à nouveau pour vérification)';
$lang['field_type_TextFieldExpandable'] = 'Lignes de texte multiples';
$lang['field_type_TextAreaField'] = 'Zone de texte';
$lang['field_type_ButtonField'] = 'Bouton';
$lang['field_type_CheckboxField'] = 'Case à cocher';
$lang['field_type_CheckboxGroupField'] = 'Groupe de cases à cocher';
$lang['field_type_PulldownField'] = 'Menu déroulant';
$lang['field_type_YearPullDownField'] = 'Menu déroulant année';
$lang['field_type_MultiselectField'] = 'Sélection multiple';
$lang['field_type_StatePickerField'] = 'Sélectionner un état des USA';
$lang['field_type_ProvincePickerField'] = 'Sélectionner une Province du Canada';
$lang['field_type_CountryPickerField'] = 'Sélectionner un pays';
$lang['field_type_DatePickerField'] = 'Sélectionner une date';
$lang['field_type_TimePickerField'] = 'Sélectionner une heure';
$lang['field_type_RadioGroupField'] = 'Groupe de boutons radio';
$lang['field_type_DispositionDirector'] = '*Adresser par mail les résultats après choix par menu déroulant';
$lang['field_type_DispositionFileDirector'] = '*Sauvegarder les résultats vers un fichier après choix par menu déroulant';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Sauvegarder en fichier(s) les résultats des sélections multiples';
$lang['field_type_DispositionPageRedirector'] = '*Rediriger vers la page à partir d\'un menu déroulant';
$lang['field_type_DispositionEmail'] = '*Envoyer par mail les résultats aux adresses fournies';
$lang['field_type_DispositionEmailConfirmation'] = '*Validation via adresse mail';
$lang['field_type_DispositionFromEmailAddressField'] = '*Mail champ "From Address", et envoie copie';
$lang['field_type_DispositionFile'] = '*Écrire les résultats dans un fichier';
$lang['field_type_DispositionUniqueFile'] = '*Ecrire les résultats vers un fichier à chaque soumission';
$lang['field_type_DispositionDatabase'] = '*Stocker les résultats dans la base de données';
$lang['field_type_DispositionFormBrowser'] = '*Stocker les résultats pour le module FormBrowser v0.3/v0.4';
$lang['field_type_DispositionUserTag'] = '*Appeler une balise utilisateur avec les résultats du formulaire';
$lang['field_type_DispositionForm'] = '*Soumettre à une quelconque action sur le formulaire';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Envoyer par mail aux utilisateurs ayant fourni une adresse';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Mail vers l\'administrateur du CMS';
$lang['field_type_DispositionEmailBasedFrontendFields'] = '*Envoyer par e-mail en fonction des champs saisis';
$lang['field_type_PageBreakField'] = '-Saut de page';
$lang['field_type_FileUploadField'] = 'Fichier à envoyer';
$lang['field_type_FromEmailAddressField'] = 'Champ du mail "From Adresse"';
$lang['field_type_FromEmailAddressAgainField'] = 'Champ du mail "From Adresse" à nouveau';
$lang['field_type_FromEmailNameField'] = 'Champ du mail "From Nom"';
$lang['field_type_FromEmailSubjectField'] = 'Champ du mail "Sujet"';
$lang['field_type_CCEmailAddressField'] = 'Champ du mail en Copie Conforme (CC)';
$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é';
$lang['field_type_ComputedField'] = '-Champ calculé';
$lang['field_type_UniqueIntegerField'] = '-Entier unique (Série)';
$lang['field_type_UserTagField'] = '-Appel d\'une balise utilisateur';
$lang['field_type_CompanyDirectoryField'] = 'Champ Company Directory';
$lang['field_type_ModuleInterfaceField'] = '-Champ Module Interface';
$lang['field_type_CheckboxExtendedField'] = 'case de validation étendue';
$lang['validation_none'] = 'Sans Validation';
$lang['validation_numeric'] = 'Numérique';
$lang['validation_integer'] = 'Entier';
$lang['validation_email_address'] = 'Adresse mail';
$lang['validation_usphone'] = 'Numéro de téléphone (US)';
$lang['validation_must_check'] = 'Doit être vérifié';
$lang['validation_regex_match'] = 'Valider l\'expression regulière';
$lang['validation_regex_nomatch'] = 'Ne pas valider l\'expression regulière';
$lang['validation_empty'] = 'Ne peut être vide';
$lang['required'] = 'Nécessaire';
$lang['not_required'] = 'Facultatif';
$lang['not_available'] = 'Non disponible';
$lang['error_emailfromfeuprop'] = 'Erreur lors du paramétrage du champ';
$lang['error_nofeu'] = 'Le module Gestion des utilisateurs du site (FrontEndUsers) n\'a pas été trouvé. Ce champ ne fonctionnera pas.';
$lang['error_nofeudefns'] = 'Aucune propriété FEU trouvée. Ce champ ne fonctionnera pas.';
$lang['required_field_missing'] = 'Un champ obligatoire n\'a pas été rempli';
$lang['please_enter_a_value'] = 'Veuillez entrer une valeur pour "%s"';
$lang['please_enter_a_number'] = 'Veuillez entrer un nombre pour "%s"';
$lang['please_enter_valid'] = 'Veuillez entrer une valeur correcte pour "%s"';
$lang['please_enter_an_integer'] = 'Veuillez entrer une valeur entière pour "%s"';
$lang['please_enter_an_email'] = 'Veuillez entrer une adresse mail valide pour "%s"';
$lang['email_address_does_not_match'] = 'L\'adresse mail ne correspond pas à la valeur de "% s"';
$lang['please_enter_a_phone'] = 'Veuillez entrer un numéro de téléphone valide pour "%s"';
$lang['please_login'] = 'Merci de vous connectez pour utiliser ce formulaire';
$lang['not_valid_email'] = '"%s" ne semble pas être une adresse mail valide !';
$lang['please_enter_no_longer'] = 'Veuillez entrer une valeur n\'ayant pas plus de %s caractères';
$lang['please_enter_at_least'] = 'Veuillez entrer une valeur au minimum de % s caractères';
$lang['title_list_delimiter'] = 'Caractère utilisé comme "séparateur" dans les formulaires reçus contenant plus d\'une valeur&nbsp;';
$lang['you_need_permission'] = 'Il vous faut la permission "%s" pour exécuter cette opération.';
$lang['lackpermission'] = 'Désolé ! Vous n\'avez pas les droits suffisants pour accéder à cette section.';
$lang['field_order_updated'] = 'Ordre des champs mis à jour.';
$lang['form_deleted'] = 'Formulaire supprimé.';
$lang['field_deleted'] = 'Champ supprimé.';
$lang['configuration_updated'] = 'Configuration mise à jour.';
$lang['you_must_check'] = 'Vérifiez "%s" pour pouvoir continuer.';
$lang['must_specify_one_destination'] = 'Vous devez pré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ées ne seront disponibles que lorsque qu\'un type de champ aura été choisi.';
$lang['field_name_in_use'] = 'Il existe déjà un champ "%s" utilisé. Utilisez des noms de champ uniques ou désactivez cette fonction dans la configuration de Form Builder.';
$lang['field_no_name'] = 'Tous les champs doivent être nommés, sinon désactivez cette fonction dans la configuration de Form Builder.';
$lang['no_field_assigned'] = 'Aucun champ désigné pour %s';
$lang['anonymous'] = 'Anonyme';
$lang['abbreviation_length'] = 'Longueur : %s';
$lang['boxes'] = '%s boîtes';
$lang['options'] = '%s options&nbsp;';
$lang['text_length'] = '%s caractères.';
$lang['order'] = 'Ordre';
$lang['unspecified'] = '[non spécifié]';
$lang['added'] = 'ajouté';
$lang['updated'] = 'mis à jour';
$lang['sort_options'] = 'Trier les options à l\'exécution&nbsp;';
$lang['select_one'] = 'Sélectionnez-en un';
$lang['select_type'] = 'Sélectionnez le type';
$lang['to'] = 'Pour';
$lang['yes'] = 'Oui';
$lang['no'] = 'Non';
$lang['recipients'] = 'destinataires';
$lang['fields'] = 'champs';
$lang['file_count'] = '%s fichiers possibles';
$lang['destination_count'] = '%s destinations&nbsp;';
$lang['save'] = 'Sauvegarder';
$lang['add'] = 'Ajouter';
$lang['update'] = 'Mise à jour';
$lang['save_and_continue'] = 'Sauvegarder et continuer l\'édition';
$lang['information'] = 'Information&nbsp;';
$lang['automatic'] = 'Automatique';
$lang['forms'] = 'Formulaires';
$lang['form'] = 'Formulaire %s';
$lang['configuration'] = 'Configuration&nbsp;';
$lang['field_requirement_updated'] = 'Champ requis mis à jour.';
$lang['maximum_size'] = 'Taille Maximum';
$lang['permitted_extensions'] = 'Extensions&nbsp;';
$lang['permitted_filetypes'] = 'Types de fichier autorisés';
$lang['file_too_large'] = 'Le fichier envoyé est trop lourd ! La taille maximum est de :&nbsp;';
$lang['illegal_file_type'] = 'Ce type de fichier n\'est pas accepté. Veuillez vérifier l\'extension de votre fichier.';
$lang['upload'] = 'Envoi';
$lang['form_imported'] = 'Formulaire Importé.';
$lang['form_import_failed'] = 'L\'importation du formulaire a échoué ! Il y a un problè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&nbsp;';
$lang['merid'] = 'Méridien';
$lang['date_range'] = 'Ordre : %s - %s';
$lang['thanks'] = 'Merci ! Votre formulaire a été reçu.';
$lang['edit'] = 'Éditer';
$lang['delete'] = 'Supprimer';
$lang['day'] = 'Jour';
$lang['mon'] = 'Mois';
$lang['year'] = 'Année';
$lang['none'] = '(Aucun)';
$lang['css'] = 'CSS&nbsp;';
$lang['uninstalled'] = 'Module désinstallé.';
$lang['installed'] = 'Module version %s installée.';
$lang['upgraded'] = 'Module mis à jour à la version %s.';
$lang['button_previous'] = 'Retour...';
$lang['button_submit'] = 'Envoyer';
$lang['button_continue'] = 'Suivant...';
$lang['value_checked'] = 'Coché';
$lang['value_unchecked'] = 'Non coché';
$lang['tab_main'] = 'Principal';
$lang['tab_symbol'] = 'Paramètres d\'affichage du Formulaire';
$lang['tab_submit'] = 'Envoi du Formulaire';
$lang['tab_captcha'] = 'Options Captcha';
$lang['tab_advanced'] = 'Options avancées';
$lang['tab_templatelayout'] = 'Gabarit du Formulaire';
$lang['tab_submissiontemplate'] = 'Gabarit de l\'envoi';
$lang['tab_udt'] = 'Intégration de balise utilisateur';
$lang['title_feu_property'] = 'Propriété FrontEndUsers';
$lang['info_feu_property'] = 'Seulement certains types de propriété peuvent être utilisés pour corroborer (menus déroulants, champs de sélection multiple, etc.).';
$lang['canuse_smarty'] = '<em>Les variables Smarty sont actives dans ce champ.</em>';
$lang['add_options'] = 'Ajouter plus d\'options';
$lang['delete_options'] = 'Supprimer les options sélectionnées';
$lang['add_checkboxes'] = 'Ajouter d\'autres boîtes de vérification';
$lang['delete_checkboxes'] = 'Supprimer les boîtes de vérification sélectionnées';
$lang['add_address'] = 'Ajouter d\'autres adresses mail';
$lang['delete_address'] = 'Supprimer les adresses mail sélectionnées';
$lang['add_destination'] = 'Ajouter d\'autres destinations';
$lang['delete_destination'] = 'Supprimer les destinations sélectionnées';
$lang['suspected_spam'] = 'Trop de mails sont générés à partir de votre adresse IP ! Le système anti-spam a été activé et les administrateurs du site en ont été informés.';
$lang['suspected_spam_log'] = 'De possibles spams provenant de l\'IP %s ont été stoppés.';
$lang['reorder'] = 'Réorganiser les champs';
$lang['cancel'] = 'Annuler';
$lang['value_set'] = 'Valeur donnée : %s';
$lang['title_cataloger_attribute_fields'] = 'Cataloge des champs d\'attribut';
$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['title_textfield_label'] = 'Intitulé de champ de texte';
$lang['title_show_textfield'] = 'Montrer un champ texte ?';
$lang['help_name_regex'] = 'Une expression reguliè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\'expression regulière pour Cataloger';
$lang['title_field_height'] = 'Hauteur du champ';
$lang['title_file_path'] = 'Dossier de destination pour les fichiers crées&nbsp;';
$lang['title_udt_name'] = 'Balise utilisateur&nbsp;';
$lang['title_uploads_destpage'] = 'Page de retour pour les liens d\'uploads (envois)';
$lang['title_uploadmodule_summary'] = 'Envoyé avec formbuilder';
$lang['title_uploads_category'] = 'Catégorie d\'Uploads (envois)';
$lang['title_sendto_uploads'] = 'Envoyer ce fichier au module d\'upload';
$lang['title_allow_overwrite'] = 'Autoriser l\'écrasemement des fichiers déjà existants lors de l\'upload ?';
$lang['title_allow_overwrite_long'] = 'Le fichier uploadé doit-il écraser le fichier précédemment uploadé s\'il a le même nom ?';
$lang['overwrite'] = 'Permet le remplacement';
$lang['nooverwrite'] = 'Non remplacé';
$lang['file_already_exists'] = 'Le fichier %s existe déjà, et ne peut pas être écrasé.';
$lang['title_file_rename'] = 'Nom du fichier gabarit';
$lang['original_file_extension'] = 'Extension originale du fichier (le "." compris)';
$lang['title_suppress_filename'] = 'Supprimer le nom de fichier dans les mails et dans les formulaires pour l\'utilisateur final';
$lang['title_suppress_attachment'] = 'Empêcher d\'attacher des fichiers aux emails';
$lang['file_rename_help'] = 'Pour renommer un fichier pour l\'upload, créez le gabarit ici. Laissez vide pour préserver le nom du fichier original';
$lang['title_legend'] = 'Légende&nbsp;';
$lang['title_maximum_length'] = 'Longueur maximum&nbsp;';
$lang['title_checkbox_label'] = 'Intitulé de la case à cocher&nbsp;';
$lang['title_radio_label'] = 'Intitulé du bouton radio';
$lang['title_checked_value'] = 'Valeur cochée&nbsp;';
$lang['title_unchecked_value'] = 'Valeur non cochée&nbsp;';
$lang['title_checkbox_details'] = 'Détails des groupes de cases à cocher&nbsp;';
$lang['title_delete'] = 'Supprimer ?';
$lang['title_select_one_message'] = 'Texte personnalisable "sélection"&nbsp;';
$lang['title_selection_value'] = 'Valeur sélectionnée';
$lang['title_selection_displayname'] = 'Nom d\'affichage sélectionné&nbsp;';
$lang['title_selection_subject'] = 'Sujet sélectionné';
$lang['title_select_default_country'] = 'Sélection par défaut&nbsp;';
$lang['title_select_default_state'] = 'Sélection par défaut&nbsp;';
$lang['title_select_default_province'] = 'Sélection par défaut&nbsp;';
$lang['title_option_name'] = 'Nom de l\'option';
$lang['title_option_value'] = 'Valeur soumise';
$lang['title_pulldown_details'] = 'Options par menu déroulant&nbsp;';
$lang['title_multiselect_details'] = 'Options de Sé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'] = '"From Name" pour le mail&nbsp;';
$lang['title_relaxed_email_regex'] = 'Utiliser une validation d\'adresse mail plus souple&nbsp;';
$lang['title_relaxed_regex_long'] = 'Autoriser les adresses mail sans extension (c.a.d : accepter "nom@domaine" à la place de "nom@domaine.com" requis par défaut)';
$lang['title_email_from_address'] = '"From Adresse" pour Mail de l\'expéditeur&nbsp;';
$lang['title_email_encoding'] = 'Encodage des caractères du mail&nbsp;';
$lang['title_director_details'] = 'Menu déroulant basé sur les détails de l\'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'] = 'Statut du Formulaire&nbsp;';
$lang['title_ready_for_deployment'] = 'Prêt à être déployé';
$lang['title_not_ready1'] = 'Pas prêt';
$lang['title_redirect_page'] = 'Page où rediriger après l\'envoi du formulaire&nbsp;';
$lang['title_not_ready2'] = 'Ajouter un champ au formulaire pour pouvoir modifier les contributions des utilisateurs. Vous pouvez';
$lang['title_not_ready_link'] = 'utiliser ce raccourci';
$lang['title_form_alias'] = 'Alias du Formulaire&nbsp;';
$lang['title_field_alias_short'] = 'Alias&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 alias de champs lors de l\'ajout ou de l\'édition d\'un formulaire';
$lang['title_field_name'] = 'Nom de champ&nbsp;';
$lang['title_field_alias'] = 'Alias du champ et attribut id DOM (id CSS)&nbsp;';
$lang['title_radiogroup_details'] = 'Détails des groupes de boutons radio&nbsp;';
$lang['title_field_type'] = 'Type de champ&nbsp;';
$lang['title_not_ready3'] = 'pour cré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ée du module Form Builder. Parfois utile pour débuguer.';
$lang['title_add_new_field'] = 'Ajouter un nouveau champ';
$lang['title_form_submit_button'] = 'Texte du bouton d\'envoi du formulaire&nbsp;';
$lang['title_button_text'] = 'Texte du bouton';
$lang['title_submit_button_safety'] = 'Ajouter du Javascript au bouton d\'envoi final pour aider à la prévention des envois multiples (spam) ?';
$lang['title_submit_button_safety_help'] = 'Ajouter un script sécurisé&nbsp;';
$lang['title_form_next_button'] = 'Texte du bouton "suivant" du formulaire (utilisé pour les formulaires comprenant plusieurs pages)&nbsp;';
$lang['title_form_prev_button'] = 'Texte du bouton "précédent" du formulaire (utilisé pour les formulaires comprenant plusieurs pages)&nbsp;';
$lang['title_field_validation'] = 'Validation du champ&nbsp;';
$lang['title_field_to_validate'] = 'Champ à valider&nbsp;';
$lang['title_field_css_id'] = 'Id CSS pour ce champ&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_predisplay_udt'] = 'Balise utilisateur à appeler avant d\'afficher le formulaire la première fois (appelée une seule fois)&nbsp;';
$lang['title_form_predisplay_each_udt'] = 'Balise utilisateur à appeler avant d\'afficher le formulaire (appelée à chaque page pour les formulaires multipages)&nbsp;';
$lang['title_form_validate_udt'] = 'Balise utilisateur à appeler pendant la validation du formulaire&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éponse obligatoire&nbsp;';
$lang['title_hide_label'] = 'Intitulé caché&nbsp;';
$lang['title_hide_label_long'] = 'Masquer le nom de ce champ dans le formulaire';
$lang['title_textarea_length'] = 'La longueur maximale du contenu d\'un champ (0 ou vide pas de limite)';
$lang['title_text'] = 'Texte statique à afficher&nbsp;';
$lang['title_field_regex'] = 'Validation Regex&nbsp;';
$lang['title_lines_to_show'] = 'Nombre de lignes à afficher&nbsp;';
$lang['title_read_only'] = 'Lecture seule';
$lang['no_default'] = 'Pas de sélection par défaut&nbsp;';
$lang['redirect_after_approval'] = 'Page de redirection après acceptation&nbsp;';
$lang['title_regex_help'] = 'Cette expression régulière sera seulement utilisée si "type de validation" est mis sur une option apparentée regex. Inclut un style Perl regex complet, incluant les slashes de début et fin ainsi que les flags (exemple : "/image\.(\d+)/i")';
$lang['title_field_required_abbrev'] = 'Requis';
$lang['title_hide_errors'] = 'Cacher les erreurs&nbsp;';
$lang['title_form_displaytype'] = 'Type d\'affichage du formulaire';
$lang['title_hide_errors_long'] = 'Cacher aux utilisateurs l\'affichage des messages d\'erreur ou de debugage.';
$lang['title_email_template'] = 'Gabarit du mail&nbsp;';
$lang['title_maximum_size'] = 'Taille maximum pour l\'envoi de fichier (kilobytes)&nbsp;';
$lang['title_maximum_size_long'] = 'Cette limitation est en sus des limites php ou de celles de la configuration du serveur web';
$lang['title_file_destination'] = 'Répertoire d\'enregistrerment des fichiers&nbsp;';
$lang['title_permitted_extensions'] = 'Extensions autorisées&nbsp;';
$lang['title_permitted_extensions_long'] = 'Entrer une liste séparée par un caractère autre que le point, (exemple : "jpg, gif, jpeg"). Les espaces seront ignorés. Laisser vierge signifie "aucune restriction".';
$lang['title_show_limitations'] = 'Afficher les restrictions ?&nbsp;';
$lang['title_show_limitations_long'] = 'Afficher les restrictions de tailles et d\'extensions pour le champ d\'upload ?';
$lang['title_form_template'] = 'Gabarit à utiliser pour afficher le formulaire&nbsp;';
$lang['title_page_x_of_y'] = 'Page %s sur %s';
$lang['title_no_advanced_options'] = 'Champ sans option avancée.';
$lang['title_form_unspecified'] = 'Texte à renvoyer pour les valeurs de champ non spécifiées&nbsp;';
$lang['title_enable_fastadd_long'] = 'Autoriser l\'ajout rapide des champs de formulaire à l\'aide d\'un menu déroulant ?';
$lang['title_enable_fastadd'] = 'Accès rapide au formulaire ?&nbsp;';
$lang['title_fastadd'] = 'Ajout rapide du champ';
$lang['title_enable_antispam_long'] = 'Cocher cette case limitera à 10 emails par heure la transmission des formulaires pour une mê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\'affichage des ID de champs pendant l\'ajout ou l\'édition du formulaire';
$lang['title_xml_to_upload'] = 'Importer un formulaire à partir d\'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énérer un mail en HTML ?&nbsp;';
$lang['title_link_autopopulate'] = 'Remplir automatiquement ?&nbsp;';
$lang['title_link_autopopulate_help'] = 'Remplir automatiquement avec l\'URL de la page contenant le formulaire ? (Ceci réécrira le lien de la page ci-dessous)';
$lang['title_default_link'] = 'Lien URL par défaut&nbsp;';
$lang['title_default_link_title'] = 'Texte par dé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">"Captcha"</a> pour protéger l\'envoi de vos formulaires en installant le module Captcha. Pour plus d\'informations, <a href="http://dev.cmsmadesimple.org/projects/captcha/">suivez le projet du Captcha</a>.';
$lang['title_use_captcha'] = 'Utiliser Captcha pour protéger l\'envoi de vos formulaires ?&nbsp;';
$lang['title_use_captcha_help'] = 'Cocher ici pour protéger vos formulaires avec <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">"Captcha"</a>.';
$lang['title_user_captcha'] = 'Veuillez confirmer que vous n\'êtes pas un automate en recopiant les caractères présents sur l\'image.';
$lang['title_user_captcha_error'] = 'Echec de la vérification Captcha&nbsp;';
$lang['wrong_captcha'] = 'Le code rentré diffère de l\'image.';
$lang['title_title_user_captcha'] = 'Texte d\'aide concernant Captcha&nbsp;';
$lang['title_dont_submit_unchecked'] = 'Ne pas envoyer les valeurs non-cochées&nbsp;';
$lang['title_dont_submit_unchecked_help'] = 'Cochez ceci si vous voulez seulement que les cases coché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électionné par défaut ?&nbsp;';
$lang['title_24_hour'] = 'Heures de 0 à 24 ? &nbsp;';
$lang['title_before_noon'] = 'matin';
$lang['title_after_noon'] = 'après midi';
$lang['title_smarty_eval'] = 'Avec des balises Smarty dans les champs ?&nbsp;';
$lang['title_textarea_rows'] = 'Lignes (note : peut être modifié via CSS)&nbsp;';
$lang['title_textarea_cols'] = 'Colonnes (note : peut être modifié via CSS)&nbsp;';
$lang['title_form_main'] = 'Accueil - Détails du Formulaire&nbsp;';
$lang['title_default_blank'] = 'Par défaut à vide';
$lang['title_default_blank_help'] = 'Par défaut à vide (décoché par défaut à la date du jour)';
$lang['title_show_username'] = 'Affichage login utilisateur ?&nbsp;';
$lang['title_show_userfirstname'] = 'Affichage prénom utilisateur ?&nbsp;';
$lang['title_show_userlastname'] = 'Affichage nom utilisateur ?&nbsp;';
$lang['title_restrict_to_group'] = 'Liste des utilisateurs pour le groupe spécifié&nbsp;';
$lang['title_encrypt_database_data'] = 'Données cryptées enregistrées dans la base de données';
$lang['title_crypt_cert'] = 'Certificat de cryptage des données';
$lang['title_encryption_keyfile'] = 'Phrase secrète ou chemin vers le fichier contenant la phrase. (Si vous utilisez OpenSSL, c\'est la phrase secrète pour la clé privée)';
$lang['title_encrypt_sortfields'] = 'Hacher les champs de tri ?';
$lang['title_private_key'] = 'Clé privée à utiliser pour le cryptage des données';
$lang['title_encrypt_sortfields_help'] = 'Ceci hache les champs de tri, mais laisse les premières lettres non cryptées. Cryptographiquement, cela crée une vulnérabilité, mais reste un compromis acceptable pour une majorité d\'utilisateurs entre la sécurité et la possibilité de trier les enregistrements. Le tri devient approximatif, mais demeure de qualité correcte. Si vous n\'utilisez pas cette option, les champs de tri sont enregistrés en texte brut.';
$lang['title_encryption_functions'] = 'Enregistrement crypté non disponible';
$lang['title_install_crypto'] = 'Merci d\'installer le module OpenSSL ou mcrypt si vous souhaitez activer le cryptage de base de données.';
$lang['title_install_curl'] = 'Vérifiez que vous avez les fonctions CURL activés dans votre installation de PHP. Voir http://www.php.net/manual/en/book.curl.php';
$lang['title_mle_version'] = 'Exécuter en mode MLE&nbsp;';
$lang['title_mle_version_long'] = 'Changements/support pour CMSMS Multilingue Edition. Ne cochez pas cette option si vous n\'utilisez pas la version MLE.';
$lang['title_ensure_cert_key_match'] = 'Assurez-vous que vous sélectionnez la clé privée qui est approprié pour le certificat que vous utilisez pour le cryptage !';
$lang['choose_crypt'] = 'Bibliothèque de cryptage';
$lang['title_encrypt_database_long'] = 'Cochez cette option pour crypter les données stockées. Cette option rend plus difficile (mais pas impossible) l\'affichage de l\'information pour les pirates informatiques.';
$lang['choose_crypt_long'] = 'Les options ci-dessous s\'appliquent uniquement si vous utilisez la bibliothèque de cryptage OpenSSL';
$lang['title_crypt_lib'] = 'Bibliothèque de cryptage';
$lang['openssl'] = 'Bibliothèque OpenSSL';
$lang['mcrypt'] = 'Bibliothèque PHP mcrypt';
$lang['title_feu_binding'] = 'Interface Frontend User';
$lang['title_install_feu'] = 'Merci d\'installer le module Frontend User pour connecter un formulaire et ses données à un utilisateur spécifique';
$lang['title_feu_bind_help'] = 'Cochez cette option pour verrouiller l\'accès des données à l\'utilisateur connecté sur le site.';
$lang['title_encryption'] = 'Cryptage';
$lang['title_export_form_to_udt'] = 'Exporter la référence de formulaire vers un UDT en tant que $params[\'FORM\']? (ne pas faire cela si vous utilisez print_r($params) )';
$lang['title_url_help'] = 'URL complète y compris le protocole et le chemin (par exemple, http://myhost.com/form_handler.cgi)';
$lang['title_url'] = 'URL du formulaire de soumission';
$lang['title_method'] = 'Méthode du formulaire';
$lang['title_maps_to'] = 'Mapper le champ "%s" à la variable de soumission de formulaire';
$lang['title_additional'] = 'Soumission additionnelle';
$lang['title_additional_help'] = 'Tout ce qui peut être ajouté à la charge de l\'envoi, sous forme d\'URL (par ex., "user=steve+jobs&employee_number=1)';
$lang['title_include_in_submission'] = 'Inclure dans le champ de soumission';
$lang['title_date_order'] = 'Ordre du champ composant date (pour l\'entrée)';
$lang['title_data_stored_in_fbr'] = 'Les données seront stockées dans un format XML dans la table de la base [préfixe]_module_fb_frombrowser';
$lang['error_has_no_fb_field'] = 'Erreur ! Soit le formulaire ne possède aucun arrangement de form_builder, soit il a échoué à instancier (en raison de problèmes de mémoire ?)';
$lang['help_date_order'] = 'Utiliser "m" pour mois, "d" pour jour, and "y" pour année. Séparez les items par des tirets.';
$lang['restricted_to_group'] = 'Seulement pour le groupe %s&nbsp;';
$lang['title_show_to_user'] = 'Affichage utilisateur ?&nbsp;';
$lang['title_use_random_generator'] = 'Utiliser un nombre aléatoire à la place d\'un nombre statique';
$lang['title_numbers_to_generate'] = 'Combien de nombres à générer dans le processus';
$lang['help_leaveempty'] = 'Ce champ peut être laissé vide&nbsp;';
$lang['help_variables_for_template'] = 'Variables pour gabarit';
$lang['help_variables_for_computation'] = 'Variables autorisées';
$lang['help_php_variable_name'] = 'Variable PHP';
$lang['help_submission_date'] = 'Date d\'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_ignored_if_upload'] = '(Ce champ est ignoré si vous utilisez le module Uploads pour gérer les fichiers)';
$lang['help_other_fields'] = 'Les autres noms de champs peuvent être utilisés de façon interchangeable (particulièrement utile si Smarty bloque sur les caractères ASCII en dehors de 32-126). <br />Les autres champs seront disponibles si vous les ajouter au formulaire.';
$lang['help_array_fields'] = 'Une autre manière d\'accéder aux valeurs de champ peut se faire via $fieldname_obj, $alias_obj, or $fld_#_obj, où chaque champ est un objet contenant :<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>par exemple</em>, vous pouvez utiliser "{$fld_1_obj->name} = {$fld_1_obj->value}';
$lang['help_date_format'] = '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&nbsp;';
$lang['help_form_field'] = 'Champ représenté&nbsp;';
$lang['help_rtf_file_template'] = 'Spécifiez un fichier situé dans le dossier FormBuilder/templates/. Ce champ est ignoré si vous utiliser un fichier de type TXT.';
$lang['help_rtf_template_type'] = 'Basic: Use the textarea below to layout the field names/values in a single block.<br />
Advanced: Specify Smarty variables in the RTF Template File as you would below, but arrange them however you like and add formatting.<br />
&nbsp;You can still use the %%HEADER%% and %%FOOTER%% sections in the RTF file.';
$lang['help_unique_file_template'] = 'For TXT, this will be immediately after the Header Template.<br />
For RTF, this will replace the %%FIELDS%% string in the template file if RTF Template Type is set to "Basic".<br />
This field will be ignored if using "RTF" as File Type and "Advanced" as RTF Template Type.';
$lang['help_file_header_template'] = 'Pour les fichiers TXT, ceci sera placé en tête du fichier. Pour RTF, cela remplacera la chaîne %%HEADER%% dans le gabarit.';
$lang['help_file_footer_template'] = 'Pour les fichiers TXT, ceci sera placé à la fin du fichier. Pour RTF, cela remplacera la chaîne %%FOOTER%% dans le gabarit.';
$lang['link_back_to_form'] = '« Retour au Formulaire';
$lang['title_create_sample_template'] = 'Créer un modèle de gabarit';
$lang['title_create_sample_html_template'] = 'Créer un modèle de gabarit HTML';
$lang['title_create_sample_header_template'] = 'Créer un modèle d\'entête';
$lang['title_create_sample_footer_template'] = 'Créer un gabarit de pied de page';
$lang['title_create_sample_header'] = 'Créer un modèle d\'entête';
$lang['help_tab_symbol'] = 'une tabulation';
$lang['title_file_template'] = 'Gabarit d\'une ligne pour les fichiers crées&nbsp;';
$lang['title_file_header'] = 'Gabarit du header (en-tête) des fichiers crées&nbsp;';
$lang['title_file_footer'] = 'Gabarit pour le pied de page du fichier de sorti&nbsp;';
$lang['title_rtf_file_template'] = 'Gabarit RTF à utiliser';
$lang['title_unique_file_template'] = 'Gabarit pour la sortie';
$lang['title_file_type'] = 'Choisissez un type de fichier à utiliser';
$lang['title_rtf_template_type'] = 'Choisissez un gabarit RTF';
$lang['title_confirmation_url'] = 'URL à suivre pour confirmer le formulaire&nbsp;';
$lang['title_value'] = 'Valeur (regardez dans onglets "Options avancées" si vous utilisez des balises Smarty)&nbsp;';
$lang['title_date_format'] = 'Format d\'affichage 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 éditeur WYSIWYG pour la zone de texte (coté admin seulement) ?&nbsp;';
$lang['title_submit_actions'] = 'Comportement lors de l\'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éfinit pas ce que le module Form Builder fait des données récoltées. La destination des données sera définie dans les champs "Disposition" (commençant par *.... ).';
$lang['title_start_year'] = 'Année de début&nbsp;';
$lang['title_end_year'] = 'Année de fin&nbsp;';
$lang['title_default_year'] = 'Année par défaut&nbsp;';
$lang['title_default_year_help'] = '&nbsp;(Mettre -1 pour signifier que l\'année par défaut est l\'année courante)';
$lang['title_submit_action'] = 'Action après l\'envoi du formulaire&nbsp;';
$lang['title_submit_response'] = 'Réponse à afficher&nbsp;';
$lang['title_submit_date'] = 'Date Envoyée';
$lang['title_approval_date'] = 'Date Approuvée (par l\'admin)';
$lang['title_user_approved'] = 'Date Approuvée (par la personne qui l\'a soumise)';
$lang['display_text'] = 'Afficher un résumé du formulaire envoyé&nbsp;';
$lang['redirect_to_page'] = 'Rediriger vers une page du site';
$lang['title_submit_response_help'] = 'Ce gabarit sert à l\'affichage pour l\'utilisateur après l\'envoi du formulaire. Ce gabarit n\'a aucun effet ni sur les mails, ni sur d\'autres formulaires - Vous placerez ces gabarits (judicieusement) dans l\'onglet "options avancées".';
$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ée = oui)&nbsp;';
$lang['title_unique_fieldnames'] = 'Champs à nom unique requis&nbsp;';
$lang['title_unique_fieldnames_long'] = 'Les champs doivent avoir des noms différents (case cochée = oui)&nbsp;';
$lang['title_reorder_form'] = 'Ré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_field_helptext'] = 'Texte d\'aide à afficher avec ce champ&nbsp;';
$lang['title_string_or_number_eval'] = 'Interpréter les variables comme étant des nombres ou des chaînes de caractères&nbsp;';
$lang['title_order'] = 'Ordre d\'interprétation&nbsp;';
$lang['title_order_help'] = 'Si plus d\'un champ de calcul existe, ils seront calculé du plus petit au plus grand';
$lang['title_string_unspaced'] = 'Chine (pas d\'espaces entre les champs) ?';
$lang['title_compute_value'] = 'Valeur de calcul&nbsp;';
$lang['title_compute'] = 'Utilisation de PHP';
$lang['title_string'] = 'Chaînes de caractères';
$lang['title_numeric'] = 'Numerique';
$lang['title_inline_form'] = 'Montrer le formulaire en ligne ?&nbsp;';
$lang['title_inline_form_help'] = 'Coché signifie que le résultat de la soumission du formulaire remplace la balise {cms_module}, non-coché remplace la balise {content}.';
$lang['title_field_default_value'] = 'Valeur par défaut pour le champ&nbsp;';
$lang['title_clear_default'] = 'Effacer la valeur par défaut par un clic ?';
$lang['title_clear_default_help'] = 'Cocher cette case pour effacer la valeur par défaut quand l\'utilisateur cliquera ce champ. Puisque cela utilise la comparaison de chaîne en javascript, cela échouera si vous insérez des balises de citation simples dans votre texte par défaut. Vérifier les caractères utilisés pour éviter les erreurs.';
$lang['title_remove_file_from_server'] = 'Supprimer les fichiers uploadés depuis le serveur aprés exécution (dispositions email)&nbsp;';
$lang['title_field_javascript'] = 'Javascript pour le champ&nbsp;';
$lang['title_field_javascript_long'] = 'Mettre le code Javascript, inclut les évènements, ex : onclick="yourfn()"';
$lang['title_submit_javascript'] = 'Formulaire de soumission Javascript&nbsp;';
$lang['title_submit_javascript_long'] = 'Mettre le code Javascript, en incluant l\'évènement que vous voulez piéger, ex : onclick="yourfn()".<br /> Ne fonctionnera probablement pas bien si vous utilisez l\'option de "script sécurité" ci-dessus.';
$lang['email_from_addr_help'] = 'Ne vous contentez pas de choisir une adresse aléatoire ici -- Beaucoup de fournisseurs <br /> ne distribueront pas le courrier si vous utilisez un nom de domaine différent que votre <br /> nom d\'hôte (par exemple, utilisez quelque chose comme nom@%s)';
$lang['title_switch_advanced'] = 'Besoin de plus de types de champs ?';
$lang['title_switch_basic'] = 'Trop de types de champ confus ?';
$lang['title_switch_advanced_link'] = 'Passer en mode avancé';
$lang['title_switch_basic_link'] = 'Passer en mode simple';
$lang['title_file_root'] = 'Dossier dans lequel le fichier sera sauvé&nbsp;';
$lang['title_file_root_help'] = 'Ce doit être un dossier de votre serveur Web avec des permissions d\'écriture<br />Passez-le en CHMOD 777 si vous avez des problèmes ou doutes.<br />De plus, vérifiez que vous n\'avez pas de restriction de répertoire PHP.';
$lang['title_newline_replacement'] = 'Nouvelle ligne/Retour à la ligne en remplacement de caractères&nbsp;';
$lang['title_newline_replacement_help'] = 'Laisser vierge la ligne pour permettre une Nouvelle ligne/Retour à la ligne';
$lang['title_send_usercopy'] = 'Envoyer une copie de la soumission à l\'utilisateur ?&nbsp;';
$lang['title_send_usercopy_label'] = 'Etiquette pour case à cocher (si choix utilisateur)&nbsp;';
$lang['title_send_me_a_copy'] = 'M\'envoyer une copie du formulaire';
$lang['title_allow_subject_override'] = 'Autoriser que l\'objet soit annulé ?';
$lang['title_allow_subject_override_long'] = 'Autoriser les champs de type "Sujet de l\'e-mail" à l\'emporter sur le sujet spécifié dans le menu déroulant.';
$lang['title_display_length'] = 'Affichage de la longueur';
$lang['title_minimum_length'] = 'Longueur minimum pour la réponse';
$lang['title_hide'] = 'Masquer l\'entrée';
$lang['title_hide_help'] = 'Afficher les caractères lorsque l\'utilisateur entre un mot de passe ?';
$lang['password_does_not_match'] = 'Le mot de passe ne correspond pas %s';
$lang['back_top'] = 'Retour à la page principale FormBuilder';
$lang['title_headers_to_modify'] = 'Quelles entêtes de messagerie devraient utiliser cette entrée ?';
$lang['title_blank_invalid'] = 'N\'acceptez pas d\'espace vide comme réponse valide&nbsp;';
$lang['title_blank_invalid_long'] = 'Si un champ est requis, cocher ceci obligera l\'utilisateur à remplir avec des caractères alphanumériques, pas juste des espaces';
$lang['title_must_save_order'] = 'Vous devez cliquer sur un des boutons «Sauvegarder» pour valider le nouvel ordre des champs.';
$lang['title_html5'] = 'Utiliser HTML5 au lieu de Javascript';
$lang['title_email_cc_address'] = 'Adresse(s) auxquelles envoyer en Copie Carbone (CC). Utilisez des virgules pour séparer les adresses.';
$lang['title_use_bcc'] = 'Utiliser la Copie Carbone Invisible (CCI) au lieu de la Copie Carbone (CC)';
$lang['title_send_using'] = 'Adressage de mail';
$lang['title_field_to_modify'] = 'Champ email pour ajouter l\'adresse CC';
$lang['title_modifies'] = 'Ajouter CC à "%s"';
$lang['bcc_field'] = 'Destinataires "CCI"';
$lang['cc_field'] = 'Destinataires "CC"';
$lang['to_field'] = 'Normal ("To" destinataires)';
$lang['bcc'] = 'CCI';
$lang['cc'] = 'CC&nbsp;';
$lang['error_CompanyDirectory_module_not_available'] = 'Le module Company Directory n\'est pas disponible !';
$lang['option_never'] = 'Jamais';
$lang['option_user_choice'] = 'Donne un choix à l\'utilisateur (case à cocher)';
$lang['option_always'] = 'Toujours';
$lang['option_from'] = 'Adresse email pour "From" (De)';
$lang['option_reply'] = 'Adresse email pour "Reply-To" (Répondre à)';
$lang['option_both'] = 'Adresses email pour à la fois "From" et "Reply-To"';
$lang['option_dropdown'] = 'list-box de sélection';
$lang['option_selectlist_single'] = 'Liste simple';
$lang['option_selectlist_multiple'] = 'Liste multiple';
$lang['option_radiogroup'] = 'Groupe de boutons radio';
$lang['title_company_field_note'] = 'Note : la sortie formulaire sera<br/>"company name"=>"value"';
$lang['title_pick_categories'] = 'Choisissez une catégorie (multiple)';
$lang['title_pick_fielddef'] = 'Donne un champ de définition de la valeur (unique) <em>option</em>';
$lang['title_choose_user_input'] = 'Choisir une entrée utilisateur';
$lang['title_see_also_udt'] = '(Vous pouvez également naviguer dans l\'onglet Formulaire de soumission si vous souhaitez définir une balise utilisateur pour le formulaire de validation)';
$lang['title_year_end_message'] = 'Fin de l\'année';
$lang['title_field_logic'] = 'Données ou balises Smarty qui doivent être envoyés avec ce champ&nbsp;';
$lang['title_field_logic_long'] = 'Données Smarty, javascript, ou toute autre donnée que vous voulez envoyer avec ce champ.<br />S\'exécute via le compileur smarty, utiliser les balises {literal}{/literal} avec < script >< /script >';
$lang['title_field_includelabels'] = 'Inclut les intitulés';
$lang['title_field_includelabels_help'] = 'Activer ceci inclut les intitulés à apparaître. Exemple - label: value,label2: value2';
$lang['title_field_siblings'] = 'Lie ce champ à son parent';
$lang['title_field_siblings_help'] = 'Menu déroulant qui liste tous les parents de ce champ et vous permet de lier ce champ avec un de ses parents. Rend possible de contrôler ce champ avec les contrôles du parent sélectionné.';
$lang['title_field_hidebuttons'] = 'Cache les boutons de contrôle';
$lang['title_field_hidebuttons_help'] = 'Cache les boutons de contrôle de ce champ sur l\'interface publique';
$lang['title_note'] = 'Note&nbsp;';
$lang['title_changing_triggers_reindex'] = 'Modification de l\'un des champs ci-dessus déclenchera une ré-indexation de *tous* les enregistrements, cela pourrait prendre un certain temps.';
$lang['illegal_file'] = 'Tentative de téléchargement illégal de fichiers de type (%s) depuis %s';
$lang['title_searchable'] = 'Faire des enregistrements accessibles pour le module de recherche';
$lang['title_searchable_help'] = 'En cochant, cela rendra toutes les données accessibles dans le module de recherche. NE PAS utiliser cette option si vous cryptez vos données -- Les informations seront soumises à la recherche si vous cryptez ou non !';
$lang['uploaded_outside_webroot'] = '%s (hors de la racine du site web)';
$lang['title_fbr_edit'] = 'Éditable dans l\'administration du module FormBrowser ?';
$lang['title_active_only'] = 'Inclure seulement les utilisateurs actifs ?';
$lang['error_usertag_disposition'] = 'La balise utilisateur a retourné une erreur';
$lang['error_usertag'] = 'la balise utilisateur %s returne une erreur.';
$lang['error_cataloger_module_not_available'] = '<strong>Le module Cataloger ne semble pas être installé/actif.</strong>';
$lang['warning'] = 'ATTENTION !';
$lang['select_source_template'] = 'Sélectionner un gabarit source :';
$lang['default_template'] = 'Gabarit par défaut';
$lang['table_left_template'] = 'Gabarit tableau, Titres à gauche';
$lang['table_top_template'] = 'Gabarit tableau, Titres en haut';
$lang['form_template_name'] = 'Gabarit venant de %s';
$lang['template_are_you_sure'] = '\u00CAtes-vous s\u00FBr de vouloir écrire par dessus votre gabarit avec le gabarit sélectionné ? (m\u00EAme si vous dites OK, vous devrez quand m\u00EAme sauvegarder le changement)';
$lang['title_bad_function'] = 'Erreur de calcul "%s".';
$lang['no_referrer_info'] = 'Pas d\'information HTTP_REFERER disponible (probablement dû à l\'usage de validation d\'Email utilisateur)';
$lang['validation_param_error'] = 'Erreur du paramètre de validation. Vérifiez que vous avez recopié correctement l\'URL de l\'email !';
$lang['validation_response_error'] = 'Erreur de réponse de la validation. Vérifiez que vous avez recopié correctement l\'URL de l\'email !';
$lang['validation_no_field_error'] = 'Erreur de réponse de la validation. Aucun champ de validation d\'email dans ce formulaire !';
$lang['upgrade03to04'] = 'Le gabarit de formulaire a été mis à jour automatiquement de la version 0.3 vers la version 0.4. Il se peut que vous ayez à faire certaines corrections. Si vous utilisez le formulaire par défaut, remplacez simplement ce gabarit par "default" en utilisant le menu déroulant ci-dessus.';
$lang['admindesc'] = 'Ajout, édition et gestion de formulaires interactifs';
$lang['must_specify_one_admin'] = 'Doit spécifier un administrateur';
$lang['operators_help'] = 'Si vous utilisez une évaluation de chaîne de caractères, la seule opération possible est la concaténation (+), alors que si vous utilisez une évaluation numérique, vous avez les symboles de base (, +, -, *, /, ). Si vous utilisez l\'évaluation par le PHP, vous pouvez 
utiliser n\'importe quelle fonction vous voulez, mais vous avez besoin de citer des choses (la substitution se produit avant l\'évaluation), par exemple, substr (\'$fld_22\',0,2).\'$fld_23\'.';
$lang['help_module_interface'] = 'Utiliser le module d\'interface';
$lang['help_module_interface_long'] = '<b>Ce champ est utilisé comme un pont vers les autres modules !</b>
Utilisez-le en créant vos éléments de formulaire dans les gabarits de(s) l\'autre(s) module(s) que vous voulez incorporer, et utilisez <strong>{$FBid}</strong> pour le lier en retour vers FormBuilder. Par exemple, pour inclure le formulaire d\'options basé sur le module Products, créez le gabarit suivant dans Products :<br/>
<pre>
{foreach from=$items item=entry}
	{assign var=MData value=\'\'}
	{assign var=Cd value=\'\'}
		{foreach from=$FBvalue item=MData}
			{assign var=MData value=\'::\'|explode:$MData}
			{if $MData[1]==$entry->id}
				{assign var=Cd value=\' checked="checked"\'}
			{/if}
		{/foreach}
	<div class="ProductDirectoryItem">
		<input type="checkbox" value="{$entry->price}::{$entry->id}" name="{$FBid}[]" {$Cd} />{$entry->product_name} ({$entry->weight}{$weight_units}) £{$entry->price}    
	</div>
{/foreach}
</pre>
<br/>
où vous pouvez mettre dans l\'entrée ci-dessous quelque chose comme <strong>{Products category="cat" summarytemplate="Your_FB_template"}</strong>';
$lang['title_add_tag'] = 'Ajouter votre balise';
$lang['date_january'] = 'Janvier';
$lang['date_february'] = 'Fé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ût';
$lang['date_september'] = 'Septembre';
$lang['date_october'] = 'Octobre';
$lang['date_november'] = 'Novembre';
$lang['date_december'] = 'Décembre';
$lang['AD'] = 'Andorre';
$lang['AE'] = 'Emirats Arabes Unis';
$lang['AF'] = 'Afghanistan&nbsp;';
$lang['AG'] = 'Antigua et Barbuda';
$lang['AI'] = 'Anguilla&nbsp;';
$lang['AL'] = 'Albanie';
$lang['AM'] = 'Arménie';
$lang['AN'] = 'Antilles Néerlandaises';
$lang['AO'] = 'Angola&nbsp;';
$lang['AQ'] = 'Antarctique';
$lang['AR'] = 'Argentine';
$lang['AS'] = 'American Samoa&nbsp;';
$lang['AT'] = 'Autriche';
$lang['AU'] = 'Australie';
$lang['AW'] = 'Aruba&nbsp;';
$lang['AX'] = 'Aland Islands&nbsp;';
$lang['AZ'] = 'Azerbaidjan';
$lang['BA'] = 'Bosnie et Herzégovine';
$lang['BB'] = 'Barbades';
$lang['BD'] = 'Bangladesh&nbsp;';
$lang['BE'] = 'Belgique';
$lang['BF'] = 'Burkina Faso&nbsp;';
$lang['BG'] = 'Bulgarie';
$lang['BH'] = 'Bahrain&nbsp;';
$lang['BI'] = 'Burundi&nbsp;';
$lang['BJ'] = 'Bénin';
$lang['BM'] = 'Bermudes';
$lang['BN'] = 'Brunei Darussalam&nbsp;';
$lang['BO'] = 'Bolivie';
$lang['BR'] = 'Brésil';
$lang['BS'] = 'Bahamas&nbsp;';
$lang['BT'] = 'Boutan';
$lang['BV'] = 'Ile Bouvet';
$lang['BW'] = 'Botswana&nbsp;';
$lang['BY'] = 'Belarus&nbsp;';
$lang['BZ'] = 'Belize&nbsp;';
$lang['CA'] = 'Canada&nbsp;';
$lang['CC'] = 'Îles Cocos (Keeling)';
$lang['CD'] = 'Congo,  République Démocratique';
$lang['CF'] = 'République Centrafricaine';
$lang['CG'] = 'Congo&nbsp;';
$lang['CH'] = 'Suisse';
$lang['CI'] = 'Ivoire (Côte d\'ivoire)';
$lang['CK'] = 'Îles Cook';
$lang['CL'] = 'Chili';
$lang['CM'] = 'Cameroun';
$lang['CN'] = 'Chine';
$lang['CO'] = 'Colombe';
$lang['CR'] = 'Costa Rica&nbsp;';
$lang['CU'] = 'Cuba&nbsp;';
$lang['CV'] = 'Cap Vert';
$lang['CX'] = 'Ile Christmas';
$lang['CY'] = 'Chypre';
$lang['CZ'] = 'République Tchèque';
$lang['DE'] = 'Allemagne';
$lang['DJ'] = 'Djibouti&nbsp;';
$lang['DK'] = 'Danemark';
$lang['DM'] = 'Dominique';
$lang['DO'] = 'République Dominicaine';
$lang['DZ'] = 'Algérie';
$lang['EC'] = 'Equateur';
$lang['EE'] = 'Estonie';
$lang['EG'] = 'Egypte';
$lang['EH'] = 'Western Sahara&nbsp;';
$lang['ER'] = 'Erithrée';
$lang['ES'] = 'Espagne';
$lang['ET'] = 'Ethiopie';
$lang['FI'] = 'Finlande';
$lang['FJ'] = 'Fidji';
$lang['FK'] = 'Iles Malouines (Malvinas)';
$lang['FM'] = 'Micronésie';
$lang['FO'] = 'Iles Feroë';
$lang['FR'] = 'France&nbsp;';
$lang['FX'] = 'France Métropolitaine';
$lang['GA'] = 'Gabon&nbsp;';
$lang['GB'] = 'Royaume-Uni (UK)';
$lang['GD'] = 'Grenade';
$lang['GE'] = 'Géorgie';
$lang['GF'] = 'Guernesey';
$lang['GH'] = 'Ghana&nbsp;';
$lang['GI'] = 'Gibraltar&nbsp;';
$lang['GL'] = 'Groënland';
$lang['GM'] = 'Gambie';
$lang['GN'] = 'Guinée';
$lang['GP'] = 'Guadeloupe&nbsp;';
$lang['GQ'] = 'Guinée Equatorial';
$lang['GR'] = 'Grèce';
$lang['GS'] = 'S. Georgia and S. Sandwich Isls.&nbsp;';
$lang['GT'] = 'Guatemala&nbsp;';
$lang['GU'] = 'Guam&nbsp;';
$lang['GW'] = 'Guinée-Bissau';
$lang['GY'] = 'Guyane';
$lang['HK'] = 'Hong Kong&nbsp;';
$lang['HM'] = 'Îles Heard et McDonald';
$lang['HN'] = 'Honduras&nbsp;';
$lang['HR'] = 'Croatie (Hrvatska)';
$lang['HT'] = 'Haïti';
$lang['HU'] = 'Hongrie';
$lang['ID'] = 'Indonésie';
$lang['IE'] = 'Irlande';
$lang['IL'] = 'Israël';
$lang['IM'] = 'Ile de Man';
$lang['IN'] = 'Inde';
$lang['IO'] = 'British Indian Ocean Territory&nbsp;';
$lang['IQ'] = 'Irak';
$lang['IR'] = 'Iran&nbsp;';
$lang['IS'] = 'Islande';
$lang['IT'] = 'Italie';
$lang['JE'] = 'Jersey&nbsp;';
$lang['JM'] = 'Jamaïque';
$lang['JO'] = 'Jordanie';
$lang['JP'] = 'Japon';
$lang['KE'] = 'Kenya&nbsp;';
$lang['KG'] = 'Kyrgyzstan&nbsp;';
$lang['KH'] = 'Cambodge';
$lang['KI'] = 'Kiribati&nbsp;';
$lang['KM'] = 'Comoros&nbsp;';
$lang['KN'] = 'Saint Kitts et Nevis';
$lang['KP'] = 'Corée (du Nord)';
$lang['KR'] = 'Corée (du Sud)';
$lang['KW'] = 'Koweït';
$lang['KY'] = 'Iles Cayman';
$lang['KZ'] = 'Kazakhstan&nbsp;';
$lang['LA'] = 'Laos&nbsp;';
$lang['LB'] = 'Liban';
$lang['LC'] = 'Saint Lucie';
$lang['LI'] = 'Liechtenstein&nbsp;';
$lang['LK'] = 'Sri Lanka&nbsp;';
$lang['LR'] = 'Libéria';
$lang['LS'] = 'Lesotho&nbsp;';
$lang['LT'] = 'Lithuanie';
$lang['LU'] = 'Luxembourg&nbsp;';
$lang['LV'] = 'Latvie';
$lang['LY'] = 'Lybie';
$lang['MA'] = 'Maroc';
$lang['MC'] = 'Monaco&nbsp;';
$lang['MD'] = 'Moldavie';
$lang['MG'] = 'Madagascar&nbsp;';
$lang['MH'] = 'Iles Marshall';
$lang['MK'] = 'F.Y.R.O.M. (Macédoine)';
$lang['ML'] = 'Mali&nbsp;';
$lang['MM'] = 'Myanmar&nbsp;';
$lang['MN'] = 'Mongolie';
$lang['MO'] = 'Macao';
$lang['MP'] = 'Northern Mariana Islands&nbsp;';
$lang['MQ'] = 'Martinique&nbsp;';
$lang['MR'] = 'Mauritanie';
$lang['MS'] = 'Montserrat&nbsp;';
$lang['MT'] = 'Malte';
$lang['MU'] = 'Île Maurice';
$lang['MV'] = 'Maldives&nbsp;';
$lang['MW'] = 'Malawi&nbsp;';
$lang['MX'] = 'Mexique';
$lang['MY'] = 'Malaysie';
$lang['MZ'] = 'Mozambique&nbsp;';
$lang['NA'] = 'Namibie';
$lang['NC'] = 'Nouvelle Calédonie';
$lang['NE'] = 'Niger&nbsp;';
$lang['NF'] = 'Norfolk Island&nbsp;';
$lang['NG'] = 'Nigéria';
$lang['NI'] = 'Nicaragua&nbsp;';
$lang['NL'] = 'Pays Bas';
$lang['NO'] = 'Norvège';
$lang['NP'] = 'Népal';
$lang['NR'] = 'Nauru&nbsp;';
$lang['NT'] = 'Zone neutre';
$lang['NU'] = '&nbsp;';
$lang['NZ'] = 'Nouvelle Zélande (Aotearoa)';
$lang['OM'] = 'Oman&nbsp;';
$lang['PA'] = 'Panama&nbsp;';
$lang['PE'] = 'Pérou';
$lang['PF'] = 'Polynésie Française';
$lang['PG'] = 'Papouasie Nouvelle Guinée';
$lang['PH'] = 'Philippines&nbsp;';
$lang['PK'] = 'Pakistan&nbsp;';
$lang['PL'] = 'Pologne';
$lang['PM'] = 'St-Pierre et Miquelon';
$lang['PN'] = 'Pitcairn&nbsp;';
$lang['PR'] = 'Porto Rico';
$lang['PS'] = 'Territoire Palestinien';
$lang['PT'] = 'Portugal&nbsp;';
$lang['PW'] = 'Palau&nbsp;';
$lang['PY'] = 'Paraguay&nbsp;';
$lang['QA'] = 'Qatar&nbsp;';
$lang['RE'] = 'Réunion';
$lang['RO'] = 'Roumanie';
$lang['RS'] = 'Serbie';
$lang['RU'] = 'Fédération de Russie';
$lang['RW'] = 'Rwanda&nbsp;';
$lang['SA'] = 'Arabie Saoudite';
$lang['SB'] = 'Solomon Islands&nbsp;';
$lang['SC'] = 'Seychelles&nbsp;';
$lang['SD'] = 'Soudan';
$lang['SE'] = 'Suède';
$lang['SG'] = 'Singapour';
$lang['SH'] = 'St-Hélène';
$lang['SI'] = 'Slovénie';
$lang['SJ'] = 'Svalbard & Jan Mayen Islands';
$lang['SK'] = 'Slovak Republic&nbsp;';
$lang['SL'] = 'Sierra Leone&nbsp;';
$lang['SM'] = 'San Marin';
$lang['SN'] = 'Sénégal';
$lang['SO'] = 'Somalie';
$lang['SR'] = 'Surinam';
$lang['ST'] = 'Sao Tome et Principe';
$lang['SV'] = 'San Salvador';
$lang['SY'] = 'Syrie';
$lang['SZ'] = 'Swaziland&nbsp;';
$lang['TC'] = 'Turks et Caicos';
$lang['TD'] = 'Tchad';
$lang['TF'] = 'French Southern Territories&nbsp;';
$lang['TG'] = 'Togo&nbsp;';
$lang['TH'] = 'Thaïlande';
$lang['TJ'] = 'Tajikistan&nbsp;';
$lang['TK'] = 'Tokelau&nbsp;';
$lang['TM'] = 'Turkmenistan&nbsp;';
$lang['TN'] = 'Tunisie';
$lang['TO'] = 'Tonga&nbsp;';
$lang['TP'] = 'Timor Oriental';
$lang['TR'] = 'Turquie';
$lang['TT'] = 'Trinidad et Tobago';
$lang['TV'] = 'Tuvalu&nbsp;';
$lang['TW'] = 'Taïwan';
$lang['TZ'] = 'Tanzanie';
$lang['UA'] = 'Ukraine&nbsp;';
$lang['UG'] = 'Ouganda';
$lang['UK'] = 'Royaume Uni';
$lang['UM'] = 'US Minor Outlying Islands&nbsp;';
$lang['US'] = 'Etats-Unis';
$lang['UY'] = 'Uruguay&nbsp;';
$lang['UZ'] = 'Uzbekistan&nbsp;';
$lang['VA'] = 'Vatican City State (Holy See)&nbsp;';
$lang['VC'] = 'Saint Vincent et les Grenadines';
$lang['VE'] = 'Venezuela&nbsp;';
$lang['VG'] = 'Virgin Islands (British)&nbsp;';
$lang['VI'] = 'Virgin Islands (U.S.)&nbsp;';
$lang['VN'] = 'Viet Nam&nbsp;';
$lang['VU'] = 'Vanuatu&nbsp;';
$lang['WF'] = 'Wallis and Futuna Islands&nbsp;';
$lang['WS'] = 'Samoa&nbsp;';
$lang['YE'] = 'Yemen&nbsp;';
$lang['YT'] = 'Mayotte&nbsp;';
$lang['YU'] = 'Yugoslavie';
$lang['ZA'] = 'Afrique du Sud';
$lang['ZM'] = 'Zambie';
$lang['ZW'] = 'Zimbabwe&nbsp;';
$lang['submission_error'] = 'Désolé ! Une erreur a empêché la transmission du formulaire.';
$lang['submit_error'] = 'Erreur de soumission FormBuilder : %s';
$lang['uploads_error'] = 'Erreur en soumettant un fichier au module d\'upload : %s';
$lang['nouploads_error'] = 'Module d\'upload introuvable';
$lang['upload_attach_error'] = 'Erreur d\'upload/attachement sur le fichier %s (tmp_name : %s, de type %s)';
$lang['submission_error_file_lock'] = 'Erreur. Impossible d\'obtenir le blocage du fichier.';
$lang['unchecked_by_default'] = 'Par défaut : décoché';
$lang['checked_by_default'] = 'Par défaut : coché';
$lang['email_default_template'] = 'Soumission par FormBuilder';
$lang['email_template_not_set'] = '<br/>Gabarit du mail pas encore défini !';
$lang['missing_cms_mailer'] = 'FormBuilder : impossible de trouver le module CMSMailer requis !';
$lang['user_approved_submission'] = 'Utilisateur approuvant la soumission %s de %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Evénement déclenché lorsqu\'un formulaire FormBuilder est envoyé';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Evénement déclenché s\'il y a une erreur lorsqu\'un formulaire FormBuilder est envoyé';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Evénement déclenché lorsqu\'un formulaire FormBuilder est affiché';
$lang['event_help_OnFormBuilderFormSubmit'] = '<h4>Paramètres</h4>
<ul>
<li><em>form_name</em> - Le nom du formulaire (string)</li>
<li><em>form_id</em> - L\'id interne du formulaire (int)</li>
<li><em>value_<name></em> - Fournit une valeur par défaut à un champ avec le nom précisé.</li>
</ul>';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<h4>Paramètres</h4>
<ul>
<li><em>form_name</em> - Le nom du formulaire (string)</li>
<li><em>form_id</em> - L\'id interne du formulaire (int)</li>
<li><em>error</em> - Une liste de toutes les erreurs connues (string)</li>
</ul>';
$lang['event_help_OnFormBuilderFormDisplay'] = '<h4>Paramètres</h4>
<ul>
<li><em>form_name</em> - Le nom du formulaire (string)</li>
<li><em>form_id</em> - L\'id interne du formulaire (int)</li>
</ul>';
$lang['formbuilder_params_response_id'] = 'ID. de la réponse utilisée par le module FormBrowser';
$lang['formbuilder_params_passed_from_tag'] = 'Valeurs du champ par défaut; voir le module d\'aide';
$lang['formbuilder_params_field_id'] = 'ID du champ pour les opérations internes';
$lang['formbuilder_params_form_name'] = 'Nom du formulaire';
$lang['formbuilder_params_form_id'] = 'ID du formulaire pour les opérations internes';
$lang['formbuilder_params_general'] = 'Paramètres généraux pour les opérations internes';
$lang['template_variable_help'] = '<h3>Variables du Gabarit de Formulaire</h3>
<p>Vous pouvez l\'éditer pour que la présentation de votre formulaire soit conforme à vos souhaits.
   Pour que le formulaire fonctionne, vous devrez toujours inclure les tags {$fb_hidden} et {$submit}.</p>

<p>Vous pouvez accéder à vos champs de formulaire en utilisant soit l\'ordre $fields soit directement par leurs noms (e.g., {$myfield->input} )</p>


<p>Voici les différentes valeurs applicables aux champs :</p>
<table>
<tr><th>Champ</th><th>Valeur</th></tr>
<tr><td>field->display</td><td>1 pour afficher le champ, sinon 0</td></tr>
<tr><td>field->required</td><td>1 si le champ est requis, sinon 0</td></tr>
<tr><td>field->required_symbol</td><td>Le symbole signalant les champs obligatoires</td></tr>
<tr><td>field->css_class</td><td>La classe CSS de ce champ</td></tr>
<tr><td>field->valid</td><td>1 si le champ été valide, sinon 0</td></tr>
<tr><td>field->error</td><td>Texte pour les problèmes de validation, au cas où le champ ne serait pas validé</td></tr>
<tr><td>field->hide_name</td><td>1 si le nom du champs doit rester caché, sinon 0</td></tr>
<tr><td>field->has_label</td><td>1 si le type de champ a un label</td></tr>
<tr><td>field->needs_div</td><td>1 si le champ doit être intégré dans un DIV (ou dans une ligne de tableau, si c\'est votre choix)</td></tr>
<tr><td>field->name</td><td>Le nom du champ</td></tr>
<tr><td>field->helptext</td><td>Le champ de texte d\'aide</td></tr>
<tr><td>field->input</td><td>La valeur de contrôle du champ (ex. : la valeur du champ)</td></tr>
<tr><td>field->op</td><td>un bouton de contrôle associé au champ si c\'est possible (ex. : le bouton supprimer pour un champ texte)</td></tr>
<tr><td>field->input_id</td><td>l\' ID du champ (utile pour un label for="foo">)</td></tr>
<tr><td>field->alias</td><td>l\'alias spécifié pour ce champ</td></tr>
<tr><td>field->id</td><td>l\'id interne / opaque que FormBuilder utilise pour ce champ</td></tr>
<tr><td>field->type</td><td>le type de données du champ</td></tr>
                                
<tr><td>field->multiple_parts</td><td>1 si le champ->input est une collection de contrôles</td></tr>
<tr><td>field->label_parts</td><td>1 si la collection de contrôles a des labels séparés pour chaque contrôle</td></tr>
</table>

<p>Dans le cas d\'un formulaire à plusieurs pages, vous aurez aussi accès à la valeur des champs précédents. Ils sont dans $previous array, ou accessibles par leurs noms (ex. : {$myfield->value} ).
Vous pouvez aussi utiliser Static Text fields, ce qui constitue une bonne façon de personnaliser vos formulaires !</p>

<p>Dans certains cas, field->input est en fait un groupe d\'objets plutôt qu\'une entrée. Ça arrive, par exemple, dans CheckBoxGroups ou RadioButtonGroups. Dans ce cas, vous pouvez les répéter avec field->input->name et field->input->inputs.</p>
    
<p>Voici les variables smarty complé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éro de la page courrante pour un formulaire multi-pages</td></tr>
<tr><td>title_page_x_of_y</td><td>affiche "page x de y" 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ées du formulaire</td></tr>

<tr><td>in_formbrowser</td><td>1 Si le formulaire est affiché à partir de FormBrowser</td></tr>
<tr><td>in_admin</td><td>1 Si le formulaire est visualisé de l\'administration de FormBrowser</td></tr>
<tr><td>fbr_id</td><td>ID de retour si le formulaire est affiché à partir de FormBrowser</td></tr>

<tr><td>prev</td><td>Bouton "Reculer" pour un formulaire multiple</td></tr>
<tr><td>submit</td><td>Bouton "Suivant" or "Envoyer"  pour un formulaire multiple, ajuster automatiquement</td></tr>
</table>
<p>Je ne sais pas pourquoi vous vouliez ça, mais les voilà...</p>';
$lang['post_install'] = 'FormBuilder est installé. Merci de consulter l\'aide du module pour la documentation.';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/hu_HU.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Form szerkesztő';
$lang['field_type_DispositionEmailFromFEUProperty'] = '*Email users matching an FEU property';
$lang['field_type_'] = 'A mező t&iacute;pusa nincs be&aacute;ll&iacute;tva';
$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_HTML5NumberField'] = 'HTML5 Number Input';
$lang['field_type_HTML5EmailField'] = 'HTML5 Email Input';
$lang['field_type_HTML5URLField'] = 'HTML5 URL Input';
$lang['field_type_PasswordField'] = 'Password';
$lang['field_type_PasswordAgainField'] = 'Password Again (verify)';
$lang['field_type_TextFieldExpandable'] = 'Text Input (Multiple)';
$lang['field_type_TextAreaField'] = 'Sz&ouml;veg ter&uuml;let';
$lang['field_type_ButtonField'] = 'Gomb';
$lang['field_type_CheckboxField'] = 'Jel&ouml;lőn&eacute;gyzet ';
$lang['field_type_CheckboxGroupField'] = 'Jel&ouml;lőn&eacute;gyzet csoport';
$lang['field_type_PulldownField'] = 'Pulldown';
$lang['field_type_YearPullDownField'] = 'Year 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 &quot;From Address&quot; Field, and send copy';
$lang['field_type_DispositionFile'] = '*Write Results to Flat File';
$lang['field_type_DispositionUniqueFile'] = '*Write Results to a Unique Flat File for each submission';
$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_DispositionForm'] = '*Submit to an arbitrary form action';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Email to User-Supplied Email Address';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Email to CMS Admin User';
$lang['field_type_DispositionEmailBasedFrontendFields'] = '*Email results based on frontend fields';
$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_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'] = '-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['field_type_UserTagField'] = '-User Defined Tag Call';
$lang['field_type_CompanyDirectoryField'] = 'Company Directory Field';
$lang['field_type_ModuleInterfaceField'] = '-Module Interface Field';
$lang['field_type_CheckboxExtendedField'] = 'Checkbox extended';
$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['validation_empty'] = 'Can&#039;t be empty';
$lang['required'] = 'Required';
$lang['not_required'] = 'Not Required';
$lang['not_available'] = 'Not Available';
$lang['error_emailfromfeuprop'] = 'Error in Field Setup';
$lang['error_nofeu'] = 'The FrontEndUsers module could not be found.  This field will not function.';
$lang['error_nofeudefns'] = 'No suitable FEU property could be found.  This field will not function.';
$lang['required_field_missing'] = 'A value was not supplied for a required field';
$lang['please_enter_a_value'] = 'K&eacute;rj&uuml;k, t&ouml;ltse ki az al&aacute;bbi mező &eacute;rt&eacute;k&eacute;t: &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['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['please_login'] = 'Please log in to use this form';
$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['please_enter_at_least'] = 'Please enter a value that is at least %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'] = 'A mezősorendet friss&iacute;tett&uuml;k.';
$lang['form_deleted'] = 'A formot t&ouml;r&ouml;lt&uuml;k.';
$lang['field_deleted'] = 'A mezőt t&ouml;r&ouml;lt&uuml;k.';
$lang['configuration_updated'] = 'A konfigur&aacute;ci&oacute;t friss&iacute;tett&uuml;k.';
$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['no_field_assigned'] = 'No field assigned for %s';
$lang['anonymous'] = 'Anonymous';
$lang['abbreviation_length'] = 'Len: %s';
$lang['boxes'] = '%s boxes';
$lang['options'] = '%s options';
$lang['text_length'] = '%s chars.';
$lang['order'] = 'Sorrend';
$lang['unspecified'] = '[nincs megadva]';
$lang['added'] = 'hozz&aacute;adva';
$lang['updated'] = 'friss&iacute;tve';
$lang['sort_options'] = 'Sort options on output';
$lang['select_one'] = 'K&eacute;rj&uuml;k, v&aacute;lasszon';
$lang['select_type'] = 'Select Type';
$lang['to'] = 'To';
$lang['yes'] = 'Igen';
$lang['no'] = 'Nem';
$lang['recipients'] = 'c&iacute;mzettek';
$lang['fields'] = 'fields';
$lang['file_count'] = '%s possible files';
$lang['destination_count'] = '%s destinations';
$lang['save'] = 'Ment&eacute;s';
$lang['add'] = 'Hozz&aacute;ad&aacute;s';
$lang['update'] = 'Friss&iacute;t&eacute;s';
$lang['save_and_continue'] = 'Ment&eacute;s &eacute;s a szerkeszt&eacute;s folytat&aacute;sa';
$lang['information'] = 'Inform&aacute;ci&oacute;';
$lang['automatic'] = 'Automatikus';
$lang['forms'] = 'Formok';
$lang['form'] = 'Form %s';
$lang['configuration'] = 'Konfigur&aacute;ci&oacute;';
$lang['field_requirement_updated'] = 'A mező k&ouml;telezős&eacute;gi &aacute;llapot&aacute;t friss&iacute;tett&uuml;k.';
$lang['maximum_size'] = 'Max. m&eacute;ret';
$lang['permitted_extensions'] = 'Kiterjeszt&eacute;sek';
$lang['permitted_filetypes'] = 'Megengedett f&aacute;jl t&iacute;pusok';
$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'] = 'Felt&ouml;lt&eacute;s';
$lang['form_imported'] = 'A formot import&aacute;ltuk.';
$lang['form_import_failed'] = 'Form import failed! There was a problem with the format of the XML file.';
$lang['rows'] = '%s sor';
$lang['cols'] = '%s oszlop';
$lang['12_hour'] = '12 &oacute;r&aacute;s &oacute;ra';
$lang['24_hour'] = '24 &oacute;r&aacute;s &oacute;ra';
$lang['hour'] = '&Oacute;ra';
$lang['min'] = 'Perc';
$lang['merid'] = 'Meridian';
$lang['date_range'] = 'Tartom&aacute;ny: %s - %s';
$lang['thanks'] = 'K&ouml;sz&ouml;nj&uuml;k! V&aacute;laszait tov&aacute;bb&iacute;tottuk.';
$lang['edit'] = 'Szerkeszt';
$lang['delete'] = 'T&ouml;rl&eacute;s';
$lang['day'] = 'Nap';
$lang['mon'] = 'H&oacute;nap';
$lang['year'] = '&Eacute;v';
$lang['none'] = '(&uuml;res)';
$lang['css'] = 'CSS';
$lang['uninstalled'] = 'Module uninstalled.';
$lang['installed'] = 'Module version %s installed.';
$lang['upgraded'] = 'Module upgraded to version %s.';
$lang['button_previous'] = 'Vissza...';
$lang['button_submit'] = 'Elk&uuml;ld';
$lang['button_continue'] = 'Tov&aacute;bb...';
$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['tab_udt'] = 'UDT Integration';
$lang['title_feu_property'] = 'FrontEndUsers Property';
$lang['info_feu_property'] = 'Only certain property types can be used for matching (dropdowns, multiselect fields, etc).';
$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'] = '&Uacute;jabb c&eacute;l hozz&aacute;ad&aacute;sa';
$lang['delete_destination'] = 'Kijel&ouml;lt c&eacute;lok t&ouml;rl&eacute;se';
$lang['suspected_spam'] = 'Too many emails generated from your IP address. Anti-Spam code has prevented delivery.';
$lang['suspected_spam_log'] = 'Az al&aacute;bbi IP c&iacute;met spam-gyan&uacute; miatt blokkoltuk: %s';
$lang['reorder'] = 'Mezők &aacute;trendez&eacute;se';
$lang['cancel'] = 'M&eacute;gsem';
$lang['value_set'] = 'Be&aacute;ll&iacute;tott &eacute;rt&eacute;k: %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['title_textfield_label'] = 'Textfield label';
$lang['title_show_textfield'] = 'Show textfield?';
$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_allow_overwrite'] = 'Allow upload to overwrite previously files?';
$lang['title_allow_overwrite_long'] = 'Should uploaded file overwrite previously uploaded file if it has the same name?';
$lang['overwrite'] = 'Allows Overwriting';
$lang['nooverwrite'] = 'No Overwrite';
$lang['file_already_exists'] = 'File %s already exists, and cannot be overwritten.';
$lang['title_file_rename'] = 'Filename template';
$lang['original_file_extension'] = 'Original file extension (includes the &quot;.&quot;)';
$lang['title_suppress_filename'] = 'Suppress filename in emails and forms the end user will see';
$lang['title_suppress_attachment'] = 'Deny file to be attached with emails';
$lang['file_rename_help'] = 'To rename a file upon uploading, create the template here. Leave blank to preserve original filename';
$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'] = 'A &quot;K&eacute;rj&uuml;k, v&aacute;lasszon&quot; sz&ouml;vege';
$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_field_alias_short'] = '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_button_text'] = '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_field_css_id'] = 'CSS id for this field';
$lang['title_form_css_class'] = 'CSS Class for this form';
$lang['title_field_css_class'] = 'CSS Class for this field';
$lang['title_form_predisplay_udt'] = 'User defined tag to call before form is displayed';
$lang['title_form_predisplay_each_udt'] = 'User defined tag to call before form is displayed (called on every page of multipage forms)';
$lang['title_form_validate_udt'] = 'User defined tag to call during form validation';
$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_textarea_length'] = 'Maximum length of field content (0 or blank means no limit)';
$lang['title_text'] = 'Static text to display';
$lang['title_field_regex'] = 'Validation Regex';
$lang['title_lines_to_show'] = 'Number of Lines to display';
$lang['title_read_only'] = 'Read Only';
$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_file_destination'] = 'Directory to save files into';
$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'] = 'de.';
$lang['title_after_noon'] = 'du.';
$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_default_blank'] = 'Default to blank';
$lang['title_default_blank_help'] = 'Default to blank (uncheck to default to today&#039;s date)';
$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['title_encrypt_database_data'] = 'Encrypt data stored in database';
$lang['title_crypt_cert'] = 'Certificate for encrypting data';
$lang['title_encryption_keyfile'] = 'Passphrase or path to file containing passphrase. (If using OpenSSL, this is the passphrase for the private key)';
$lang['title_encrypt_sortfields'] = 'Hash sort fields?';
$lang['title_private_key'] = 'Private Key to use for encrypting data';
$lang['title_encrypt_sortfields_help'] = 'This hashes the sort fields, but leaves the first few letters unencrypted. Cryptographically, this creates a vulnerability, but for most users it is an acceptable tradeoff between security and the ability to sort records. Sorting becomes approximate, but will remain pretty good. If you do not use this option, sort fields are stored in plaintext.';
$lang['title_encryption_functions'] = 'Storage Encryption Unavailable';
$lang['title_install_crypto'] = 'Please install the OpenSSL module or mcrypt support if you would like to enable database encryption.';
$lang['title_install_curl'] = 'Please make sure you have CURL support active in your PHP install. See http://www.php.net/manual/en/book.curl.php';
$lang['title_mle_version'] = 'Run in MLE Mode';
$lang['title_mle_version_long'] = 'Changes/support for CMSMS Multi-Language Edition fork. Do not check this if you are not running the MLE version.';
$lang['title_ensure_cert_key_match'] = 'Ensure that you select the private key that is appropriate for the certificate you are using for encryption!';
$lang['choose_crypt'] = 'Encryption Library';
$lang['title_encrypt_database_long'] = 'Check this to encrypt the stored data. This makes it more difficult (but not impossible) for hackers to view the information.';
$lang['choose_crypt_long'] = 'The options below only apply if you are using the OpenSSL Encryption library';
$lang['title_crypt_lib'] = 'Encryption Library';
$lang['openssl'] = 'OpenSSL Library';
$lang['mcrypt'] = 'PHP mcrypt Library';
$lang['title_feu_binding'] = 'Frontend User binding';
$lang['title_install_feu'] = 'Please install the Frontend User module to connect a form and its data to a specific user';
$lang['title_feu_bind_help'] = 'Check this to lock front-end access to this form&#039;s data to the logged-in front-end user.';
$lang['title_encryption'] = 'Encryption';
$lang['title_export_form_to_udt'] = 'Export form reference to UDT as $params[&#039;FORM&#039;]? (do not do this if you are going to print_r($params) )';
$lang['title_url_help'] = 'Entire URL, including protocol and path (e.g., http://myhost.com/form_handler.cgi)';
$lang['title_url'] = 'Form submission URL';
$lang['title_method'] = 'Form method';
$lang['title_maps_to'] = 'Map field &quot;%s&quot; to form submission variable';
$lang['title_additional'] = 'Additional submission';
$lang['title_additional_help'] = 'Anything to be appended to the submission payload, in URL-encoded form (.e.g, &quot;user=steve+jobs&amp;employee_number=1)';
$lang['title_include_in_submission'] = 'Include field in Submission';
$lang['title_date_order'] = 'Date component field order (for input)';
$lang['title_data_stored_in_fbr'] = 'Data will be stored in an XML format in the [PREFIX]_module_fb_formbrowser database table.';
$lang['error_has_no_fb_field'] = 'Error! Either the form has no Form Browser Disposition, or it failed to instantiate (due to memory issues?)';
$lang['help_date_order'] = 'Use &quot;m&quot; for Month, &quot;d&quot; for Day, and &quot;y&quot; for Year. Separate the items by hyphens.';
$lang['restricted_to_group'] = 'Only in group %s';
$lang['title_show_to_user'] = 'Display to user?';
$lang['title_use_random_generator'] = 'Use random number generator instead of static';
$lang['title_numbers_to_generate'] = 'How many numbers to generate in process';
$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_ignored_if_upload'] = '(This field ignored if you use the Uploads module to manage files)';
$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['help_rtf_file_template'] = 'Specify a file located in the FormBuilder/templates/ folder. This field is ignored if you use TXT as your file type.';
$lang['help_rtf_template_type'] = 'Basic: Use the textarea below to layout the field names/values in a single block.<br />
Advanced: Specify Smarty variables in the RTF Template File as you would below, but arrange them however you like and add formatting.<br />
&nbsp;You can still use the %%HEADER%% and %%FOOTER%% sections in the RTF file.';
$lang['help_unique_file_template'] = 'For TXT, this will be immediately after the Header Template.<br />
For RTF, this will replace the %%FIELDS%% string in the template file if RTF Template Type is set to &quot;Basic&quot;.<br />
This field will be ignored if using &quot;RTF&quot; as File Type and &quot;Advanced&quot; as RTF Template Type.';
$lang['help_file_header_template'] = 'For TXT, this will be placed at the top of the file. For RTF, this will replace the %%HEADER%% string in the template file.';
$lang['help_file_footer_template'] = 'For TXT, this will be placed at the bottom of the file. For RTF, this will replace the %%FOOTER%% string in the template file.';
$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_footer_template'] = 'Create Sample Footer 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_file_footer'] = 'Template for the footer of output file';
$lang['title_rtf_file_template'] = 'Template RTF file to use';
$lang['title_unique_file_template'] = 'Template for output';
$lang['title_file_type'] = 'Choose a file type to use';
$lang['title_rtf_template_type'] = 'Choose an RTF template type';
$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['title_submit_date'] = 'Date Submitted';
$lang['title_approval_date'] = 'Date Approved (by admin)';
$lang['title_user_approved'] = 'Date Approved (by submitter)';
$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_field_helptext'] = 'Help-text to display with this field';
$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_string_unspaced'] = 'String (no spaces between fields)?';
$lang['title_compute_value'] = 'Value to compute';
$lang['title_compute'] = 'Computed/PHP';
$lang['title_string'] = 'Sz&ouml;veg';
$lang['title_numeric'] = 'Numerikus';
$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['title_display_length'] = 'Display length';
$lang['title_minimum_length'] = 'Minimum response length';
$lang['title_hide'] = 'Hide input';
$lang['title_hide_help'] = 'Show symbols rather plain text when user enters password?';
$lang['password_does_not_match'] = 'Password does not match %s';
$lang['back_top'] = 'Back to FormBuilder Main Page';
$lang['title_headers_to_modify'] = 'Which email headers should this input populate?';
$lang['title_blank_invalid'] = 'Do not accept blank space as valid response';
$lang['title_blank_invalid_long'] = 'If a field is required, checking this will require that people put in some alphanumeric characters, not just spaces';
$lang['title_must_save_order'] = 'You must click one of the &quot;save&quot; buttons to make your new field order permanent.';
$lang['title_html5'] = 'Use HTML5 placeholder text instead of Javascript';
$lang['error_CompanyDirectory_module_not_available'] = 'Company Directory module is not available!';
$lang['option_never'] = 'Never';
$lang['option_user_choice'] = 'Give user a choice (checkbox)';
$lang['option_always'] = 'Always';
$lang['option_from'] = '&quot;From&quot; email address';
$lang['option_reply'] = '&quot;Reply-To&quot; email address';
$lang['option_both'] = 'Both &quot;From&quot; and &quot;Reply-To&quot; email addresses';
$lang['option_dropdown'] = 'Dropdown';
$lang['option_selectlist_single'] = 'Select List (single)';
$lang['option_selectlist_multiple'] = 'Select List (multiple)';
$lang['option_radiogroup'] = 'Radio Group';
$lang['title_company_field_note'] = 'Note: Output will be in the form of<br/>&quot;company name&quot;=>&quot;value&quot;';
$lang['title_pick_categories'] = 'Pick a category (multiple)';
$lang['title_pick_fielddef'] = 'Pull a field Definition&#039;s value (single) <em>optional</em>';
$lang['title_choose_user_input'] = 'Choose User input';
$lang['title_see_also_udt'] = '(Also take a look at the Form Submission tab if you want to set a UDT for form validation)';
$lang['title_year_end_message'] = 'End year';
$lang['title_field_logic'] = 'Smarty data or logic that is meant to be sent with this field';
$lang['title_field_logic_long'] = 'Can be smarty data, javascript, or some other data you want to sent along with this field.<br />Goes through the Smarty compiler, so remember use {literal}{/literal} tags with <script></script>';
$lang['title_field_includelabels'] = 'Include labels';
$lang['title_field_includelabels_help'] = 'Enabling this includes labels to output. example - label: value,label2: value2';
$lang['title_field_siblings'] = 'Link this field to it&#039;s sibling';
$lang['title_field_siblings_help'] = 'Dropdown lists all siblings of this field and allows you to link this field to one of it&#039;s sibling. Makes possible controlling this field with selected sibling controls.';
$lang['title_field_hidebuttons'] = 'Hide control buttons';
$lang['title_field_hidebuttons_help'] = 'Hides frontend control buttons of this field.';
$lang['title_note'] = 'Note';
$lang['title_changing_triggers_reindex'] = 'Changing any of the above fields will trigger a reindex of *all* saved records, so it could take a while.';
$lang['illegal_file'] = 'Attempted upload of illegal file type (%s) from %s';
$lang['title_searchable'] = 'Make records accessible to Search Module';
$lang['title_searchable_help'] = 'Checking this will make all submitted data accessible to the Search Module. DO NOT use this if you encrypt your data -- the information gets exposed to search whether or not it is encrypted!';
$lang['uploaded_outside_webroot'] = '%s (outside web root)';
$lang['title_fbr_edit'] = 'Editable in FormBrowser Admin?';
$lang['error_usertag_disposition'] = 'User defined tag returned an error';
$lang['error_usertag'] = 'User defined tag %s returned an error.';
$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['help_module_interface'] = 'Using Module Interface';
$lang['help_module_interface_long'] = '<b>This field is used as a gateway to other modules!</b>
Use it by creating your form elements in the templates of the other module(s) you wish to incorporate, and using the <strong>{$FBid}</strong> to tie it back to FormBuilder. For example, to include form options based on the Products module, create the following template in Products:<br/>
<pre>
{foreach from=$items item=entry}
	{assign var=MData value=&#039;&#039;}
	{assign var=Cd value=&#039;&#039;}
		{foreach from=$FBvalue item=MData}
			{assign var=MData value=&#039;::&#039;|explode:$MData}
			{if $MData[1]==$entry->id}
				{assign var=Cd value=&#039; checked=&quot;checked&quot;&#039;}
			{/if}
		{/foreach}
	<div class=&quot;ProductDirectoryItem&quot;>
		<input type=&quot;checkbox&quot; value=&quot;{$entry->price}::{$entry->id}&quot; name=&quot;{$FBid}[]&quot; {$Cd} />{$entry->product_name} ({$entry->weight}{$weight_units}) &pound;{$entry->price}    
	</div>
{/foreach}
</pre>
<br/>
where in the input below you put something like <strong>{Products category=&quot;cat&quot; summarytemplate=&quot;Your_FB_template&quot;}</strong>';
$lang['title_add_tag'] = 'Add your tag';
$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['AF'] = 'Afghanistan';
$lang['AX'] = 'Aland Islands';
$lang['AL'] = 'Albania';
$lang['DZ'] = 'Algeria';
$lang['AS'] = 'American Samoa';
$lang['AD'] = 'Andorra';
$lang['AO'] = 'Angola';
$lang['AI'] = 'Anguilla';
$lang['AQ'] = 'Antarctica';
$lang['AG'] = 'Antigua and Barbuda';
$lang['AR'] = 'Argentina';
$lang['AM'] = 'Armenia';
$lang['AW'] = 'Aruba';
$lang['AU'] = 'Australia';
$lang['AT'] = 'Austria';
$lang['AZ'] = 'Azerbaijan';
$lang['BS'] = 'Bahamas';
$lang['BH'] = 'Bahrain';
$lang['BB'] = 'Barbados';
$lang['BD'] = 'Bangladesh';
$lang['BY'] = 'Belarus';
$lang['BE'] = 'Belgium';
$lang['BZ'] = 'Belize';
$lang['BJ'] = 'Benin';
$lang['BM'] = 'Bermuda';
$lang['BT'] = 'Bhutan';
$lang['BW'] = 'Botswana';
$lang['BO'] = 'Bolivia';
$lang['BA'] = 'Bosnia and Herzegovina';
$lang['BV'] = 'Bouvet Island';
$lang['BR'] = 'Brazil';
$lang['IO'] = 'British Indian Ocean Territory';
$lang['BN'] = 'Brunei Darussalam';
$lang['BG'] = 'Bulgaria';
$lang['BF'] = 'Burkina Faso';
$lang['BI'] = 'Burundi';
$lang['KH'] = 'Cambodia';
$lang['CM'] = 'Cameroon';
$lang['CA'] = 'Canada';
$lang['CV'] = 'Cape Verde';
$lang['KY'] = 'Cayman Islands';
$lang['CF'] = 'Central African Republic';
$lang['TD'] = 'Chad';
$lang['CL'] = 'Chile';
$lang['CN'] = 'China';
$lang['CX'] = 'Christmas Island';
$lang['CC'] = 'Cocos (Keeling) Islands';
$lang['CO'] = 'Colombia';
$lang['KM'] = 'Comoros';
$lang['CG'] = 'Congo';
$lang['CD'] = 'Congo,  Democratic Republic';
$lang['CK'] = 'Cook Islands';
$lang['CR'] = 'Costa Rica';
$lang['CI'] = 'Ivoire (Ivory Coast)';
$lang['HR'] = 'Croatia (Hrvatska)';
$lang['CU'] = 'Cuba';
$lang['CY'] = 'Cyprus';
$lang['CZ'] = 'Czech Republic';
$lang['DK'] = 'Denmark';
$lang['DJ'] = 'Djibouti';
$lang['DM'] = 'Dominica';
$lang['DO'] = 'Dominican Republic';
$lang['TP'] = 'East Timor';
$lang['EC'] = 'Ecuador';
$lang['EG'] = 'Egypt';
$lang['SV'] = 'El Salvador';
$lang['GQ'] = 'Equatorial Guinea';
$lang['ER'] = 'Eritrea';
$lang['EE'] = 'Estonia';
$lang['ET'] = 'Ethiopia';
$lang['FK'] = 'Falkland Islands (Malvinas)';
$lang['FO'] = 'Faroe Islands';
$lang['FJ'] = 'Fiji';
$lang['FI'] = 'Finland';
$lang['FR'] = 'France';
$lang['FX'] = 'France,  Metropolitan';
$lang['GF'] = 'Guernsey';
$lang['PF'] = 'French Polynesia';
$lang['TF'] = 'French Southern Territories';
$lang['MK'] = 'F.Y.R.O.M. (Macedonia)';
$lang['GA'] = 'Gabon';
$lang['GM'] = 'Gambia';
$lang['GE'] = 'Georgia';
$lang['DE'] = 'Germany';
$lang['GH'] = 'Ghana';
$lang['GI'] = 'Gibraltar';
$lang['GB'] = 'Great Britain (UK)';
$lang['GR'] = 'Greece';
$lang['GL'] = 'Greenland';
$lang['GD'] = 'Grenada';
$lang['GP'] = 'Guadeloupe';
$lang['GU'] = 'Guam';
$lang['GT'] = 'Guatemala';
$lang['GN'] = 'Guinea';
$lang['GW'] = 'Guinea-Bissau';
$lang['GY'] = 'Guyana';
$lang['HT'] = 'Haiti';
$lang['HM'] = 'Heard and McDonald Islands';
$lang['HN'] = 'Honduras';
$lang['HK'] = 'Hong Kong';
$lang['HU'] = 'Hungary';
$lang['IS'] = 'Iceland';
$lang['IN'] = 'India';
$lang['ID'] = 'Indonesia';
$lang['IR'] = 'Iran';
$lang['IQ'] = 'Iraq';
$lang['IE'] = 'Ireland';
$lang['IL'] = 'Israel';
$lang['IM'] = 'Isle of Man';
$lang['IT'] = 'Italy';
$lang['JE'] = 'Jersey';
$lang['JM'] = 'Jamaica';
$lang['JP'] = 'Japan';
$lang['JO'] = 'Jordan';
$lang['KZ'] = 'Kazakhstan';
$lang['KE'] = 'Kenya';
$lang['KI'] = 'Kiribati';
$lang['KP'] = 'Korea (North)';
$lang['KR'] = 'Korea (South)';
$lang['KW'] = 'Kuwait';
$lang['KG'] = 'Kyrgyzstan';
$lang['LA'] = 'Laos';
$lang['LV'] = 'Latvia';
$lang['LB'] = 'Lebanon';
$lang['LI'] = 'Liechtenstein';
$lang['LR'] = 'Liberia';
$lang['LY'] = 'Libya';
$lang['LS'] = 'Lesotho';
$lang['LT'] = 'Lithuania';
$lang['LU'] = 'Luxembourg';
$lang['MO'] = 'Macau';
$lang['MG'] = 'Madagascar';
$lang['MW'] = 'Malawi';
$lang['MY'] = 'Malaysia';
$lang['MV'] = 'Maldives';
$lang['ML'] = 'Mali';
$lang['MT'] = 'Malta';
$lang['MH'] = 'Marshall Islands';
$lang['MQ'] = 'Martinique';
$lang['MR'] = 'Mauritania';
$lang['MU'] = 'Mauritius';
$lang['YT'] = 'Mayotte';
$lang['MX'] = 'Mexico';
$lang['FM'] = 'Micronesia';
$lang['MC'] = 'Monaco';
$lang['MD'] = 'Moldova';
$lang['MA'] = 'Morocco';
$lang['MN'] = 'Mongolia';
$lang['MS'] = 'Montserrat';
$lang['MZ'] = 'Mozambique';
$lang['MM'] = 'Myanmar';
$lang['NA'] = 'Namibia';
$lang['NR'] = 'Nauru';
$lang['NP'] = 'Nepal';
$lang['NL'] = 'Netherlands';
$lang['AN'] = 'Netherlands Antilles';
$lang['NT'] = 'Neutral Zone';
$lang['NC'] = 'New Caledonia';
$lang['NZ'] = 'New Zealand (Aotearoa)';
$lang['NI'] = 'Nicaragua';
$lang['NE'] = 'Niger';
$lang['NG'] = 'Nigeria';
$lang['NU'] = 'Niue';
$lang['NF'] = 'Norfolk Island';
$lang['MP'] = 'Northern Mariana Islands';
$lang['NO'] = 'Norway';
$lang['OM'] = 'Oman';
$lang['PK'] = 'Pakistan';
$lang['PW'] = 'Palau';
$lang['PS'] = 'Palestinian Territory';
$lang['PA'] = 'Panama';
$lang['PG'] = 'Papua New Guinea';
$lang['PY'] = 'Paraguay';
$lang['PE'] = 'Peru';
$lang['PH'] = 'Philippines';
$lang['PN'] = 'Pitcairn';
$lang['PL'] = 'Poland';
$lang['PT'] = 'Portugal';
$lang['PR'] = 'Puerto Rico';
$lang['QA'] = 'Qatar';
$lang['RE'] = 'Reunion';
$lang['RO'] = 'Romania';
$lang['RU'] = 'Russian Federation';
$lang['RW'] = 'Rwanda';
$lang['GS'] = 'S. Georgia and S. Sandwich Isls.';
$lang['KN'] = 'Saint Kitts and Nevis';
$lang['LC'] = 'Saint Lucia';
$lang['VC'] = 'Saint Vincent &amp; the Grenadines';
$lang['WS'] = 'Samoa';
$lang['SM'] = 'San Marino';
$lang['ST'] = 'Sao Tome and Principe';
$lang['SA'] = 'Saudi Arabia';
$lang['SN'] = 'Senegal';
$lang['SC'] = 'Seychelles';
$lang['SL'] = 'Sierra Leone';
$lang['SG'] = 'Singapore';
$lang['SI'] = 'Slovenia';
$lang['SK'] = 'Slovak Republic';
$lang['SB'] = 'Solomon Islands';
$lang['SO'] = 'Somalia';
$lang['ZA'] = 'South Africa';
$lang['ES'] = 'Spain';
$lang['LK'] = 'Sri Lanka';
$lang['SH'] = 'St. Helena';
$lang['PM'] = 'St. Pierre and Miquelon ';
$lang['SD'] = 'Sudan';
$lang['SR'] = 'Suriname';
$lang['SJ'] = 'Svalbard &amp; Jan Mayen Islands';
$lang['SZ'] = 'Swaziland';
$lang['SE'] = 'Sweden';
$lang['CH'] = 'Switzerland';
$lang['SY'] = 'Syria';
$lang['TW'] = 'Taiwan';
$lang['TJ'] = 'Tajikistan';
$lang['TZ'] = 'Tanzania';
$lang['TH'] = 'Thailand';
$lang['TG'] = 'Togo';
$lang['TK'] = 'Tokelau';
$lang['TO'] = 'Tonga';
$lang['TT'] = 'Trinidad and Tobago';
$lang['TN'] = 'Tunisia';
$lang['TR'] = 'Turkey';
$lang['TM'] = 'Turkmenistan';
$lang['TC'] = 'Turks and Caicos Islands';
$lang['TV'] = 'Tuvalu';
$lang['UG'] = 'Uganda';
$lang['UA'] = 'Ukraine';
$lang['AE'] = 'United Arab Emirates';
$lang['UK'] = 'United Kingdom';
$lang['US'] = 'United States';
$lang['UM'] = 'US Minor Outlying Islands';
$lang['UY'] = 'Uruguay';
$lang['UZ'] = 'Uzbekistan';
$lang['VU'] = 'Vanuatu';
$lang['VA'] = 'Vatican City State (Holy See)';
$lang['VE'] = 'Venezuela';
$lang['VN'] = 'Viet Nam';
$lang['VG'] = 'Virgin Islands (British)';
$lang['VI'] = 'Virgin Islands (U.S.)';
$lang['WF'] = 'Wallis and Futuna Islands';
$lang['EH'] = 'Western Sahara';
$lang['YE'] = 'Yemen';
$lang['YU'] = 'Yugoslavia';
$lang['ZM'] = 'Zambia';
$lang['ZW'] = 'Zimbabwe';
$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 neve';
$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;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>
';
$lang['post_install'] = '<br />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.<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&#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 &quot;From Address&quot; 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 &quot;From Name&quot; 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 &quot;From Address&quot; Field, and send copy. This works like the Email &quot;From Address&quot; Field described above, but it provides options for sending a copy of the results to the user.</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>After a bit of nagging on the part of people who actually respect standards, FormBuilder no longer encourages tricks like embedding CSS in 
static text fields. Instead, it creates a stylesheet called &quot;FormBuilder Default&quot; that you are encouraged to attach to the page template
that you use for pages that contain your form.</p>  
<p>This default CSS was graciously provided by Paul Noone.</p>


<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;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> Make sure you can successfully send email via the test in the CMSMailer Module. It&#039;s simply amazing how many problems boil down to a misconfigured CMSMailer.</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>
<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"><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['utma'] = '156861353.2120955972.1312782573.1312782573.1312782573.1';
$lang['utmb'] = '156861353.1.10.1312782857';
$lang['utmc'] = '156861353';
$lang['utmz'] = '156861353.1312782573.1.1.utmcsr=(direct)|utmccn=(direct)|utmcmd=(none)';
$lang['qca'] = 'P0-51390990-1312782857313';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/it_IT.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Form Builder';
$lang['field_type_DispositionEmailFromFEUProperty'] = '*Email di utenti che corrispondono ad una propriet&agrave; FEU';
$lang['field_type_'] = 'Tipo del campo non impostato';
$lang['field_type_CatalogerItemsField'] = 'Seleziona uno (o pi&ugrave;) elementi del catalogo';
$lang['field_type_FieldsetEnd'] = '-Fine Fieldset';
$lang['field_type_FieldsetStart'] = '-Inizio Fieldset';
$lang['field_type_TextField'] = 'Input testuale';
$lang['field_type_HTML5NumberField'] = 'Input Numerico HTML5';
$lang['field_type_HTML5EmailField'] = 'Input Email HTML5';
$lang['field_type_HTML5URLField'] = 'Input URL HTML5';
$lang['field_type_SiteAdminField'] = 'Amministratore del Sito';
$lang['field_type_PasswordField'] = 'Password';
$lang['field_type_PasswordAgainField'] = 'Ripetere Password (verifica)';
$lang['field_type_TextFieldExpandable'] = 'Input Testuale (Multiplo)';
$lang['field_type_TextAreaField'] = 'Area di Testo';
$lang['field_type_ButtonField'] = 'Pulsante';
$lang['field_type_CheckboxField'] = 'Check Box';
$lang['field_type_CheckboxGroupField'] = 'Gruppo di Check Box';
$lang['field_type_PulldownField'] = 'Menu a tendina';
$lang['field_type_YearPullDownField'] = 'Selezione Anno';
$lang['field_type_MultiselectField'] = 'Selezione Multipla';
$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'] = '*Invia copia Email al campo &quot;Da Indirizzo&quot; Field';
$lang['field_type_DispositionFile'] = '*Scrivi i risultati in un file non formattato';
$lang['field_type_DispositionUniqueFile'] = '*Scrivi risultati in un file non formattato univoco per ogni invio';
$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_DispositionForm'] = '*Invia ad un azione modulo personalizzata';
$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_DispositionEmailBasedFrontendFields'] = '*Invia Email basata sui campi lato utente';
$lang['field_type_DispositionListItExtended'] = '*Salva i risultati per ListItExtended';
$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_CCEmailAddressField'] = 'Invia per Email in Copia Carbone (CC) al campo Indirizzo';
$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['field_type_UserTagField'] = '-Inserimento Tag Definito dall&#039;utente';
$lang['field_type_CompanyDirectoryField'] = 'Campo Company Directory';
$lang['field_type_ModuleInterfaceField'] = '-Campo Modulo Interfaccia';
$lang['field_type_CheckboxExtendedField'] = 'Casella di Controllo estesa';
$lang['validation_none'] = 'Nessuna validazione';
$lang['validation_numeric'] = 'Numerico';
$lang['validation_integer'] = 'Intero';
$lang['validation_email_address'] = 'Indirizzo Email';
$lang['validation_usphone'] = 'Numero telefonico (USA)';
$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['validation_empty'] = 'Non pu&ograve; essere vuoto';
$lang['required'] = 'Richiesto';
$lang['not_required'] = 'Non necessario';
$lang['not_available'] = 'Non disponibile';
$lang['error_emailfromfeuprop'] = 'Errore nelle impostazioni del campo';
$lang['error_nofeu'] = 'Modulo FrontEndUsers non trovato. Questo campo non funzioner&agrave;.';
$lang['error_nofeudefns'] = 'Non &egrave; stata trovata alcuna proprieta FEU corrispondente. Questo campo non funzioner&agrave;.';
$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['please_login'] = 'Effettuate l&#039;accesso per utilizzare questo modulo';
$lang['not_valid_email'] = '&quot;%s&quot; non sembra essere un indirizzo email valido!';
$lang['please_enter_no_longer'] = 'Inserite un valore non pi&ugrave; lungo di %s caratteri';
$lang['please_enter_at_least'] = 'Interite un valore si almeno %s caratteri';
$lang['title_list_delimiter'] = 'Carattere da usare come delimitatore nei risultati che restituiscono 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'] = 'Modulo eliminato.';
$lang['field_deleted'] = 'Campo eliminato.';
$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['no_field_assigned'] = 'Nessun campo assegnato per %s';
$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['fields'] = 'Campi';
$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['css'] = 'Stili CSS';
$lang['notice'] = 'NOTIFICA';
$lang['general'] = 'Generale';
$lang['about'] = 'Informazioni';
$lang['templates'] = 'Modelli';
$lang['advanced'] = 'Avanzato';
$lang['styling'] = 'Stili';
$lang['team'] = 'Gruppo';
$lang['contributors'] = 'Collaboratori';
$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 Modulo';
$lang['tab_submissiontemplate'] = 'Modello per l&#039;invio';
$lang['tab_udt'] = 'Integrazione UDT';
$lang['title_feu_property'] = 'Propriet&agrave; FrontEndUsers';
$lang['info_feu_property'] = 'Per cercare corrispondenze possono essere utilizzati solo alcuni tipi di propriet&agrave; (menu a tendina, campi a selezione multipla, etc.).';
$lang['canuse_smarty'] = '<em>Le Variabili smarty sono accettate per questo campo.<em>';
$lang['add_options'] = 'Aggiungi pi&ugrave; opzioni';
$lang['delete_options'] = 'Elimina le opzioni selezionate';
$lang['add_checkboxes'] = 'Aggiungi pi&ugrave; Caselle a spunta';
$lang['delete_checkboxes'] = 'Elimina le Caselle selezionate';
$lang['add_address'] = 'Aggiungi un altro Indirizzo';
$lang['delete_address'] = 'Elimina gli Indirizzi selezionati';
$lang['add_destination'] = 'Aggiungi un altro Destinatario';
$lang['delete_destination'] = 'Elimina 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'] = 'Sospetto spam dall&#039;indirizzo IP %s .';
$lang['reorder'] = 'Riordina campi';
$lang['cancel'] = 'Annulla';
$lang['value_set'] = 'Valore impostato: %s';
$lang['help_cataloger_attribute_fields'] = 'Sotto &egrave; presente una lista di attributi disponibili dal Modulo Cataloger.<br/>Potete scegliere di specificare gruppi o valori consentiti, oppure numerosi valori da utilizzare come filtro per l&#039;elenco di valori mostrati agli utenti.<br/>
<br/>
<strong>Gruppi di valori:</strong><br/>
I Gruppi di valori possono essere indicati specificando un valore minimo e massimo con questa sintassi &quot;range: minvalue to maxvalue&quot;<br/>
<br/>
<strong>Valori Multipli:</strong><br/>
Per indicare Valori Multipli per un attributo utilizzate la sintassi &quot;multi: value1|value2|value3&quot;<br/>
<br/>
<strong>Valori da Campi Nascosti</strong><br/>
Per indicare un valore da un campo nascosto utilizzate la sintassi {$fld_id}<br/>
<br/>';
$lang['title_textfield_label'] = 'Etichetta campo di testo';
$lang['title_show_textfield'] = 'Mostrare campo di testo?';
$lang['help_name_regex'] = 'Una espressione regolare per permettere il filtraggio degli Item di Cataloger per nome';
$lang['help_field_height'] = 'La altezza del campo multiselect';
$lang['title_name_regex'] = 'Espressione regolare degli Item name di Cataloger';
$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_allow_overwrite'] = 'Permettere ai file caricati di sovrascrivere i file precedenti?';
$lang['title_allow_overwrite_long'] = 'Il file caricato pu&ograve; sovrascrivere file preesistenti se hanno lo stesso nome?';
$lang['overwrite'] = 'Permettere Sovrascrittura';
$lang['nooverwrite'] = 'Nessuna Sovrascrittura';
$lang['file_already_exists'] = 'Il file %s &egrave; gi&agrave; esistente e non pu&ograve; essere sovrascritto.';
$lang['title_file_rename'] = 'Modello di nome file';
$lang['original_file_extension'] = 'Estensione file originale (incluso &quot;.&quot;)';
$lang['title_suppress_filename'] = 'Non visualizzare il nome del file nelle email e nei moduli visualizzati dall&#039;utente';
$lang['title_suppress_attachment'] = 'Vieta gli allegati nelle email';
$lang['file_rename_help'] = 'Create qui un modello per rinominare un file prima del caricamento . Lasciate vuoto per conservare il nome file originale';
$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 Menu a tendina';
$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'] = 'Campo &quot;Da&quot; (nome) per le 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 Mittente&quot; per email';
$lang['title_email_encoding'] = 'Insieme di caratteri di encoding per email';
$lang['title_director_details'] = 'Dettagli invio email con menu a tendina';
$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 l&#039;utilizzo';
$lang['title_not_ready1'] = 'Non pronto';
$lang['title_redirect_page'] = 'Pagina a cui dirigere dopo l&#039;invio del modulo';
$lang['title_not_ready2'] = 'Inserite un campo nel modulo per la gestione delle informazioni inserite dall&#039;utente. Potete';
$lang['title_not_ready_link'] = 'usare questa scorciatoia';
$lang['title_form_alias'] = 'Alias del Modulo';
$lang['title_field_alias_short'] = 'Alias';
$lang['title_form_fields'] = 'Campi Modulo';
$lang['title_field_id'] = 'Id campo';
$lang['title_show_fieldaliases'] = 'Mostra Alais dei Campi';
$lang['title_show_fieldaliases_long'] = 'Selezionandolo verranno visualizzati gli alias dei campi durante la creazione o la modifica di un modulo';
$lang['title_field_name'] = 'Nome campo';
$lang['title_field_alias'] = 'Campo Alias e attributo ID DOM (CSS ID)';
$lang['title_radiogroup_details'] = 'Dettagli del gruppo Radio Button';
$lang['title_field_type'] = 'Tipo campo';
$lang['title_not_ready3'] = 'per creare un campo di gestione del modulo.';
$lang['title_add_new_form'] = 'Aggiungi nuovo Modulo';
$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 pulsante di Invio del modulo';
$lang['title_button_text'] = 'Testo del pulsante';
$lang['title_submit_button_safety'] = 'Aggiungere codice Javascript al pulsante di Invio per evitare errori di invii multipli?';
$lang['title_submit_button_safety_help'] = 'Aggiungi script di sicurezza';
$lang['title_form_next_button'] = 'Testo del Pulsante &quot;Successivo&quot; del modulo (per moduli multipagina)';
$lang['title_form_prev_button'] = 'Testo del Pulsante &quot;Precedente&quot; del modulo (per moduli multipagina)';
$lang['title_field_validation'] = 'Validazione Campo';
$lang['title_field_to_validate'] = 'Campo da validare';
$lang['title_field_css_id'] = 'ID CSS  per questo campo';
$lang['title_form_css_class'] = 'Stile CSS per questo Form';
$lang['title_field_css_class'] = 'Stile CSS per questo Campo';
$lang['title_form_predisplay_udt'] = 'Tag Definito dall&#039;Utente da chiamare prima che il modulo venga visualizzato la prima volta (chiamato solo una volta)';
$lang['title_form_predisplay_each_udt'] = 'Tag Definito dall&#039;Utente da chiamare prima che il modulo venga visualizzato';
$lang['title_form_validate_udt'] = 'Tag definito dall&#039;utente da chiamare durante la validazione di un modulo';
$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_textarea_length'] = 'Lunghezza massima del contenuto di un campo (0 o vuoto significa nessun limite)';
$lang['title_text'] = 'Testo statico da visualizzare';
$lang['title_field_regex'] = 'Regex di validazione';
$lang['title_lines_to_show'] = 'Numero di linee da visualizzare';
$lang['title_read_only'] = 'Sola Lettuta';
$lang['no_default'] = 'Nessun Valore predefinito';
$lang['redirect_after_approval'] = 'Pagina dove reindirizzare 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'] = 'Nascondi gli Errori';
$lang['title_form_displaytype'] = 'Tipo di visualizzazione modulo';
$lang['title_hide_errors_long'] = 'Previeni la visualizzazione dei messaggi di debug/errore da parte degli utenti.';
$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_file_destination'] = 'Cartella in cui salvare i file';
$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'] = 'Visualizzare qualsiasi restrizione delle dimensione e estensione con il campo upload?';
$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'] = 'Aggiunta rapida Campi';
$lang['title_enable_antispam_long'] = 'Selezionando questo permetter&agrave; solo 10 emails di essere attivate da un dato indirizzo IP (per ora).';
$lang['title_enable_antispam'] = 'Abilito primitive degli anti-spam?';
$lang['title_show_fieldids'] = 'Mostra ID dei campi';
$lang['title_show_fieldids_long'] = 'Selezionandolo permetter&agrave; la visualizzazione degli ID dei campi durante la creazione o modifica di moduli';
$lang['title_xml_to_upload'] = 'Carica modulo da file XML';
$lang['title_xml_upload_formname'] = 'Usa questo nome modulo';
$lang['title_import_legend'] = 'Importa Modulo XML';
$lang['title_xml_upload_formalias'] = 'Usa questo Alias Modulo';
$lang['title_html_email'] = 'Generare email HTML?';
$lang['title_link_autopopulate'] = 'Popolare automaticamente?';
$lang['title_link_autopopulate_help'] = 'Riempire automaticamente con l&#039;URL della pagina che contiene il modulo? (sovrascrive le opzioni di link di pagina sottostanti)';
$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'] = 'Potete utilizzare <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a> per proteggere l&#039;invio di un modulo se installate il modulo Captcha module. Per maggiori informazioni <a href="http://dev.cmsmadesimple.org/projects/captcha/">andate al progetto Captcha</a>.';
$lang['title_use_captcha'] = 'Usare Captcha per proteggere l&#039;invio dei form?';
$lang['title_use_captcha_help'] = 'Selezionate per proteggere il modulo con <a href="http://www.wikipedia.org/wiki/Captcha" target="_new">&quot;Captcha&quot;</a>.';
$lang['title_user_captcha'] = 'Inserite i caratteri visualizzati dell&#039;immagine come procedura di protezione.';
$lang['title_user_captcha_error'] = 'Testo fallito per Captcha';
$lang['wrong_captcha'] = 'Captcha inserito non corretto.';
$lang['title_title_user_captcha'] = 'Testo di aiuto per Captcha';
$lang['title_dont_submit_unchecked'] = 'Non inviare valori delle caselle non selezionate';
$lang['title_dont_submit_unchecked_help'] = 'Selezionate se desiderate che vengano restituiti solo i valori delle caselle selezionate';
$lang['link_label'] = 'Etichetta per Link';
$lang['link_destination'] = 'URL di destinazione del link';
$lang['title_default_set'] = 'Selezionato per default?';
$lang['title_24_hour'] = 'Utilizzo formato 24-ore?';
$lang['title_before_noon'] = 'AM';
$lang['title_after_noon'] = 'PM';
$lang['title_smarty_eval'] = 'Processare i tag smarty all&#039;interno dei campi?';
$lang['title_textarea_rows'] = 'Righe (nota: pu&ograve; essere sovrascritto tramite CSS)';
$lang['title_textarea_cols'] = 'Colonne (nota: pu&ograve; essere sovrascritto tramite CSS)';
$lang['title_form_main'] = 'Dettagli principali del Modulo';
$lang['title_default_blank'] = 'Vuoto per default';
$lang['title_default_blank_help'] = 'Vuoto per default (deselezionate per utilizzare la data odierna di default)';
$lang['title_show_username'] = 'Visualizzare il nome di accesso dell&#039;utente';
$lang['title_show_userfirstname'] = 'Visualizzare il nome dell&#039;utente';
$lang['title_show_userlastname'] = 'Visualizzare il cognome dell&#039;utente';
$lang['title_restrict_to_group'] = 'Restringi la lista utenti agli utenti di un gruppo specifico';
$lang['title_encrypt_database_data'] = 'Cripta i dati salvati nel database';
$lang['title_crypt_cert'] = 'Certificato per la criptazione dei dati';
$lang['title_encryption_keyfile'] = 'Frase di accesso o percorso del file contenente la frase di accesso. (Se utilizzate openSSl questa &egrave; la frase di accesso per la chiave privata)';
$lang['title_encrypt_sortfields'] = 'Creare hash per i campi di ordinamento?';
$lang['title_private_key'] = 'Chiave privata per la criptazione dei dati';
$lang['title_encrypt_sortfields_help'] = 'Questa opzione crea l&#039;hash per i cami di ordinamento, ma lascia le prime lettere non criptate. Crittograficamente crea una vulnerabilit&agrave;, ma per molti utenti &egrave; un compromesso accettabile tra sicurezza e possibilit&agrave; di ordinare i dati. L&#039;ordinamento diventa approssimatico, ma rimarr&agrave; comunque accettabile. Se non volete utilizzare questa opzione, i campi di ordinamento saranno registrati in chiaro.';
$lang['title_encryption_functions'] = 'Salvataggio Criptato non disponibile';
$lang['title_install_crypto'] = 'Installate il modulo OpenSSL o mcrypt se desiderate abilitare la criptazione del database.';
$lang['title_install_curl'] = 'Verificate che sia attivo il supporto CURL nella vostra installazione PHP. Fate riferimento a http://www.php.net/manual/en/book.curl.php';
$lang['title_mle_version'] = 'Esegui in modalit&agrave; MLE';
$lang['title_mle_version_long'] = 'Modifica/supporta la versione CMSMS Edizione Multi-Lingua. Non selezionate se non state eseguendo questa versione.';
$lang['title_ensure_cert_key_match'] = 'Verificate di avere selezionato la chiave privata adatta al certificato che state utilizzando per la criptazione!';
$lang['choose_crypt'] = 'Libreria di Criptazione';
$lang['title_encrypt_database_long'] = 'Selezionatelo per criptare i dati salvati. Ci&ograve; rende pi&ugrave; difficile (ma non impossibile) la visualizzazione delle informazioni da parte degli hacker.';
$lang['choose_crypt_long'] = 'le opzioni sottostanti si applicano solo se state utilizzando la Libreria di criptazione OpenSSL';
$lang['title_crypt_lib'] = 'Libreria di Criptazione';
$lang['openssl'] = 'Libreria OpenSSL';
$lang['mcrypt'] = 'Libreria PHP mcrypt';
$lang['title_install_listit2'] = 'installate ListItExtended per inviare al modulo.';
$lang['title_listit2_instance'] = 'Istanza ListItExtended';
$lang['title_listit2_state'] = 'Stato dell&#039;oggetto ListItExtended (Attivo/Inattivo)';
$lang['content_select_instance'] = 'Tutti icampi possono essere mappati dopo avere inserito questo campo nel modulo la prima volta';
$lang['title_feu_binding'] = 'Abbinamento con FrontEndusers';
$lang['title_install_feu'] = 'Installate il modulo FrontEndUsers per collegare un modulo e i suoi dati ad un utente specifico';
$lang['title_feu_bind_help'] = 'Selezionate per vincolare l&#039;accesso utente a questo modulo all&#039;utente FEU che ha effettuato l&#039;accesso.';
$lang['title_encryption'] = 'Criptazione';
$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. 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 per 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'] = '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'] = 'Commuta al modo Avanzato';
$lang['title_switch_basic_link'] = 'Commuta al modo Semplice';
$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_usertag_disposition'] = 'User defined tag returned an error';
$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['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['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['utma'] = '156861353.838811379.1385129143.1389707124.1389783779.5';
$lang['utmz'] = '156861353.1389198872.3.3.utmcsr=solgea.net|utmccn=(referral)|utmcmd=referral|utmcct=/cmsms/admin/index.php';
$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'] = 'Formos';
$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_PasswordField'] = 'Password';
$lang['field_type_PasswordAgainField'] = 'Password Again (verify)';
$lang['field_type_TextFieldExpandable'] = 'Text Input (Multiple)';
$lang['field_type_TextAreaField'] = 'Text Area';
$lang['field_type_ButtonField'] = 'Button';
$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_DispositionFromEmailAddressField'] = '*Email &quot;From Address&quot; 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'] = '-Puslapio trūkis';
$lang['field_type_FileUploadField'] = 'Bylos atsiuntimas';
$lang['field_type_FromEmailAddressField'] = 'El pa&scaron;to &quot;Nuo Adresas&quot; laukelis';
$lang['field_type_FromEmailAddressAgainField'] = 'Email &quot;From Address&quot; Again Field';
$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'] = 'Paslėptas laukas';
$lang['field_type_ComputedField'] = '-Computed Field';
$lang['field_type_UniqueIntegerField'] = '-Unique Integer (Serial)';
$lang['validation_none'] = 'Netikrinti';
$lang['validation_numeric'] = 'Numeric';
$lang['validation_integer'] = 'Sveikas skaičius';
$lang['validation_email_address'] = 'El pa&scaron;to adresas';
$lang['validation_usphone'] = 'Tel. nr. (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'] = 'Privalomam laukui nebuvo suteikta vertė';
$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'] = 'Pra&scaron;ome įvesti sveiką skaičių laukelyje &quot;%s&quot;';
$lang['please_enter_an_email'] = 'Pra&scaron;ome įvesti galiojantį el pa&scaron;to adresą&quot;%s&quot;';
$lang['email_address_does_not_match'] = 'Email address does not match value in &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['please_enter_at_least'] = 'Please enter a value that is at least %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'] = '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'] = 'Kam';
$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'] = 'Valanda';
$lang['min'] = 'Minutė';
$lang['merid'] = 'Meridian';
$lang['date_range'] = 'Ruožas: %s - %s';
$lang['thanks'] = 'Ačiū! Jūsų pateikimas buvo gautas.';
$lang['edit'] = 'Redaguoti';
$lang['delete'] = 'Trinti';
$lang['day'] = 'Diena';
$lang['mon'] = 'Mėnuo';
$lang['year'] = 'Metai';
$lang['none'] = '(none)';
$lang['css'] = 'CSS';
$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'] = 'Pagrindinis';
$lang['tab_symbol'] = 'Formos rodymo nustatymai';
$lang['tab_submit'] = 'Formos pateikimas';
$lang['tab_captcha'] = 'Captcha nustatymai';
$lang['tab_advanced'] = 'Papildomi Snustatymai';
$lang['tab_templatelayout'] = 'Template Layout Options';
$lang['tab_submissiontemplate'] = 'Pateikimo &scaron;ablonas';
$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'] = 'Pridėti daugiau Checkbox laukų';
$lang['delete_checkboxes'] = 'I&scaron;trinti pažymėtus Checkbox laukus';
$lang['add_address'] = 'Pridėti kitą adresą';
$lang['delete_address'] = 'I&scaron;trinti pažymėtus adresus';
$lang['add_destination'] = 'Pridėti kitą paskyrimo vietą';
$lang['delete_destination'] = 'I&scaron;trinti pažymėtas paskyrimo vietas';
$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'] = 'Pakeisti laukų eili&scaron;kumą';
$lang['cancel'] = 'At&scaron;aukti';
$lang['value_set'] = 'Nustatyta vertė: %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'] = 'Lauko auk&scaron;tis';
$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'] = 'Pateikta naudojant forbbuilder';
$lang['title_uploads_category'] = 'Įkėlimų kategorija';
$lang['title_sendto_uploads'] = 'Siųsti &scaron;į  failą į uploads modulį';
$lang['title_legend'] = 'Legenda';
$lang['title_maximum_length'] = 'Didžiausias ilgis';
$lang['title_checkbox_label'] = 'Checkbox etiketė';
$lang['title_radio_label'] = 'Radio Button etiketė';
$lang['title_checked_value'] = 'Vertė kai pažymėta';
$lang['title_unchecked_value'] = 'Vertė kai nepažymėta';
$lang['title_checkbox_details'] = 'Checkbox Group Details';
$lang['title_delete'] = 'I&scaron;trinti?';
$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'] = 'Naudoti supaprastintą e. pa&scaron;to adreso tikrinimą';
$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'] = 'Failo pavadinimas';
$lang['title_email_subject'] = 'E. pa&scaron;to temos linija';
$lang['title_form_name'] = 'Formos pavadinimas';
$lang['title_form_status'] = 'Formos būsena';
$lang['title_ready_for_deployment'] = 'Ready for Deployment';
$lang['title_not_ready1'] = 'Neparengta';
$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'] = 'nudoti &scaron;į trumpinį';
$lang['title_form_alias'] = 'Formos aliasas';
$lang['title_form_fields'] = 'Formos laukai';
$lang['title_field_id'] = 'Lauko Id';
$lang['title_show_fieldaliases'] = 'Rodyti formos aliasus';
$lang['title_show_fieldaliases_long'] = 'Clicking this will display field aliases when adding or editing a form';
$lang['title_field_name'] = 'Lauko pavadinimas';
$lang['title_field_alias'] = 'Lauko aliasas';
$lang['title_radiogroup_details'] = 'Radio Button Group Details';
$lang['title_field_type'] = 'Lauko tipas';
$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'] = 'Formos pateikimo mygtuko tekstas';
$lang['title_button_text'] = 'Mygtuko tekstas';
$lang['title_submit_button_safety'] = 'Add Javascript to Submit Button to prevent multiple submissions?';
$lang['title_submit_button_safety_help'] = 'Pridėti saugumo skriptą';
$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'] = 'Lauko tikrinimas';
$lang['title_field_to_validate'] = 'Laukas patikrinimui';
$lang['title_field_css_id'] = 'CSS ID &scaron;iam laukui';
$lang['title_form_css_class'] = 'CSS klasė &scaron;iai formai';
$lang['title_field_css_class'] = 'CSS klasė &scaron;iam laukui';
$lang['title_form_predisplay_udt'] = 'User defined tag to call before form is displayed';
$lang['title_form_required_symbol'] = 'Simbolis privalomų laukų žymėjimui';
$lang['title_field_required'] = 'Privalomas';
$lang['title_field_required_long'] = 'Privalomas laukas';
$lang['title_hide_label'] = 'Slėpti etiketę';
$lang['title_hide_label_long'] = 'Hide this field&#039;s name on Form';
$lang['title_text'] = 'Statinis tekstas';
$lang['title_field_regex'] = 'Tikrinimo Regex';
$lang['title_lines_to_show'] = 'Rodomų linijų skaičius';
$lang['title_read_only'] = 'Tik skaitymui';
$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'] = 'Privalomas';
$lang['title_hide_errors'] = 'Slėpti klaidas';
$lang['title_form_displaytype'] = 'Formos rodymo tipas';
$lang['title_hide_errors_long'] = 'Prevent debug / error messages from being seen by users.';
$lang['title_email_template'] = 'E. lai&scaron;ko &scaron;ablonas';
$lang['title_maximum_size'] = 'Maksimalus įkeliamo failo dydis (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'] = 'Rodyti laukų 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 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_default_blank'] = 'Default to blank';
$lang['title_default_blank_help'] = 'Default to blank (uncheck to default to today&#039;s date)';
$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['title_encrypt_database_data'] = 'Encrypt data stored in database';
$lang['title_crypt_cert'] = 'Certificate for encrypting data';
$lang['title_encryption_keyfile'] = 'Passphrase or path to file containing passphrase for private key';
$lang['title_encrypt_sortfields'] = 'Hash sort fields?';
$lang['title_private_key'] = 'Private Key to use for encrypting data';
$lang['title_encrypt_sortfields_help'] = 'This hashes the sort fields, but leaves the first few letters unencrypted. Cryptographically, this creates a vulnerability, but for most users it is an acceptable tradeoff between security and the ability to sort records. Sorting becomes approximate, but will remain pretty good. If you do not use this option, sort fields are stored in plaintext.';
$lang['title_encryption_functions'] = 'Storage Encryption Unavailable';
$lang['title_install_crypto'] = 'Please install the OpenSSL module or mcrypt support if you would like to enable database encryption.';
$lang['title_mle_version'] = 'Run in MLE Mode';
$lang['title_mle_version_long'] = 'Changes/support for CMSMS Multi-Language Edition fork. Do not check this if you are not running the MLE version.';
$lang['title_ensure_cert_key_match'] = 'Ensure that you select the private key that is appropriate for the certificate you are using for encryption!';
$lang['choose_crypt'] = 'Encryption Library';
$lang['title_encrypt_database_long'] = 'Check this to encrypt the stored data. This makes it more difficult (but not impossible) for hackers to view the information.';
$lang['choose_crypt_long'] = 'The options below only apply if you are using the OpenSSL Encryption library';
$lang['title_crypt_lib'] = 'Encryption Library';
$lang['openssl'] = 'OpenSSL Library';
$lang['mcrypt'] = 'PHP mcrypt Library';
$lang['title_feu_binding'] = 'Frontend User binding';
$lang['title_install_feu'] = 'Please install the Frontend User module to connect a form and its data to a specific user';
$lang['title_feu_bind_help'] = 'Check this to lock front-end access to this form&#039;s data to the logged-in front-end user.';
$lang['title_encryption'] = 'Encryption';
$lang['title_export_form_to_udt'] = 'Export form reference to UDT as $params[&#039;FORM&#039;]?';
$lang['restricted_to_group'] = 'Tik %s grupėje';
$lang['title_show_to_user'] = 'Rodyti naudotoją?';
$lang['help_leaveempty'] = '&Scaron;is laukas gali būti tu&scaron;čias';
$lang['help_variables_for_template'] = 'Variables For Template';
$lang['help_variables_for_computation'] = 'Variables Available';
$lang['help_php_variable_name'] = 'PHP kintamasis';
$lang['help_submission_date'] = 'Pateikimo data';
$lang['help_server_name'] = 'Jūsų serveris';
$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 versija';
$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'] = 'Kintamasis';
$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'] = 'Numatyti metai';
$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'] = 'Nukreipti į svetainės puslapį';
$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_field_helptext'] = 'Help-text to display with this field';
$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'] = 'Eilutė';
$lang['title_numeric'] = 'Skaičius';
$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'] = 'Numatyta lauko vertė';
$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'] = 'Reikia daugiau laukų tipų? ';
$lang['title_switch_basic'] = 'Perdaug laukų tipų? ';
$lang['title_switch_advanced_link'] = 'Perjungti į i&scaron;plėstinę modą';
$lang['title_switch_basic_link'] = 'Perjungti į paprastą modą';
$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'] = 'Siųsti formos kopiją man';
$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['title_display_length'] = 'Display length';
$lang['title_minimum_length'] = 'Minimum response length';
$lang['title_hide'] = 'Hide input';
$lang['title_hide_help'] = 'Show symbols rather plain text when user enters password?';
$lang['password_does_not_match'] = 'Password does not match %s';
$lang[''] = '';
$lang['option_never'] = 'Niekada';
$lang['option_user_choice'] = 'Give user a choice (checkbox)';
$lang['option_always'] = 'Visada';
$lang['error_usertag_disposition'] = 'User defined tag returned an error';
$lang['error_cataloger_module_not_available'] = '<strong>Cataloger module does not seem to be installed/active.</strong>';
$lang['warning'] = 'DĖMESIO!';
$lang['default_template'] = 'Numatytas &scaron;ablonas';
$lang['table_left_template'] = 'Table Template, Titles on left';
$lang['table_top_template'] = 'Table Template, Title on top';
$lang['form_template_name'] = '&Scaron;ablonas i&scaron; %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'] = 'Deja! Įvyko klaida pateikiant jūsų atsakymus.';
$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['qca'] = 'P0-503561618-1253632908224';
$lang['utma'] = '156861353.579566734.1253831402.1257096770.1257785403.14';
$lang['utmz'] = '156861353.1257785403.14.13.utmccn=(referral)|utmcsr=forum.cmsmadesimple.org|utmcct=/index.php/topic,38875.0/topicseen.html|utmcmd=referral';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/nb_NO.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Skjemabygger';
$lang['field_type_DispositionEmailFromFEUProperty'] = '*E-post brukere som passer med en FEU egenskap';
$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_HTML5NumberField'] = 'HTML5 Antall Input';
$lang['field_type_HTML5EmailField'] = 'HTML5 E-post Input';
$lang['field_type_HTML5URLField'] = 'HTML5 URL inndata';
$lang['field_type_SiteAdminField'] = 'Nettstedsadmin';
$lang['field_type_PasswordField'] = 'Passord';
$lang['field_type_PasswordAgainField'] = 'Gjenta passord (verifiser)';
$lang['field_type_TextFieldExpandable'] = 'Tekst innskriving (Flere)';
$lang['field_type_TextAreaField'] = 'Tekstomr&aring;de';
$lang['field_type_ButtonField'] = 'Knapp';
$lang['field_type_CheckboxField'] = 'Avkrysningsboks';
$lang['field_type_CheckboxGroupField'] = 'Avkrysningsboks gruppe';
$lang['field_type_PulldownField'] = 'Nedtrekk';
$lang['field_type_YearPullDownField'] = '&Aring;r 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_DispositionUniqueFile'] = '*Skriv resultat til en Unik flat fil for hvert innlegg';
$lang['field_type_DispositionDatabase'] = '*Lagre resultater i databasen';
$lang['field_type_DispositionFormBrowser'] = '*Lagre resultater for FormBrowser modulen v.3';
$lang['field_type_DispositionUserTag'] = '*Kall opp en Brukerdefinert Tagg med skjema resultatene';
$lang['field_type_DispositionForm'] = '* Send til en vilk&aring;rlig skjemahandling';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Epost til Bruker-Oppgitt Epostadresse';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Epost til CMS Admin bruker';
$lang['field_type_DispositionEmailBasedFrontendFields'] = '*E-post resultater basert p&aring; Frontend felter';
$lang['field_type_DispositionListItExtended'] = '*Lagre resultater for ListItExtended';
$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_CCEmailAddressField'] = 'E-post Carbon Copy (CC) adressefelt';
$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['field_type_UserTagField'] = '-Bruker Definert Tagg(UDT) kall';
$lang['field_type_CompanyDirectoryField'] = 'Company Directory felt';
$lang['field_type_ModuleInterfaceField'] = '-Modul grensesnittsfelt';
$lang['field_type_CheckboxExtendedField'] = 'Utvidet Avkrysningsboks';
$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['validation_empty'] = 'Kan ikek v&aelig;re tom';
$lang['required'] = 'P&aring;krevd';
$lang['not_required'] = 'Frivillig';
$lang['not_available'] = 'Ikke tilgjengelig';
$lang['error_emailfromfeuprop'] = 'Feil i Felt oppsett';
$lang['error_nofeu'] = 'FrontEndUsers modulen ble ikke funnet. Dette feltet vil ikke fungere.';
$lang['error_nofeudefns'] = 'Ingen passende FEU egenskap ble funnet. Dette feltet vil ikke fungere.';
$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['please_login'] = 'Vennligst logg inn for &aring; benytte dette skjema';
$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['please_enter_at_least'] = 'Vennligst oppgi en verdi som best&aring;r av minst %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 ikke sl&aring;r av dette i Skjemabygger konfigurasjonen.';
$lang['no_field_assigned'] = 'Ingen felt tilegnet for %s';
$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['fields'] = 'felter';
$lang['file_count'] = '%s mulige filer';
$lang['destination_count'] = '%s m&aring;l';
$lang['save'] = 'Lagre og lukk';
$lang['add'] = 'Legg til';
$lang['update'] = 'Oppdater';
$lang['save_and_continue'] = 'Bruk';
$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['css'] = 'Stilark (CSS)';
$lang['notice'] = 'MERK';
$lang['general'] = 'Generelt';
$lang['about'] = 'Om';
$lang['templates'] = 'Maler';
$lang['advanced'] = 'Avansert';
$lang['styling'] = 'Styling';
$lang['team'] = 'Teamet';
$lang['contributors'] = 'Bidragsytere';
$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['tab_udt'] = 'UDT integrasjon';
$lang['title_feu_property'] = 'FrontEndUsers egenskap';
$lang['info_feu_property'] = 'Bare spesielle egenskapstyper kan benyttes for kobling (nedtrekk, flervalg felt, osv).';
$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 e-poster 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['title_textfield_label'] = 'Tekstfelt etikett';
$lang['title_show_textfield'] = 'Vis tekstfelt?';
$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_allow_overwrite'] = 'Tillat opplasting &aring; overskrive eksisterende filer?';
$lang['title_allow_overwrite_long'] = 'Skal opplastet fil overskrive tidligere opplastet fil om de har samme navn?';
$lang['overwrite'] = 'Tillater overskriving';
$lang['nooverwrite'] = 'Ingen overskriving';
$lang['file_already_exists'] = 'Filen %s eksisterer allerede, og f&aring;r ikke overskrives.';
$lang['title_file_rename'] = 'Filnavn-mal';
$lang['original_file_extension'] = 'Original filendelse (inkludert &quot;.&quot;)';
$lang['title_suppress_filename'] = 'Undertrykk filnavn i e-post og skjemaer sluttbrukeren vil se';
$lang['title_suppress_attachment'] = 'Nekt filer &aring; bli lagt ved eposter';
$lang['file_rename_help'] = 'For &aring; endre navn p&aring; en fil ved opplasting, oppretter du malen her. La st&aring; tomt for &aring; bevare opprinnelige filnavn';
$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'] = 'Sjemanavn';
$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_field_alias_short'] = '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 Skjemabygger versjon?';
$lang['title_show_version_long'] = 'Dette vil innkapsle ditt versjonsnummer for Skjemabygger 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_button_text'] = '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_field_css_id'] = 'CSS id for dette feltet';
$lang['title_form_css_class'] = 'CSS klasse for dette skjema';
$lang['title_field_css_class'] = 'CSS klasse for dette felt';
$lang['title_form_predisplay_udt'] = 'Bruker definert tagg(User Defined Tag/UDT) &aring; kalle f&oslash;r skjemaet vises f&oslash;rste gang (kalles kun en gang)';
$lang['title_form_predisplay_each_udt'] = 'Bruker Definerte Tagg(UDT) &aring; kalle opp f&oslash;r skjema vises (blir kallt opp for hver side for flerside-skjemaer)';
$lang['title_form_validate_udt'] = 'Brukerdefinert tagg(UDT) &aring; kalle opp under skjema validering';
$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_textarea_length'] = 'Maksimal lengde p&aring; feltinnhold (0 eller blank betyr ingen grense)';
$lang['title_text'] = 'Statisk tekst &aring; vise';
$lang['title_field_regex'] = '(Regex) sjekk';
$lang['title_lines_to_show'] = 'Antall linjer &aring; vise';
$lang['title_read_only'] = 'Skrivebeskyttet';
$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_file_destination'] = 'Katalog hvor filer skal lagres';
$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 at 10 e-poster &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'] = 'Skjema detaljer';
$lang['title_default_blank'] = 'Standard er blank';
$lang['title_default_blank_help'] = 'Standard er blank (fjern avhaking for &aring; benytte dagens dato som standard)';
$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['title_encrypt_database_data'] = 'Krypter data lagret i databasen';
$lang['title_crypt_cert'] = 'Sertifikat for krypetering av data';
$lang['title_encryption_keyfile'] = 'Passordfrase eller sti til fil som inneholder passordfrase. (Om OpenSSL benyttes er dette passordfrasen for privatn&oslash;kkelen)';
$lang['title_encrypt_sortfields'] = 'Sladd sorteringsfelter?';
$lang['title_private_key'] = 'Privatn&oslash;kkel &aring; benytte for &aring; kryptere data';
$lang['title_encrypt_sortfields_help'] = 'Dette sladder sorteringsfeltene, men lar de f&oslash;rste f&aring; bokstavene v&aelig;re ukrypterte, dette gir en s&aring;rbarhet, men for de fleste brukere er dette en akseptabel middelvei mellom sikkerhet og muligheten til &aring; sortere poster. Sorteringen blir s&aring;nn omtrent, men forblir ganske god. Om du ikke benytter dette valget s&aring; vil sorteringsfelter bli lagret i klartekst.';
$lang['title_encryption_functions'] = 'Lagringskryptering ikke tilgjengelig';
$lang['title_install_crypto'] = 'Vennligst installer OpenSSL modulen eller mcrypt-st&oslash;tte om du &oslash;nsker &aring; benytte databasekryptering.';
$lang['title_install_curl'] = 'Kontroller at du har CURL st&oslash;tte aktiv i din PHP installasjon. Se http://www.php.net/manual/en/book.curl.php';
$lang['title_mle_version'] = 'Kj&oslash;r i MLE-modus';
$lang['title_mle_version_long'] = 'Endringer/st&oslash;tte for CMSMS Multi-Language Edition fork. Ikke hak av for dette om du ikke kj&oslash;rer MLE versjonen.';
$lang['title_ensure_cert_key_match'] = 'V&aelig;r sikker p&aring; at du velger den private n&oslash;kkelen som tilh&oslash;rer sertifikatet du benytter for krypteringen!';
$lang['choose_crypt'] = 'Krypteringsbibliotek';
$lang['title_encrypt_database_long'] = 'Hak av denne for &aring; kryptere de lagrede data. Dette gj&oslash;r det mer vanskelig (men ikke umulig) for hackere &aring; lese informasjonen.';
$lang['choose_crypt_long'] = 'Valgene nedenfor er kun gyldige om du benytter OpenSSL Encryption biblioteket';
$lang['title_crypt_lib'] = 'Krypteringsbibliotek';
$lang['openssl'] = 'OpenSSL bibliotek';
$lang['mcrypt'] = 'PHP mcrypt bibliotek';
$lang['title_install_listit2'] = 'Vennligst installer ListItExtended for &aring; sende et skjema til modulen';
$lang['title_listit2_instance'] = 'ListItExtended instans';
$lang['title_listit2_state'] = 'ListItExtended Element tilstand (aktiv/passiv)';
$lang['content_select_instance'] = 'Alle felt kan kobles n&aring;r dette feltet er lagt til skjemaet';
$lang['title_feu_binding'] = 'Frontend User tilkobling';
$lang['title_install_feu'] = 'Vennligst installer Frontend User modulen for &aring; koble et skjema og dets data til en spesifik bruker';
$lang['title_feu_bind_help'] = 'Hak av denne for &aring; l&aring;se front-end tilgang til data i dette skjema til den innloggede front-end brukeren.';
$lang['title_encryption'] = 'Kryptering';
$lang['title_export_form_to_udt'] = 'Eksportere skjemarefferanse til UDT som $params[&#039;FORM&#039;]? (ikke gj&oslash;r dette om du skal kj&oslash;re  print_r($params) )';
$lang['title_url_help'] = 'Hele nettadressen, inkludert protokollen og bane (f.eks, http://myhost.com/form_handler.cgi)';
$lang['title_url'] = 'Skjemainnsendings URL';
$lang['title_method'] = 'Skjema metode';
$lang['title_maps_to'] = 'Koble feltet &quot;%s&quot; til skjemainnsendings variabelen';
$lang['title_maps_to_field'] = 'Koble felt &quot;%s&quot; til felt';
$lang['title_additional'] = 'Ytterligere innsending';
$lang['title_additional_help'] = 'Noe &aring; bli lagt til innsendings payload i URL-kodet form (Eksempel &quot;user=steve+jobs&amp;employee_number=1)';
$lang['title_include_in_submission'] = 'Inkluder feltet i innsendingen';
$lang['title_date_order'] = 'Rekkef&oslash;lge for dato komponent-feltet (for innskriving)';
$lang['title_data_stored_in_fbr'] = 'Data vil bli lagret i et XML format i [PREFIX]_module_fb_frombrowser database tabellen.';
$lang['error_has_no_fb_field'] = 'Feil! Enten skjemaet har ingen form_builder disposisjon, eller det feilet i lasting (pga minne problemer?)';
$lang['help_date_order'] = 'Benytt &quot;m&quot; for m&aring;ned, &quot;d&quot; for dag, og &quot;y&quot; for &aring;r. Skill elementene med bindestrek.';
$lang['restricted_to_group'] = 'Kun i gruppe %s';
$lang['title_show_to_user'] = 'Vis til bruker?';
$lang['title_use_random_generator'] = 'Benytt tilfeldig nummergenerator i stedet for statisk';
$lang['title_numbers_to_generate'] = 'Hvor mange nummer skal genereres i prosessen';
$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_ignored_if_upload'] = '(Dette feltet blir ignorert hvis du bruker Opplasting modulen til &aring; behandle filer)';
$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 containing:<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 formaterings hjelp.';
$lang['help_variable_name'] = 'Variabel';
$lang['help_form_field'] = 'Felt representert';
$lang['help_rtf_file_template'] = 'Spesifiser en fil i FormBuilder/templates/ mappen. Dette feltet blir ignorert om de benytter TXT som din filtype.';
$lang['help_rtf_template_type'] = 'Basic: Bruk tekstfeltet nedenfor til layout feltnavnene/verdier i &eacute;n enkelt blokk <br />.
Avansert: Angi Smarty variabler i RTF malfil som du ville gjort nedenfor, men ordne dem slik du vil og legge til formatering <br />.
Du kan fortsatt bruke%% HEADER%% og%%FOOTER%% seksjoner i RTF-filen.';
$lang['help_unique_file_template'] = 'For TXT, vil dette v&aelig;re umiddelbart etter Header Mal. <br />
For RTF, vil denne erstatte%%FIELDS%% streng i malfilen hvis RTF Template Type er satt til &quot;Basic&quot;. <br />
Dette feltet vil bli ignorert hvis du bruker &quot;RTF&quot; som filtype og &quot;Advanced&quot; som RTF maltype.';
$lang['help_file_header_template'] = 'For TXT, vil dette v&aelig;re plassert p&aring; toppen av filen. For RTF, vil denne erstatte%%HEADER%% streng i malen filen.';
$lang['help_file_footer_template'] = 'For TXT, vil denne bli plassert p&aring; bunnen av filen. For RTF, vil denne erstatte%%FOOTER%% streng i malfilen.';
$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_footer_template'] = 'Opprett Eksempel Footer 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 hodet p&aring; utdata filen';
$lang['title_file_footer'] = 'Mal for bunnteksten p&aring; utdata filen';
$lang['title_rtf_file_template'] = 'Mal RTF fil &aring; benytte';
$lang['title_unique_file_template'] = 'Mal for utdata';
$lang['title_file_type'] = 'Velg en filtype &aring; benytte';
$lang['title_rtf_template_type'] = 'Velg en RTF maltype';
$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 Skjemabygger 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['title_submit_date'] = 'Dato innsendt';
$lang['title_approval_date'] = 'Dato godkjent (av admin)';
$lang['title_user_approved'] = 'Dato godkjent (av innsender)';
$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_field_helptext'] = 'Hjelpetekst &aring; vise for dette feltet';
$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_string_unspaced'] = 'Streng (ingen mellomrom mellom felter)?';
$lang['title_compute_value'] = 'Verdi &aring; beregne';
$lang['title_compute'] = 'Beregnede/PHP';
$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 oppf&oslash;lging 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'] = 'Gj&oslash;r dette til det fullstendige javaskrifptkallet, inkludert hendelsen du vil fange, f.eks., onclick=&quot;yourfn()&quot;';
$lang['title_submit_javascript'] = 'Skjemainnsendings javaskript';
$lang['title_submit_javascript_long'] = 'Gj&oslash;r dette til det fullstendige javaskrifptkallet, inkludert hendelsen du vil fange, f.eks., onclick=&quot;yourfn()&quot;.<br />Dette vil trolig ikke fungere godt om du benytter &quot;Sikkehetskript&quot; opsjonen ovenfor.';
$lang['email_from_addr_help'] = 'Ikke 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 webserveren har rettigheter til &aring; skrive i. <br />
Chmod denne til 777 hvis du har problemer/er i tvil. <br />
Sjekk ogs&aring; for &aring; se at du ikke har PHP katalog restriksjoner. <br />
Dersom feltet er tomt, vil dette benytte standard uploads katalogen ($ config[&#039;uploads_path&#039;]).';
$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['title_display_length'] = 'Lengde &aring; vise';
$lang['title_minimum_length'] = 'Minimum lengde p&aring; svar';
$lang['title_hide'] = 'Skjul inndata';
$lang['title_hide_help'] = 'Vis symboler i stedet for tekst n&aring;r bruker skriver passord?';
$lang['password_does_not_match'] = 'Passord samsvarer ikke med %s';
$lang['back_top'] = 'Tilbake til FormBuilder hovedsiden';
$lang['title_headers_to_modify'] = 'Hvilke e-post hoder b&oslash;r dette inndatafelt fylle ut?';
$lang['title_blank_invalid'] = 'Ikke godta mellomrom som gyldig svar';
$lang['title_blank_invalid_long'] = 'Om et felt er p&aring;krevd, vil avkryssing av dette valg kreve at folk skriver inn alfanummeriske bokstaver og ikke bare mellomrom';
$lang['title_must_save_order'] = 'Du m&aring; klikke en av &quot;lagre&quot;-knappene for &aring; gj&oslash;re din nye feltrekkef&oslash;lge permanent.';
$lang['title_html5'] = 'Bruk HTML5 plassholdertekst i stedet for Javascript';
$lang['title_email_cc_address'] = 'Addresse(r) &aring; e-poste som Carbon copy (CC). Bruk komma for &aring; avgrense flere adresser.';
$lang['title_use_bcc'] = 'Benytt Blind carbon copy (BCC i stedet for CC)';
$lang['title_send_using'] = 'E-post adressering';
$lang['title_field_to_modify'] = 'E-postfelt &aring; legge til CC adresse';
$lang['title_modifies'] = 'Legg CC til &quot;%s&quot;';
$lang['bcc_field'] = '&quot;BCC&quot; mottakere';
$lang['cc_field'] = '&quot;CC&quot; mottakere';
$lang['to_field'] = 'Normale (&quot;To&quot; mottakere)';
$lang['bcc'] = 'BCC';
$lang['cc'] = 'CC';
$lang['error_CompanyDirectory_module_not_available'] = 'Company Directory modulen er ikke tilgjengelig!';
$lang['option_never'] = 'Aldri';
$lang['option_user_choice'] = 'Gi brukeren et valg (avkryssningsboks)';
$lang['option_always'] = 'Alltid';
$lang['option_from'] = '&quot;Fra&quot; e-postadresse';
$lang['option_reply'] = '&quot;Svar-til&quot; e-postadresse';
$lang['option_both'] = 'B&aring;de &quot;Fra&quot; og &quot;Svar-til&quot; e-postadressene';
$lang['option_dropdown'] = 'Nedtrekk';
$lang['option_selectlist_single'] = 'Valgliste (enkelt)';
$lang['option_selectlist_multiple'] = 'Valgliste (flere)';
$lang['option_radiogroup'] = 'Radioknappgruppe';
$lang['title_company_field_note'] = 'Merk: Utdata vil v&aelig;re p&aring; formen<br/>&quot;firmanavn&quot;=>&quot;verdi&quot;';
$lang['title_pick_categories'] = 'Velg en kategori (flere)';
$lang['title_pick_fielddef'] = 'Velg et felt Definisjonsverdi (enkel) <em>valgfritt</em>';
$lang['title_choose_user_input'] = 'Velg bruker-inndata';
$lang['title_see_also_udt'] = '(Ta ogs&aring; en titt p&aring; Skjemainnsendingsfanen om du &oslash;nsker &aring; sette en UDT for skjemavalidering)';
$lang['title_year_end_message'] = 'Slutt &aring;r';
$lang['title_field_logic'] = 'Smarty data eller logikk som er ment for &aring; bli sendt med dette feltet';
$lang['title_field_logic_long'] = 'Kan v&aelig;re smartydata, javaskript eller noe annen data du vil sende sammen med dette feltet.<br />G&aring;r gjennom smarty kompilereren, s&aring; husk &aring; benytte{literal}{/literal} tagger sammen med <script></script>';
$lang['title_field_includelabels'] = 'Inkluder etiketter';
$lang['title_field_includelabels_help'] = '&Aring; aktivere dette inkluderer etiketter i utdata. Eksempel - etikett: verdi,etikett2: verdi2';
$lang['title_field_siblings'] = 'Lenk dette felt til dets etterf&oslash;lger';
$lang['title_field_siblings_help'] = 'Nedtrekksliste lister alle etterf&oslash;lgere av dette felt og tillater deg &aring; lenke dette feltet til en av dets etterf&oslash;lgere. Dette gj&oslash;r det mulig &aring; kontrollere dette feltet med valgte etterf&oslash;lger kontroller.';
$lang['title_field_hidebuttons'] = 'Skjul kontrollknapper';
$lang['title_field_hidebuttons_help'] = 'Skjuler kontrollknapper for dette felt p&aring; fronend';
$lang['title_note'] = 'Merk';
$lang['title_changing_triggers_reindex'] = '&Aring; endre noen av de ovennevnte feltene vil utl&oslash;se en Reindex av &#039;alle&#039; lagrede poster, s&aring; dette kan ta en stund.';
$lang['illegal_file'] = 'Fors&oslash;kte opplasting av ulovlig filtype (%s) fra %s';
$lang['title_searchable'] = 'Gj&oslash;r poster tilgjengelig for s&oslash;kemodulen';
$lang['title_searchable_help'] = 'Hake av dette vil gj&oslash;re alle innsendte data tilgjengelig for s&oslash;kemodulen. IKKE BRUK denne hvis du krypterer dine data -- informasjonen blir tilgjengelig for s&oslash;k om den er kryptert eller ikke!';
$lang['uploaded_outside_webroot'] = '%s (utenfor web rot)';
$lang['title_fbr_edit'] = 'Redigerbart i FormBrowser administrasjonen?';
$lang['title_active_only'] = 'Bare inkluder aktive brukere?';
$lang['error_usertag_disposition'] = 'Bruker definert tagg(User Defined Tag/UDT) returnerte en feil';
$lang['error_usertag'] = 'Bruker definert tagg(User Defined Tag/UDT) %s returnerte en feil.';
$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['must_specify_one_admin'] = 'M&aring; spesifisere en admin';
$lang['operators_help'] = 'Hvis du bruker String evaluering, vil den eneste operasjonen som er tilgjengelig v&aelig;re sammensetning (+). Hvis du benytter Nummer(Number) evaluering s&aring; har du de helt enkle matematiske (,+, -, *, /,). 
Hvis du bruker Beregnede/PHP evaluering, kan du
bruke de funksjonene du vil, men du m&aring; sitere ting (substitusjon skjer f&oslash;r evaluering), for eksempel substr(&#039;$fld_22&#039;,0,2).&#039;$fld_23&#039;.';
$lang['help_module_interface'] = 'Benytte modulgrensesnitt';
$lang['help_module_interface_long'] = '<b>Dette feltet brukes som en inngangsport til andre moduler!</b>
Benytt det ved &aring; opprette dine skjemaelementer i malene i andre moduler du &oslash;nsker &aring; innlemme, og benytt <strong>{$FBid}</strong> for &aring; koble dette tilbake til FormBuilder. F.eks. for &aring; inkludere skjema alternativer basert p&aring; Products modulen, opprett f&oslash;lgende mal i Products:<br/>
<pre>
{foreach from=$items item=entry}
	{assign var=MData value=&#039;&#039;}
	{assign var=Cd value=&#039;&#039;}
		{foreach from=$FBvalue item=MData}
			{assign var=MData value=&#039;::&#039;|explode:$MData}
			{if $MData[1]==$entry->id}
				{assign var=Cd value=&#039; checked=&quot;checked&quot;&#039;}
			{/if}
		{/foreach}
	<div class=&quot;ProductDirectoryItem&quot;>
		<input type=&quot;checkbox&quot; value=&quot;{$entry->price}::{$entry->id}&quot; name=&quot;{$FBid}[]&quot; {$Cd} />{$entry->product_name} ({$entry->weight}{$weight_units}) &pound;{$entry->price}    
	</div>
{/foreach}
</pre>
<br/>
hvor du i inndata nedenfor setter inn noe slikt som  <strong>{Products category=&quot;cat&quot; summarytemplate=&quot;Your_FB_template&quot;}</strong>';
$lang['title_add_tag'] = 'Sett inn din tagg';
$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['AF'] = 'Afghanistan';
$lang['AX'] = '&Aring;land';
$lang['AL'] = 'Albania';
$lang['DZ'] = 'Algerie';
$lang['AS'] = 'Amerikansk Samoa';
$lang['AD'] = 'Andorra';
$lang['AO'] = 'Angola';
$lang['AI'] = 'Anguilla';
$lang['AQ'] = 'Antarktis';
$lang['AG'] = 'Antigua og Barbuda';
$lang['AR'] = 'Argentina';
$lang['AM'] = 'Armenia';
$lang['AW'] = 'Aruba';
$lang['AU'] = 'Australia';
$lang['AT'] = '&Oslash;sterike';
$lang['AZ'] = 'Azerbaijan';
$lang['BS'] = 'Bahamas';
$lang['BH'] = 'Bahrain';
$lang['BB'] = 'Barbados';
$lang['BD'] = 'Bangladesh';
$lang['BY'] = 'Belarus';
$lang['BE'] = 'Belgia';
$lang['BZ'] = 'Belize';
$lang['BJ'] = 'Benin';
$lang['BM'] = 'Bermuda';
$lang['BT'] = 'Bhutan';
$lang['BW'] = 'Botswana';
$lang['BO'] = 'Bolivia';
$lang['BA'] = 'Bosnia og Herzegovina';
$lang['BV'] = 'Bouvet Island';
$lang['BR'] = 'Brasil';
$lang['IO'] = 'British Indian Ocean Territory';
$lang['BN'] = 'Brunei Darussalam';
$lang['BG'] = 'Bulgaria';
$lang['BF'] = 'Burkina Faso';
$lang['BI'] = 'Burundi';
$lang['KH'] = 'Cambodia';
$lang['CM'] = 'Cameroon';
$lang['CA'] = 'Canada';
$lang['CV'] = 'Cape Verde';
$lang['KY'] = 'Cayman Islands';
$lang['CF'] = 'Sentral Afrikanske Republikk';
$lang['TD'] = 'Chad';
$lang['CL'] = 'Chile';
$lang['CN'] = 'Kina';
$lang['CX'] = 'Christmas Island';
$lang['CC'] = 'Cocos (Keeling) Islands';
$lang['CO'] = 'Colombia';
$lang['KM'] = 'Comoros';
$lang['CG'] = 'Kongo';
$lang['CD'] = 'Kongo,  Democratic Republic';
$lang['CK'] = 'Cook Islands';
$lang['CR'] = 'Costa Rica';
$lang['CI'] = 'Ivoire (Ivory Coast)';
$lang['HR'] = 'Kroatia (Hrvatska)';
$lang['CU'] = 'Cuba';
$lang['CY'] = 'Cyprus';
$lang['CZ'] = 'Czech Republic';
$lang['DK'] = 'Danmark';
$lang['DJ'] = 'Djibouti';
$lang['DM'] = 'Dominica';
$lang['DO'] = 'Dominikanske Republikk';
$lang['TP'] = '&Oslash;st Timor';
$lang['EC'] = 'Ecuador';
$lang['EG'] = 'Egypt';
$lang['SV'] = 'El Salvador';
$lang['GQ'] = 'Equatorial Guinea';
$lang['ER'] = 'Eritrea';
$lang['EE'] = 'Estonia';
$lang['ET'] = 'Ethiopia';
$lang['FK'] = 'Falklands&oslash;yene (Malvinas)';
$lang['FO'] = 'Faroe Islands';
$lang['FJ'] = 'Fiji';
$lang['FI'] = 'Finland';
$lang['FR'] = 'Frankrike';
$lang['FX'] = 'Frankrike,  Metropolitan';
$lang['GF'] = 'Guernsey';
$lang['PF'] = 'Fransk Polynesia';
$lang['TF'] = 'Fransk Southern Territories';
$lang['MK'] = 'F.Y.R.O.M. (Macedonia)';
$lang['GA'] = 'Gabon';
$lang['GM'] = 'Gambia';
$lang['GE'] = 'Georgia';
$lang['DE'] = 'Tyskland';
$lang['GH'] = 'Ghana';
$lang['GI'] = 'Gibraltar';
$lang['GB'] = 'Storbritannia (UK)';
$lang['GR'] = 'Hellas';
$lang['GL'] = 'Gr&oslash;nnland';
$lang['GD'] = 'Grenada';
$lang['GP'] = 'Guadeloupe';
$lang['GU'] = 'Guam';
$lang['GT'] = 'Guatemala';
$lang['GN'] = 'Guinea';
$lang['GW'] = 'Guinea-Bissau';
$lang['GY'] = 'Guyana';
$lang['HT'] = 'Haiti';
$lang['HM'] = 'Heard and McDonald &Oslash;yene';
$lang['HN'] = 'Honduras';
$lang['HK'] = 'Hong Kong';
$lang['HU'] = 'Ungarn';
$lang['IS'] = 'Island';
$lang['IN'] = 'India';
$lang['ID'] = 'Indonesia';
$lang['IR'] = 'Iran';
$lang['IQ'] = 'Irak';
$lang['IE'] = 'Irland';
$lang['IL'] = 'Israel';
$lang['IM'] = 'Isle of Man';
$lang['IT'] = 'Italia';
$lang['JE'] = 'Jersey';
$lang['JM'] = 'Jamaica';
$lang['JP'] = 'Japan';
$lang['JO'] = 'Jordan';
$lang['KZ'] = 'Kazakhstan';
$lang['KE'] = 'Kenya';
$lang['KI'] = 'Kiribati';
$lang['KP'] = 'Korea (Nord)';
$lang['KR'] = 'Korea (Syd)';
$lang['KW'] = 'Kuwait';
$lang['KG'] = 'Kyrgyzstan';
$lang['LA'] = 'Laos';
$lang['LV'] = 'Latvia';
$lang['LB'] = 'Libanon';
$lang['LI'] = 'Liechtenstein';
$lang['LR'] = 'Liberia';
$lang['LY'] = 'Libya';
$lang['LS'] = 'Lesotho';
$lang['LT'] = 'Litauen';
$lang['LU'] = 'Luxembourg';
$lang['MO'] = 'Macau';
$lang['MG'] = 'Madagascar';
$lang['MW'] = 'Malawi';
$lang['MY'] = 'Malaysia';
$lang['MV'] = 'Maldivene';
$lang['ML'] = 'Mali';
$lang['MT'] = 'Malta';
$lang['MH'] = 'Marshall Islands';
$lang['MQ'] = 'Martinique';
$lang['MR'] = 'Mauritania';
$lang['MU'] = 'Mauritius';
$lang['YT'] = 'Mayotte';
$lang['MX'] = 'Mexico';
$lang['FM'] = 'Micronesia';
$lang['MC'] = 'Monaco';
$lang['MD'] = 'Moldovia';
$lang['MA'] = 'Morocco';
$lang['MN'] = 'Mongolia';
$lang['MS'] = 'Montserrat';
$lang['MZ'] = 'Mozambique';
$lang['MM'] = 'Myanmar';
$lang['NA'] = 'Namibia';
$lang['NR'] = 'Nauru';
$lang['NP'] = 'Nepal';
$lang['NL'] = 'Nederland';
$lang['AN'] = 'Netherlandske Antillene';
$lang['NT'] = 'Neutral Zone';
$lang['NC'] = 'New Caledonia';
$lang['NZ'] = 'New Zealand (Aotearoa)';
$lang['NI'] = 'Nicaragua';
$lang['NE'] = 'Niger';
$lang['NG'] = 'Nigeria';
$lang['NU'] = 'Niue';
$lang['NF'] = 'Norfolk Island';
$lang['MP'] = 'Northern Mariana Islands';
$lang['NO'] = 'Norge';
$lang['OM'] = 'Oman';
$lang['PK'] = 'Pakistan';
$lang['PW'] = 'Palau';
$lang['PS'] = 'Palestinsk territorium';
$lang['PA'] = 'Panama';
$lang['PG'] = 'Papua New Guinea';
$lang['PY'] = 'Paraguay';
$lang['PE'] = 'Peru';
$lang['PH'] = 'Philippinene';
$lang['PN'] = 'Pitcairn';
$lang['PL'] = 'Polen';
$lang['PT'] = 'Portugal';
$lang['PR'] = 'Puerto Rico';
$lang['QA'] = 'Qatar';
$lang['RE'] = 'Reunion';
$lang['RO'] = 'Romania';
$lang['RU'] = 'Russian Federation';
$lang['RW'] = 'Rwanda';
$lang['GS'] = 'S. Georgia and S. Sandwich Isls.';
$lang['KN'] = 'Saint Kitts and Nevis';
$lang['LC'] = 'Saint Lucia';
$lang['VC'] = 'Saint Vincent &amp; the Grenadines';
$lang['WS'] = 'Samoa';
$lang['SM'] = 'San Marino';
$lang['ST'] = 'Sao Tome and Principe';
$lang['SA'] = 'Saudi Arabia';
$lang['SN'] = 'Senegal';
$lang['SC'] = 'Seychelles';
$lang['SL'] = 'Sierra Leone';
$lang['SG'] = 'Singapore';
$lang['SI'] = 'Slovenia';
$lang['SK'] = 'Slovak Republic';
$lang['SB'] = 'Solomon Islands';
$lang['SO'] = 'Somalia';
$lang['ZA'] = 'Syd-Africa';
$lang['ES'] = 'Spania';
$lang['LK'] = 'Sri Lanka';
$lang['SH'] = 'St. Helena';
$lang['PM'] = 'St. Pierre and Miquelon';
$lang['SD'] = 'Sudan';
$lang['SR'] = 'Suriname';
$lang['SJ'] = 'Svalbard &amp; Jan Mayen &oslash;yene';
$lang['SZ'] = 'Swaziland';
$lang['SE'] = 'Sverige';
$lang['CH'] = 'Sveits';
$lang['SY'] = 'Syria';
$lang['TW'] = 'Taiwan';
$lang['TJ'] = 'Tajikistan';
$lang['TZ'] = 'Tanzania';
$lang['TH'] = 'Thailand';
$lang['TG'] = 'Togo';
$lang['TK'] = 'Tokelau';
$lang['TO'] = 'Tonga';
$lang['TT'] = 'Trinidad and Tobago';
$lang['TN'] = 'Tunisia';
$lang['TR'] = 'Tyrkia';
$lang['TM'] = 'Turkmenistan';
$lang['TC'] = 'Turks and Caicos Islands';
$lang['TV'] = 'Tuvalu';
$lang['UG'] = 'Uganda';
$lang['UA'] = 'Ukraina';
$lang['AE'] = 'United Arab Emirates';
$lang['UK'] = 'Storbritannia';
$lang['US'] = 'Forente Stater America';
$lang['UM'] = 'US Minor Outlying Islands';
$lang['UY'] = 'Uruguay';
$lang['UZ'] = 'Uzbekistan';
$lang['VU'] = 'Vanuatu';
$lang['VA'] = 'Vatican City State (Holy See)';
$lang['VE'] = 'Venezuela';
$lang['VN'] = 'Vietnam';
$lang['VG'] = 'Virgin Islands (British)';
$lang['VI'] = 'Virgin Islands (U.S.)';
$lang['WF'] = 'Wallis and Futuna Islands';
$lang['EH'] = 'Western Sahara';
$lang['YE'] = 'Yemen';
$lang['YU'] = 'Yugoslavia';
$lang['ZM'] = 'Zambia';
$lang['ZW'] = 'Zimbabwe';
$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['post_install'] = 'FormBuilder installert. Vennligst sjekk i modulens Hjelp-side for dokumentasjon.';
$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->helptext</td><td>the field&#039;s help text</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->alias</td><td>the alias specified for this field</td></tr>
<tr><td>field->id</td><td>the internal / opaque id FormBuilder uses for this field</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 the case of a multipage form, you will also have access to the value of previous fields. They
are in the $previous array, or accessible by their names (e.g., &amp;#123;$myfield->value} ).
You can use this in Static Text fields as well, which is a nice way to personalize forms!</p>

<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>in_formbrowser</td><td>1 if form is being viewed from FormBrowser</td></tr>
<tr><td>in_admin</td><td>1 if form is being viewed via FormBrowser admin</td></tr>
<tr><td>fbr_id</td><td>Response ID if form is being viewed from FormBrowser</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['utma'] = '156861353.1544975789.1389776642.1389776642.1389776642.1';
$lang['utmz'] = '156861353.1389776642.1.1.utmccn=(direct)|utmcsr=(direct)|utmcmd=(none)';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/nl_NL.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'FormBuilder';
$lang['field_type_DispositionEmailFromFEUProperty'] = '*E-mail gebruikers die matchen aan een FEU-eigenschap';
$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_HTML5NumberField'] = 'HTML5 Getal Invoer';
$lang['field_type_HTML5EmailField'] = 'HTML5 E-mail Invoer';
$lang['field_type_HTML5URLField'] = 'HTML5 URL Invoer';
$lang['field_type_SiteAdminField'] = 'Site beheerder';
$lang['field_type_PasswordField'] = 'Wachtwoord';
$lang['field_type_PasswordAgainField'] = 'Nogmaals wachtwoord (ter controle)';
$lang['field_type_TextFieldExpandable'] = 'Tekstinvoer (meerdere)';
$lang['field_type_TextAreaField'] = 'Tekstveld';
$lang['field_type_ButtonField'] = 'Toets';
$lang['field_type_CheckboxField'] = 'Selectievak';
$lang['field_type_CheckboxGroupField'] = 'Selectievak-groep';
$lang['field_type_PulldownField'] = 'Keuzelijst';
$lang['field_type_YearPullDownField'] = 'Jaar Pulldown';
$lang['field_type_MultiselectField'] = 'Meerkeuze';
$lang['field_type_StatePickerField'] = 'U.S. Staten-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-mailadres';
$lang['field_type_DispositionFromEmailAddressField'] = '*E-mail "Van Adres" Veld, verzend een kopie';
$lang['field_type_DispositionFile'] = '*Schrijf resultaten naar bestand';
$lang['field_type_DispositionUniqueFile'] = '*Schrijf resultaten naar een Unieke Plat Bestand voor iedere inzending';
$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 formulier resultaten';
$lang['field_type_DispositionForm'] = '*Verstuur naar een willekeurige formulieractie';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*E-mail naar het opgegeven e-mailadres';
$lang['field_type_DispositionEmailSiteAdmin'] = '*E-mail naar CMS Admin Gebruiker';
$lang['field_type_DispositionEmailBasedFrontendFields'] = '*E=mail resultaten gebaseerd op frontend velden';
$lang['field_type_PageBreakField'] = '- Paginascheiding';
$lang['field_type_FileUploadField'] = 'Bestand Upload';
$lang['field_type_FromEmailAddressField'] = '"Van Adres" e-mailveld';
$lang['field_type_FromEmailAddressAgainField'] = 'E-mail "Van Adres" Herhalingsveld';
$lang['field_type_FromEmailNameField'] = '"Van Naam" e-mailveld';
$lang['field_type_FromEmailSubjectField'] = '"Onderwerp" e-mailveld';
$lang['field_type_CCEmailAddressField'] = 'E-mail Carbon Copy (CC) adresveld';
$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['field_type_UserTagField'] = '- Aanroep Gebruikersgedefinieerde Tag (UDT)';
$lang['field_type_CompanyDirectoryField'] = 'Company Directory Veld';
$lang['field_type_ModuleInterfaceField'] = '- Module Interface Veld';
$lang['field_type_CheckboxExtendedField'] = 'Uitgebreide checkbox';
$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['validation_empty'] = 'Kan niet leeg zijn';
$lang['required'] = 'Vereist';
$lang['not_required'] = 'Niet vereist';
$lang['not_available'] = 'Niet beschikbaar';
$lang['error_emailfromfeuprop'] = 'Fout in veldinstellingen';
$lang['error_nofeu'] = 'De FrontEndUsers module kan niet worden gevonden. Dit veld zal niet functioneren.';
$lang['error_nofeudefns'] = 'Er kan geen bruikbare FEU-eigenschap worden gevonden. Dit veld zal niet functioneren.';
$lang['required_field_missing'] = 'Een waarde ontbreekt voor dit verplichte veld';
$lang['please_enter_a_value'] = 'Voer een waarde in voor "%s"';
$lang['please_enter_a_number'] = 'Voer een nummer in bij "%s"';
$lang['please_enter_valid'] = 'Voer een geldige waarde in bij "%s"';
$lang['please_enter_an_integer'] = 'Voer een getal in bij "%s"';
$lang['please_enter_an_email'] = 'Voer een geldig e-mailadres in bij "%s"';
$lang['email_address_does_not_match'] = 'E-mailadres komt niet overeen met de waarde %s"';
$lang['please_enter_a_phone'] = 'Voer een geldig telefoonnummer is voor "%s"';
$lang['please_login'] = 'Wilt u zich alstublieft aanmelden om dit formulier te gebruiken';
$lang['not_valid_email'] = '"%s" is geen geldig e-mailadres.';
$lang['please_enter_no_longer'] = 'Voer een waarde in die niet langer is dan %s tekens';
$lang['please_enter_at_least'] = 'Voer een waarde in, met minimaal %s karakters';
$lang['title_list_delimiter'] = 'Teken om te gebruiken als scheiding bij resultaten die meer dan één waarde teruggeven';
$lang['you_need_permission'] = 'Het "%s"-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'] = '"%s" moet geselecteerd zijn om door te kunnen gaan.';
$lang['must_specify_one_destination'] = 'Er moet tenminste éé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 "%s" 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['no_field_assigned'] = 'Geen veld toegewezen voor %s';
$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 één';
$lang['select_type'] = 'Selecteer Type';
$lang['to'] = 'Aan';
$lang['yes'] = 'Ja';
$lang['no'] = 'Nee';
$lang['recipients'] = 'ontvangers';
$lang['fields'] = 'velden';
$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'] = 'Geüpload bestand is te groot. De maximale grootte is:';
$lang['illegal_file_type'] = 'Dit type bestand mag niet worden geüpload. Controleer de bestandsextensie.';
$lang['upload'] = 'Upload';
$lang['form_imported'] = 'Formulier geïmporteerd.';
$lang['form_import_failed'] = 'Formulier import 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 bericht is ontvangen.';
$lang['edit'] = 'Bewerken';
$lang['delete'] = 'Verwijderen';
$lang['day'] = 'dag';
$lang['mon'] = 'maand';
$lang['year'] = 'jaar';
$lang['none'] = '(geen)';
$lang['css'] = 'Css';
$lang['uninstalled'] = 'Module gedeïnstaleerd.';
$lang['installed'] = 'Moduleversie %s geï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['tab_udt'] = 'UDT Integratie';
$lang['title_feu_property'] = 'FrontEndUsers Eigenschap';
$lang['info_feu_property'] = 'Alleen bepaalde typen eigenschappen kunnen worden gebruikt voor het zoeken naar overeenkomsten (dropdowns, multiselect velden, etc).';
$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 gemarkeerde 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'] = 'Er zijn te veel E-mails verzonden vanaf uw IP-adres. Anti-spam mechanisme blokkeert de verzending.';
$lang['suspected_spam_log'] = 'Verdachte spam van IP %s geblokkeerd.';
$lang['reorder'] = 'Herschik velden';
$lang['cancel'] = 'Annuleren';
$lang['value_set'] = 'Ingestelde waarde: %s';
$lang['title_cataloger_attribute_fields'] = 'Cataloger attributen veld';
$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: "range: minvalue to maxvalue"<br/>
<br/>
<strong>Verschillende waarden:</strong><br/>
Om een waarde te specificeren voor een atribuut, kun je de syntac "multi: value1|value2|value3" 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['title_textfield_label'] = 'Tekstveld label';
$lang['title_show_textfield'] = 'Tekstveld weergeven?';
$lang['help_name_regex'] = 'Een reguliere expressie om de cataloger items te sorteren op naam';
$lang['help_field_height'] = 'De hoogte van het multiselect veld';
$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 (UDT)';
$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_allow_overwrite'] = 'Toestaan om eerder geuploade bestanden te overschrijven?';
$lang['title_allow_overwrite_long'] = 'Moet het geüploade bestand eerder geüploade bestanden met dezelfde naam overschrijven?';
$lang['overwrite'] = 'Sta overschrijven toe';
$lang['nooverwrite'] = 'Niet overschrijven';
$lang['file_already_exists'] = 'Bestand %s bestaat al en kan niet overschreven worden.';
$lang['title_file_rename'] = 'Bestandsnaam sjabloon';
$lang['original_file_extension'] = 'Origineel bestand extensie (inclusief een punt!)';
$lang['title_suppress_filename'] = 'Onderdruk bestandsnaam in e-mails en formulieren die de eindgebruiker te zien krijgt';
$lang['title_suppress_attachment'] = 'Weiger dit bestand als bijlage van e-mails';
$lang['file_rename_help'] = 'Om het bestand te hernoemen tijdens het uploaden moet u hier een template aanmaken. Laat dit veld leeg als u de originele bestandsnaam wilt behouden.';
$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'] = '"Selecteer één" 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'] = '"Van Naam" voor e-mail';
$lang['title_relaxed_email_regex'] = 'Gebruik eenvoudige e-mailvalidatie';
$lang['title_relaxed_regex_long'] = 'Gebruik eenvoudige e-mailvalidatie (sta bijvoorbeeld "x@y" toe i.p.v. "x@y.tld")';
$lang['title_email_from_address'] = '"Van adres" voor e-mail';
$lang['title_email_encoding'] = 'E-mail karakterset encodering';
$lang['title_director_details'] = 'Keuzelijstgebaseerde e-maildetails';
$lang['title_file_name'] = 'Bestandsnaam';
$lang['title_email_subject'] = 'E-mail onderwerpregel';
$lang['title_form_name'] = 'Formuliernaam';
$lang['title_form_status'] = 'Formulierstatus';
$lang['title_ready_for_deployment'] = 'Gereed voor gebruik';
$lang['title_not_ready1'] = 'Niet gereed';
$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_field_alias_short'] = 'Alias';
$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ï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_button_text'] = 'Toets tekst';
$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 "Volgende" knoptekst (gebruikt bij formulieren van meerdere pagina\'s)';
$lang['title_form_prev_button'] = 'Formulier "Vorige" knoptekst (gebruikt bij formulieren van meerdere pagina\'s)';
$lang['title_field_validation'] = 'Veldvalidatie';
$lang['title_field_to_validate'] = 'Veld om te valideren';
$lang['title_field_css_id'] = 'CSS id voor dit veld';
$lang['title_form_css_class'] = 'CSS-klasse voor dit formulier';
$lang['title_field_css_class'] = 'CSS-klasse voor dit veld';
$lang['title_form_predisplay_udt'] = 'Een tag die wordt aangeroepen voordat het formulier zichtbaar wordt';
$lang['title_form_predisplay_each_udt'] = 'Een tag die wordt aangeroepen voordat het formulier wordt getoond (wordt aangeroepen op elke pagina van een multipage formulier)';
$lang['title_form_validate_udt'] = 'Aan te roepen tag tijdens formulier validatie';
$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_textarea_length'] = 'Maximale lengte van de veldinhoud (0 of leeg betekent geen limiet)';
$lang['title_text'] = 'Statische tekst om weer te geven';
$lang['title_field_regex'] = 'Validatie Regex';
$lang['title_lines_to_show'] = 'Aantal weergegeven regels';
$lang['title_read_only'] = 'Alleen lezen';
$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 "validatietype" ingesteld is op een regex-gerelateerde optie. Bevat een volledige Perl-achtige regex, inclusief de start/stop slashes en vlaggen (b.v., "/image\.(\d+)/i")';
$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'] = 'E-mailsjabloon';
$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_file_destination'] = 'Servermap om bestanden in op te slaan';
$lang['title_permitted_extensions'] = 'Toegestane extensies';
$lang['title_permitted_extensions_long'] = 'Voer een komma gescheiden lijst in, zonder de punt (b.v., "jpg,gif,jpeg"). 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 e-mails toestaan vanuit een gegevens IP-adres (per uur).';
$lang['title_enable_antispam'] = 'Primitieve anti-spam functionaliteit inschakelen?';
$lang['title_show_fieldids'] = 'Toon veld-id\'s';
$lang['title_show_fieldids_long'] = 'Dit aanklikken maakt het tonen van veld-id\'s mogelijk tijdens toevoegen en wijzigen van een formulier';
$lang['title_xml_to_upload'] = 'Upload formulier vanuit 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 e-mail?';
$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'] = 'Standaard link URL';
$lang['title_default_link_title'] = 'Standaard link tekst';
$lang['title_link_to_sitepage'] = 'Link naar de sitepagina';
$lang['title_captcha_not_installed'] = 'U kunt gebruik maken van <a href="http://nl.wikipedia.org/wiki/Captcha" target="_new">"Captcha"</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://nl.wikipedia.org/wiki/Captcha" target="_new">"Captcha"</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_default_blank'] = 'Standaard naar leeg';
$lang['title_default_blank_help'] = 'Standaard naar leeg (Vinkje weghalen om standaard de huidige datum te krijgen)';
$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['title_encrypt_database_data'] = 'Encrypt data opgeslagen in database';
$lang['title_crypt_cert'] = 'Certificaat voor data encryptie';
$lang['title_encryption_keyfile'] = 'Key Bestand voor encryptie';
$lang['title_encrypt_sortfields'] = 'Hash voor sorteervelden?';
$lang['title_private_key'] = 'Geheime sleutel voor data encryptie';
$lang['title_encrypt_sortfields_help'] = 'Dit zorgt voor een hash voor sorteervelden, maar laat de eerste paar letters onbeveiligd. Dit zorgt voor een kwetsbaarheid, maar voor de meeste gebruikers is een acceptabele afweging tussen beveiliging en de mogelijkheid om records te sorteren. De sortering is bij benadering, maar werkt behoorlijk goed. Wanneer u deze optie niet gebruikt, dan zullen de velden als platte tekst worden opgeslagen.';
$lang['title_encryption_functions'] = 'Beveiligde dataopslag niet beschikbaar';
$lang['title_install_crypto'] = 'Installeer de OpenSSL module of mcrypt support als u de database encryptie wilt inschakelen.';
$lang['title_install_curl'] = 'Alstublieft controleer of u CURL support actief is in uw PHP installatie. Lees http://www.php.net/manual/en/book.curl.php';
$lang['title_mle_version'] = 'Uitvoeren in de MLE Modus';
$lang['title_mle_version_long'] = 'Wijzig/support voor CMSMS Multi-Language Editie. Gebruik deze optie niet in de gangbare cmsms versie.';
$lang['title_ensure_cert_key_match'] = 'Zorg ervoor dat uw geheime sleutel geschikt is voor het certificaat dat u gebruikt voor encryptie!';
$lang['choose_crypt'] = 'Encryptie Bibliotheek';
$lang['title_encrypt_database_long'] = 'Vink dit aan als u de opgeslagen data wilt encrypten. Dit maakt het moeilijker (maar niet onmogelijk) voor hackers om de informatie te bekijken.';
$lang['choose_crypt_long'] = 'De onderstaande opties zijn alleen van toepassing als u OpenSSL Encryptie Bibliotheek gebruikt';
$lang['title_crypt_lib'] = 'Encryptie Bibliotheek';
$lang['openssl'] = 'OpenSSL Bibliotheek';
$lang['mcrypt'] = 'PHP mcrypt Bibliotheek';
$lang['title_feu_binding'] = 'Frontend User verbinding';
$lang['title_install_feu'] = 'Installeer de FrontEndUser module om het formulier, met bijbehorende data te verbinden met een specifieke gebruiker';
$lang['title_feu_bind_help'] = 'Vink dit aan om front-end toegang te koppelen aan de data van de aangemelde front-end gebruiker.';
$lang['title_encryption'] = 'Encryptie';
$lang['title_export_form_to_udt'] = 'Exporteer formulier referentie naar een UDT als $params[\'FORM\']?';
$lang['title_url_help'] = 'Gehele URL, inclusief protocol en pad (e.g., http://myhost.com/form_handler.cgi)';
$lang['title_url'] = 'Formulier verzend url';
$lang['title_method'] = 'Formulier methode';
$lang['title_maps_to'] = 'Map field "%s" to form submission variable';
$lang['title_additional'] = 'Bijkomende aanvraag';
$lang['title_additional_help'] = 'Anything to be appended to the submission payload, in URL-encoded form (.e.g, "user=steve+jobs&employee_number=1)';
$lang['title_include_in_submission'] = 'Gebruik veld tijdens het versturen';
$lang['title_date_order'] = 'Datumcomponent volgorde (voor invoer)';
$lang['title_data_stored_in_fbr'] = 'Data wordt opgeslagen in een XML format in de [PREFIX]_module_fb_frombrowser database tabel.';
$lang['error_has_no_fb_field'] = 'Fout! Op het formulier is geen koppeling gemaakt met de module Form Browser of er is een probleem opgetreden bij het verbinden met deze module (bijvoorbeeld door geheugenproblemen)';
$lang['help_date_order'] = 'Use "m" for Month, "d" for Day, and "y" for Year. Separate the items by hyphens.';
$lang['restricted_to_group'] = 'Alleen in groep %s';
$lang['title_show_to_user'] = 'Toon aan gebruiker?';
$lang['title_use_random_generator'] = 'Gebruik willekeurige nummers in plaats van statische';
$lang['title_numbers_to_generate'] = 'Hoeveel nummer generegen in een proces';
$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_ignored_if_upload'] = '(Dit veld wordt genegeerd als je de Upload module gebruikt om bestanden te beheren)';
$lang['help_other_fields'] = 'Andere velden zijn beschikbaar nadat ze zijn toegevoegd';
$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'] = 'Bekijk <a href="http://www.php.net/manual/en/function.date.php" target=_NEW>de PHP handleiding</a> voor informatie over het format.';
$lang['help_variable_name'] = 'Variabele';
$lang['help_form_field'] = 'Gerepresenteerd Veld';
$lang['help_rtf_file_template'] = 'Specificeer een bestand dat is geplaatst in de Formbuilder/templates/-map. Dit veld zal worden genegeerd wanneer u een txt-bestand als bestandstype gebruikt.';
$lang['help_rtf_template_type'] = 'Basic: Use the textarea below to layout the field names/values in a single block.<br />
Advanced: Specify Smarty variables in the RTF Template File as you would below, but arrange them however you like and add formatting.<br />
&nbsp;You can still use the %%HEADER%% and %%FOOTER%% sections in the RTF file.';
$lang['help_unique_file_template'] = 'For TXT, this will be immediately after the Header Template.<br />
For RTF, this will replace the %%FIELDS%% string in the template file if RTF Template Type is set to "Basic".<br />
This field will be ignored if using "RTF" as File Type and "Advanced" as RTF Template Type.';
$lang['help_file_header_template'] = 'Voor TXT zal dit worden geplaatst aan de bovenkant van het bestand. Voor RTF zal dit de %%HEADER%%-string in de template vervangen.';
$lang['help_file_footer_template'] = 'Voor TXT zal dit worden geplaatst aan de onderkant van het bestand. Voor RTF zal dit de %%FOOTER%%-string in de template vervangen.';
$lang['link_back_to_form'] = '« Terug naar het formulier';
$lang['title_create_sample_template'] = 'Voorbeeldsjabloon genereren';
$lang['title_create_sample_html_template'] = 'Creëer voorbeeld HTML sjabloon';
$lang['title_create_sample_header_template'] = 'Creëer een voorbeeld Header sjabloon';
$lang['title_create_sample_footer_template'] = 'Creëer een voorbeeld Footer sjabloon';
$lang['title_create_sample_header'] = 'Voorbeeldkopregel genereren';
$lang['help_tab_symbol'] = 'een tab-teken';
$lang['title_file_template'] = 'Sjabloon voor een enkele regel van de uitgaande mail';
$lang['title_file_header'] = 'Sjabloon voor de kopregel van de uitgaande mail';
$lang['title_file_footer'] = 'Sjabloon voor de footer van de uitgaande mail';
$lang['title_rtf_file_template'] = 'Sjabloon RTF-bestand om te gebruiken';
$lang['title_unique_file_template'] = 'Sjabloon voor output';
$lang['title_file_type'] = 'Kies een bestandstype om te gebruiken';
$lang['title_rtf_template_type'] = 'Kies een RTF-sjabloon type';
$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'] = 'Datum formaat (standaard <a href="http://www.php.net/manual/en/function.date.php">PHP-datumformaten</a>)';
$lang['title_use_wysiwyg'] = 'Gebruik WYSIWYG editor voor tekstveld (alleen voor admin)?';
$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 "Disposition" 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['title_submit_date'] = 'Verzenddatum';
$lang['title_approval_date'] = 'Datum geaccordeerd (door admin)';
$lang['title_user_approved'] = 'Datum geaccordeerd (door verzender)';
$lang['display_text'] = 'Toon "Verzendsjabloon"';
$lang['redirect_to_page'] = 'Verwijs door naar webpagina';
$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 e-mails of andere formulierregels -- die kunt u instellen in sjablonen (indien van toepassing) in het "geavanceerd" 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_field_helptext'] = 'Help-tekst om te tonen bij dit veld';
$lang['title_string_or_number_eval'] = 'Interpreteer variabelen als nummers of strings';
$lang['title_order'] = 'Interpretatie volgorde';
$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_string_unspaced'] = 'String (geen spaties tussen de velden)?';
$lang['title_compute_value'] = 'Waarde om te berekenen';
$lang['title_compute'] = 'Berekend/PHP';
$lang['title_string'] = 'String';
$lang['title_numeric'] = 'Numeriek';
$lang['title_inline_form'] = 'Toon het formulier inline?';
$lang['title_inline_form_help'] = 'Inline betekent dat ieder formuliervervolgactie de {cms_module} tag  in de pagina vervangt, non-inline vervangt de gehele {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 geüploade 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="yourfn()"';
$lang['title_submit_javascript'] = 'Formulier indienen 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'] = 'Kies hier niet zomaar een willekeurig mail adres -- veel ISPs zullen<br />gegenereerde mailtjes niet afleveren bij een mailadres die niet dezelfde is als het eigen domeinnaam<br />(bijv. gebruik iets zoals naam@%s)';
$lang['title_switch_advanced'] = 'Meer veldtypes nodig?';
$lang['title_switch_basic'] = 'Teveel verwarrende 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'] = 'Dit moet een map zijn op uw webserver met schrijfrechten.<br />Chmod het naar 777 als u problemen of twijfels heeft.<br />Controleer ook of er geen sprake is van \'PHP directory restricties\'.';
$lang['title_newline_replacement'] = 'Nieuwe regel vervangingskarakter';
$lang['title_newline_replacement_help'] = 'Leeg laten om \'nieuwe regel\' toe te staan';
$lang['title_send_usercopy'] = 'Verzend gebruiker een kopie';
$lang['title_send_usercopy_label'] = 'Label voor het vinkvakje (keuze voor de gebruiker)';
$lang['title_send_me_a_copy'] = 'Verzend mij een kopie van het form';
$lang['title_allow_subject_override'] = 'Toestaan dat het Onderwerp wordt overschreven?';
$lang['title_allow_subject_override_long'] = 'Sta toe dat het veld \'E-mail Onderwerp\' wordt overschreven door het onderwerp gespecificeerd in de pulldown.';
$lang['title_display_length'] = 'Scherm lengte';
$lang['title_minimum_length'] = 'Minimale reactie lengte';
$lang['title_hide'] = 'Verberg input';
$lang['title_hide_help'] = 'Laat symbolen zien als een gebruiker zijn wachtwoord invoerd, in plaats van de daadwerkellijke tekst.';
$lang['password_does_not_match'] = 'Wachtwoord voldoet niet aan %s';
$lang['back_top'] = 'Terug naar FormBuilder Start Pagina';
$lang['title_headers_to_modify'] = 'Welke e-mail headers moet deze input bevatten?';
$lang['title_blank_invalid'] = 'Sta geen lege reacties (spaties) toe.';
$lang['title_blank_invalid_long'] = 'Als een veld verplicht is, dan zal het aanvinken van dit vakje mensen verplichten alfanumerieke karakters in te vullen, niet alleen spaties';
$lang['title_must_save_order'] = 'You must click one of the "save" buttons to make your new field order permanent.';
$lang['title_html5'] = 'Gebruik HTML5 placeholder tekst in plaats van Javascript';
$lang['title_email_cc_address'] = 'Adres om naar toe te mailen als Carbon copy (CC)';
$lang['title_use_bcc'] = 'Gebruik Blind carbon copy (BCC in plaats van CC)';
$lang['title_send_using'] = 'E-mailadressering';
$lang['title_field_to_modify'] = 'E-mailveld om CC adres toe te voegen';
$lang['title_modifies'] = 'Voeg CC toe aan "%s"';
$lang['bcc_field'] = '"BCC" ontvangers';
$lang['cc_field'] = '"CC" ontvangers';
$lang['to_field'] = 'Normaal ("Aan" ontvangers)';
$lang['bcc'] = 'BCC';
$lang['cc'] = 'CC';
$lang['error_CompanyDirectory_module_not_available'] = 'De Company Directory module is niet aanwezig!';
$lang['option_never'] = 'Nooit';
$lang['option_user_choice'] = 'Keuze van gebruiker (vinkvakje)';
$lang['option_always'] = 'Altijd';
$lang['option_from'] = '"Van" e-mail adres';
$lang['option_reply'] = '"Beantwoord naar" e-mail adres';
$lang['option_both'] = 'Zowel "Van" als "Beantwoord naar" e-mail adressen';
$lang['option_dropdown'] = 'Dropdown';
$lang['option_selectlist_single'] = 'Selectie Lijst (enkelvoudig)';
$lang['option_selectlist_multiple'] = 'Selectie Lijst (meervoudig)';
$lang['option_radiogroup'] = 'Radio Groep';
$lang['title_company_field_note'] = 'Note: Output will be in the form of<br/>"company name"=>"value"';
$lang['title_pick_categories'] = 'Kies een categorie (meerdere)';
$lang['title_pick_fielddef'] = 'Pull a field Definition\'s value (single) <em>optional</em>';
$lang['title_choose_user_input'] = 'Kies Gebruikers Invoer';
$lang['title_see_also_udt'] = '(Kijk ook even onder de Formulierverzending tab als u een UDT wilt gebruiken voor de formulier validatie)';
$lang['title_year_end_message'] = 'Eindjaar';
$lang['title_field_logic'] = 'Smarty gegevens of logica die is bedoeld om te worden verzonden met dit veld.';
$lang['title_field_logic_long'] = 'Can be smarty data, javascript, or some other data you wan\'t to sent along with this field.<br />Goes through the Smarty compiler, so remember use {literal}{/literal} tags with <script></script>';
$lang['title_field_includelabels'] = 'Voeg labels toe';
$lang['title_field_includelabels_help'] = 'Als u dit inschakelt zullen er labels worden toegevoegd aan de output. Bijvoorbeeld: - label: waarde, label2: waarde2';
$lang['title_field_siblings'] = 'Koppel dit veld aan het bovenliggende';
$lang['title_field_siblings_help'] = 'Dropdownlijsten met alle bovenliggende elementen van dit veld kunnen gekoppeld worden aan een onderliggend element. Dit maakt het mogelijk om deze velden te controleren.';
$lang['title_field_hidebuttons'] = 'Verberg controleknoppen';
$lang['title_field_hidebuttons_help'] = 'Verberg frontend controle knoppen op dit veld.';
$lang['title_note'] = 'Opmerking';
$lang['title_changing_triggers_reindex'] = 'Als u een van de bovenstaande velden wijzigt, dan zal dit leiden tot een heropbouw van *alle* opgeslagen bestanden. Dit kan dus enkele ogenblikken duren.';
$lang['illegal_file'] = 'Geprobeerd om een ongeldig bestandstype te uploaden (%s) van %s';
$lang['title_searchable'] = 'Maak records beschikbaar voor de Zoek Module';
$lang['title_searchable_help'] = 'Als u dit aanvinkt dan zal alle data toegankelijk worden voor de Zoek Module. Gebruik dit NIET als u gebruik maakt van versleutelde gegevens -- de informatie zal dan beschikbaar worden gesteld voor zoekopdrachten en deze zijn niet versleuteld!';
$lang['uploaded_outside_webroot'] = '%s (buiten webroot)';
$lang['title_fbr_edit'] = 'Aan te passen in de FormBrowser Admin?';
$lang['title_active_only'] = 'Alleen actieve gebruikers koppelen?';
$lang['error_usertag_disposition'] = 'Uit te voeren User Defined Tag na een fout';
$lang['error_usertag'] = 'Gebruikersgedefinieerde tag %s geeft een fout aan.';
$lang['error_cataloger_module_not_available'] = '<strong>De Cataloger module is niet geï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?<br />(Zelfs als u OK aangeeft, zult u de veranderingen eerst moeten opslaan)';
$lang['title_bad_function'] = 'Fout bij het berekenen van "%s".';
$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 webformulieren';
$lang['must_specify_one_admin'] = 'U moet een beheerder opgeven';
$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['help_module_interface'] = 'Gebruik Module Interface';
$lang['help_module_interface_long'] = '<b>This field is used as a gateway to other modules!</b> 
Use it by creating your form elements in the templates of the other module(s) you wish to incorporate, and using the <strong>{$FBid}</strong> to tie it back to FormBuilder. For example, to include form options based on the Products module, create the following template in Products:<br/>
<pre>
{foreach from=$items item=entry}
	{assign var=MData value=\'\'}
	{assign var=Cd value=\'\'}
		{foreach from=$FBvalue item=MData}
			{assign var=MData value=\'::\'|explode:$MData}
			{if $MData[1]==$entry->id}
				{assign var=Cd value=\' checked="checked"\'}
			{/if}
		{/foreach}
	<div class="ProductDirectoryItem">
		<input type="checkbox" value="{$entry->price}::{$entry->id}" name="{$FBid}[]" {$Cd} />{$entry->product_name} ({$entry->weight}{$weight_units}) £{$entry->price}    
	</div>
{/foreach}
</pre>
<br/>
where in the input below you put something like <strong>{Products category="cat" summarytemplate="Your_FB_template"}</strong>';
$lang['title_add_tag'] = 'Uw tag toevoegen';
$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['AD'] = 'Andorra';
$lang['AE'] = 'Verenigde Emiraten';
$lang['AF'] = 'Afghanistan';
$lang['AG'] = 'Antigua en Barbuda';
$lang['AI'] = 'Anguilla';
$lang['AL'] = 'Albanië';
$lang['AM'] = 'Armenië';
$lang['AN'] = 'Netherlandse Antillen';
$lang['AO'] = 'Angola';
$lang['AQ'] = 'Antarctica';
$lang['AR'] = 'Argentinië';
$lang['AS'] = 'Anguilla';
$lang['AT'] = 'Oostenrijk';
$lang['AU'] = 'Australië';
$lang['AW'] = 'Aruba';
$lang['AX'] = 'Åland-eilanden';
$lang['AZ'] = 'Azerbeidzjan';
$lang['BA'] = 'Bosnië en Herzegovina';
$lang['BB'] = 'Barbados';
$lang['BD'] = 'Bangladesh';
$lang['BE'] = 'België';
$lang['BF'] = 'Burkina Faso';
$lang['BG'] = 'Bulgarije';
$lang['BH'] = 'Bahrein';
$lang['BI'] = 'Burundi';
$lang['BJ'] = 'Benin';
$lang['BM'] = 'Bermuda';
$lang['BN'] = 'Brunei Darussalam';
$lang['BO'] = 'Bolivia';
$lang['BR'] = 'Brazilië';
$lang['BS'] = 'Bahama\'s';
$lang['BT'] = 'Bhutan';
$lang['BV'] = 'Bouvet';
$lang['BW'] = 'Botswana';
$lang['BY'] = 'Wit-Rusland';
$lang['BZ'] = 'Belize';
$lang['CA'] = 'Canada';
$lang['CC'] = 'Cocos (Keeling) Eilanden';
$lang['CD'] = 'Congo, Democratische Republiek';
$lang['CF'] = 'Centraal Afrikaanse Republiek';
$lang['CG'] = 'Congo';
$lang['CH'] = 'Zwitserland';
$lang['CI'] = 'Ivoorkust';
$lang['CK'] = 'Cook Eilanden';
$lang['CL'] = 'Chili';
$lang['CM'] = 'Kameroen';
$lang['CN'] = 'China';
$lang['CO'] = 'Colombia';
$lang['CR'] = 'Costa Rica';
$lang['CU'] = 'Cuba';
$lang['CV'] = 'Kaapverdische eilanden';
$lang['CX'] = 'Christmaseiland';
$lang['CY'] = 'Cyprus';
$lang['CZ'] = 'Tsjechië';
$lang['DE'] = 'Duitsland';
$lang['DJ'] = 'Djibouti';
$lang['DK'] = 'Denemarken';
$lang['DM'] = 'Dominica';
$lang['DO'] = 'Dominicaanse Republiek';
$lang['DZ'] = 'Algarije';
$lang['EC'] = 'Ecuador';
$lang['EE'] = 'Estland';
$lang['EG'] = 'Egypte';
$lang['EH'] = 'Westerse Sahara';
$lang['ER'] = 'Eritrea';
$lang['ES'] = 'Spanje';
$lang['ET'] = 'Ethiopië';
$lang['FI'] = 'Finland';
$lang['FJ'] = 'Fiji';
$lang['FK'] = 'Falkland Eilanden (Maladieven)';
$lang['FM'] = 'Micronesia';
$lang['FO'] = 'Faroe Islands';
$lang['FR'] = 'Frankrijk';
$lang['FX'] = 'Frankrijk, metropool';
$lang['GA'] = 'Gabon';
$lang['GB'] = 'Groot-Britannië';
$lang['GD'] = 'Grenada';
$lang['GE'] = 'Georgië';
$lang['GF'] = 'Guernsey';
$lang['GH'] = 'Ghana';
$lang['GI'] = 'Gibraltar';
$lang['GL'] = 'Groenland';
$lang['GM'] = 'Gambia';
$lang['GN'] = 'Guinea';
$lang['GP'] = 'Guadeloupe';
$lang['GQ'] = 'Equatorial Guinea';
$lang['GR'] = 'Griekenland';
$lang['GS'] = 'S. Georgia en S. Sandwich Eilanden';
$lang['GT'] = 'Guatemala';
$lang['GU'] = 'Guam';
$lang['GW'] = 'Guinea-Bissau';
$lang['GY'] = 'Guyana';
$lang['HK'] = 'Hong Kong';
$lang['HM'] = 'Heard and McDonald Eilanden';
$lang['HN'] = 'Honduras';
$lang['HR'] = 'Croatië';
$lang['HT'] = 'Haïti';
$lang['HU'] = 'Hongarije';
$lang['ID'] = 'Indonesië';
$lang['IE'] = 'Ierland';
$lang['IL'] = 'Isra';
$lang['IM'] = 'Isle of Man';
$lang['IN'] = 'India';
$lang['IO'] = 'Brits-Indische Oceanisch terretorium';
$lang['IQ'] = 'Irak';
$lang['IR'] = 'Iran';
$lang['IS'] = 'Ijsland';
$lang['IT'] = 'Italië';
$lang['JE'] = 'Jersey';
$lang['JM'] = 'Jamaica';
$lang['JO'] = 'Jordanië';
$lang['JP'] = 'Japan';
$lang['KE'] = 'Kenia';
$lang['KG'] = 'Kyrgyzstan';
$lang['KH'] = 'Cambodja';
$lang['KI'] = 'Kiribati';
$lang['KM'] = 'Comoros';
$lang['KN'] = 'Sint Kitts en Nevis';
$lang['KP'] = 'Noord-Korea';
$lang['KR'] = 'Zuid-Korea';
$lang['KW'] = 'Koeweit';
$lang['KY'] = 'Cayman eilanden';
$lang['KZ'] = 'Kazachstan';
$lang['LA'] = 'Laos';
$lang['LB'] = 'Libanon';
$lang['LC'] = 'Sint Lucia';
$lang['LI'] = 'Liechtenstein';
$lang['LK'] = 'Sri Lanka';
$lang['LR'] = 'Liberië';
$lang['LS'] = 'Lesotho';
$lang['LT'] = 'Lithuania';
$lang['LU'] = 'Luxemburg';
$lang['LV'] = 'Letland';
$lang['LY'] = 'Libië';
$lang['MA'] = 'Marokko';
$lang['MC'] = 'Monaco';
$lang['MD'] = 'Moldavie';
$lang['MG'] = 'Madagascar';
$lang['MH'] = 'Marshall Eilanden';
$lang['MK'] = 'F.Y.R.O.M. (Macedonia)';
$lang['ML'] = 'Mali';
$lang['MM'] = 'Myanmar';
$lang['MN'] = 'Mongolie';
$lang['MO'] = 'Macau';
$lang['MP'] = 'Noordse Mariana Eilanden';
$lang['MQ'] = 'Martinique';
$lang['MR'] = 'Mauritanië';
$lang['MS'] = 'Montserrat';
$lang['MT'] = 'Malta';
$lang['MU'] = 'Mauritanië';
$lang['MV'] = 'Malediven';
$lang['MW'] = 'Malawi';
$lang['MX'] = 'Mexico';
$lang['MY'] = 'Maleisië';
$lang['MZ'] = 'Mozambique';
$lang['NA'] = 'Namibie';
$lang['NC'] = 'Nieuw Caledonia';
$lang['NE'] = 'Niger';
$lang['NF'] = 'Norfolk Eiland';
$lang['NG'] = 'Nigeria';
$lang['NI'] = 'Nicaragua';
$lang['NL'] = 'Nederland';
$lang['NO'] = 'Noorwegen';
$lang['NP'] = 'Nepal';
$lang['NR'] = 'Nauru';
$lang['NT'] = 'Neutraal gebied';
$lang['NU'] = 'Niue';
$lang['NZ'] = 'Nieuw-Zeeland (Aotearoa)';
$lang['OM'] = 'Oman';
$lang['PA'] = 'Panama';
$lang['PE'] = 'Peru';
$lang['PF'] = 'Frans Polonesië';
$lang['PG'] = 'Papua Nieuw-Guinea';
$lang['PH'] = 'Filipijnen';
$lang['PK'] = 'Pakistan';
$lang['PL'] = 'Polen';
$lang['PM'] = 'St. Pierre en Miquelon';
$lang['PN'] = 'Pitcairn';
$lang['PR'] = 'Puerto Rico';
$lang['PS'] = 'Palestijnse terretoria';
$lang['PT'] = 'Portugal';
$lang['PW'] = 'Palau';
$lang['PY'] = 'Paraguay';
$lang['QA'] = 'Qatar';
$lang['RE'] = 'Réunion';
$lang['RO'] = 'Roemenië';
$lang['RU'] = 'Rusland';
$lang['RW'] = 'Rwanda';
$lang['SA'] = 'Saoedi-Arabië';
$lang['SB'] = 'Solomon Eilanden';
$lang['SC'] = 'Seychellen';
$lang['SD'] = 'Sudan';
$lang['SE'] = 'Zweden';
$lang['SG'] = 'Singapore';
$lang['SH'] = 'St. Helena';
$lang['SI'] = 'Slovenië';
$lang['SJ'] = 'Svalbard & Jan Mayen Eilanden';
$lang['SK'] = 'Slovaakse republiek';
$lang['SL'] = 'Sierra Leone';
$lang['SM'] = 'San Marino';
$lang['SN'] = 'Senegal';
$lang['SO'] = 'Somalië';
$lang['SR'] = 'Suriname';
$lang['ST'] = 'Sao Tome en Principe';
$lang['SV'] = 'El Salvador';
$lang['SY'] = 'Sirië';
$lang['SZ'] = 'Swaziland';
$lang['TC'] = 'Turkse and Caicose Eilanden';
$lang['TD'] = 'Chad';
$lang['TF'] = 'Franse Zuidgelegen terretoria';
$lang['TG'] = 'Togo';
$lang['TH'] = 'Thailand';
$lang['TJ'] = 'Tajikistan';
$lang['TK'] = 'Tokelau';
$lang['TM'] = 'Turkmenistan';
$lang['TN'] = 'Tunesië';
$lang['TO'] = 'Tonga';
$lang['TP'] = 'Oost-Timor';
$lang['TR'] = 'Turkije';
$lang['TT'] = 'Trinidad en Tobago';
$lang['TV'] = 'Tuvalu';
$lang['TW'] = 'Taiwan';
$lang['TZ'] = 'Tanzania';
$lang['UA'] = 'Oekraïne';
$lang['UG'] = 'Uganda';
$lang['UK'] = 'Verenigd Koninkrijk';
$lang['UM'] = 'Kleine afgelegen eilanden van de Verenigde Staten';
$lang['US'] = 'Verenigde Staten';
$lang['UY'] = 'Uruguay';
$lang['UZ'] = 'Uzbekistan';
$lang['VA'] = 'Vaticaanstad';
$lang['VC'] = 'SintVincent & de Grenadines';
$lang['VE'] = 'Venezuela';
$lang['VG'] = 'Maagdeneilanden (Brits)';
$lang['VI'] = 'Maagdeneilanden (VS)';
$lang['VN'] = 'Vietnam';
$lang['VU'] = 'Vanuatu';
$lang['WF'] = 'Wallis en Futuna Eilanden';
$lang['WS'] = 'Samoa';
$lang['YE'] = 'Jemen';
$lang['YT'] = 'Mayotte';
$lang['YU'] = 'Joegoeslavië';
$lang['ZA'] = 'Zuid-Africa';
$lang['ZM'] = 'Zambia';
$lang['ZW'] = 'Zimbabwe';
$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 />E-mailsjabloon nog niet ingesteld!';
$lang['missing_cms_mailer'] = 'Form Builder: Kan de vereiste CMSMailer module niet vinden!';
$lang['user_approved_submission'] = 'Gebruiker goedgekeurde verzending %s van %s';
$lang['event_info_OnFormBuilderFormSubmit'] = 'Een tag die wordt aangeroepen als een Form Builder-formulier verzonden wordt';
$lang['event_info_OnFormBuilderFormSubmitError'] = 'Een tag die wordt aangeroepen als een fout optreedt bij het verzenden van een Form Builder-formulier';
$lang['event_info_OnFormBuilderFormDisplay'] = 'Een tag die wordt aangeroepen als een Form Builder-formulier wordt getoond';
$lang['event_help_OnFormBuilderFormSubmit'] = '<p>Een gebeurtenis die wordt aangeroepen 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>
<li><em>value_<name></em> - Supply a default value to a field with the specified name.</li>
</ul>';
$lang['event_help_OnFormBuilderFormSubmitError'] = '<p>Een gebeurtenis die wordt aangeroepen 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>Een gebeurtenis die wordt aangeroepen 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>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>Variable</th><th>Value</th></tr>
<tr><td>$entry->display</td><td>1 if the field should be displayed, 0 otherwise</td></tr>
<tr><td>$entry->required</td><td>1 if the field is required, 0 otherwise</td></tr>
<tr><td>$entry->required_symbol</td><td>the symbol for required fields</td></tr>
<tr><td>$entry->css_class</td><td>the CSS class specified for this field</td></tr>
<tr><td>$entry->valid</td><td>1 if this field has passed validation, 0 otherwise</td></tr>
<tr><td>$entry->error</td><td>Text of the validation problem, in the event that this field did not validate</td></tr>
<tr><td>$entry->hide_name</td><td>1 if the field name should be hidden, 0 otherwise</td></tr>
<tr><td>$entry->has_label</td><td>1 if the field type has a label</td></tr>
<tr><td>$entry->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>$entry->name</td><td>the field\'s name</td></tr>
<tr><td>$entry->helptext</td><td>the field\'s help text</td></tr>
<tr><td>$entry->input</td><td>the field\'s input control (e.g., the input field itself)</td></tr>
<tr><td>$entry->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>$entry->input_id</td><td>the ID of the field\'s input (useful for label for="foo")</td></tr>
<tr><td>$entry->alias</td><td>the alias specified for this field</td></tr>
<tr><td>$entry->id</td><td>the internal / opaque id FormBuilder uses for this field</td></tr>
<tr><td>$entry->type</td><td>the field\'s data type</td></tr>                             
<tr><td>$entry->multiple_parts</td><td>1 if the field->input is actually a collection of controls</td></tr>
<tr><td>$entry->label_parts</td><td>1 if the collection of controls has separate labels for each control</td></tr>
</table>

<p>In the case of a multipage form, you will also have access to the value of previous fields. They
are in the $previous array, or accessible by their names (e.g., {$myfield->value} ).
You can use this in Static Text fields as well, which is a nice way to personalize forms!</p>

<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>$in_formbrowser</td><td>1 if form is being viewed from FormBrowser</td></tr>
<tr><td>$in_admin</td><td>1 if form is being viewed via FormBrowser admin</td></tr>
<tr><td>$fbr_id</td><td>Response ID if form is being viewed from FormBrowser</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>';
$lang['post_install'] = 'De module FormBuilder is geïnstalleerd. Raadpleeg de Help pagina voor meer informatie!';
$lang['opt_month_input_text'] = 'Tekst';
$lang['opt_month_input_number'] = 'Nummer';
$lang['opt_month_input_both'] = 'Beiden';
$lang['title_default_time'] = 'Standaard tijd';
$lang['title_minute_interval'] = 'Minuten interval';
?>]]></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_HTML5NumberField'] = 'HTML5 Number Input';
$lang['field_type_HTML5EmailField'] = 'HTML5 Email Input';
$lang['field_type_HTML5URLField'] = 'HTML5 URL Input';
$lang['field_type_PasswordField'] = 'Hasło';
$lang['field_type_PasswordAgainField'] = 'Hasło (weryfikacja)';
$lang['field_type_TextFieldExpandable'] = 'Pole tekstowego wprowadzania (wielokrotne)';
$lang['field_type_TextAreaField'] = 'Pole tekstowe (text area)';
$lang['field_type_ButtonField'] = 'Przycisk';
$lang['field_type_CheckboxField'] = 'Checkbox';
$lang['field_type_CheckboxGroupField'] = 'Grupa checkbox&oacute;w';
$lang['field_type_PulldownField'] = 'Lista rozwijalna';
$lang['field_type_YearPullDownField'] = 'Wyb&oacute;r roku';
$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 wielokrotnego 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_DispositionFromEmailAddressField'] = '*Email &quot;From Address&quot; Field, and send copy';
$lang['field_type_DispositionFile'] = '*Zapisz wyniki do zwykłego pliku';
$lang['field_type_DispositionUniqueFile'] = '*Write Results to a Unique Flat File for each submission';
$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_DispositionForm'] = '*Submit to an arbitrary form action';
$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_FromEmailAddressAgainField'] = 'Email &quot;From Address&quot; Again Field';
$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['field_type_UserTagField'] = '-User Defined Tag Call';
$lang['field_type_CompanyDirectoryField'] = 'Company Directory Field';
$lang['field_type_ModuleInterfaceField'] = '-Module Interface Field';
$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['email_address_does_not_match'] = 'Email address does not match value in &quot;%s&quot;';
$lang['please_enter_a_phone'] = 'Wprowadź poprawny numer telefonicznych w polu &quot;%s&quot;';
$lang['please_login'] = 'Please log in to use this form';
$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['please_enter_at_least'] = 'Please enter a value that is at least %s characters';
$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['no_field_assigned'] = 'No field assigned for %s';
$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['fields'] = 'fields';
$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['css'] = 'CSS';
$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['tab_udt'] = 'UDT Integration';
$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_allow_overwrite'] = 'Allow upload to overwrite previously files?';
$lang['title_allow_overwrite_long'] = 'Should uploaded file overwrite previously uploaded file if it has the same name?';
$lang['overwrite'] = 'Allows Overwriting';
$lang['nooverwrite'] = 'No Overwrite';
$lang['file_already_exists'] = 'File %s already exists, and cannot be overwritten.';
$lang['title_file_rename'] = 'Filename template';
$lang['original_file_extension'] = 'Original file extension (includes the &quot;.&quot;)';
$lang['title_suppress_filename'] = 'Suppress filename in emails and forms the end user will see';
$lang['file_rename_help'] = 'To rename a file upon uploading, create the template here. Leave blank to preserve original filename';
$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_field_alias_short'] = 'Alias';
$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_button_text'] = 'Tekst przycisku';
$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_field_to_validate'] = 'Field to Validate';
$lang['title_field_css_id'] = 'CSS id for this field';
$lang['title_form_css_class'] = 'Klasa CSS dla tego formularza';
$lang['title_field_css_class'] = 'Klasa CSS dla tego pola';
$lang['title_form_predisplay_udt'] = 'User defined tag to call before form is displayed the first time (only called once)';
$lang['title_form_predisplay_each_udt'] = 'User defined tag to call before form is displayed (called on every page of multipage forms)';
$lang['title_form_validate_udt'] = 'User defined tag to call during form validation';
$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_textarea_length'] = 'Maksymalna długość pola z treścią (0 lub puste oznacza brak limitu)';
$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['title_read_only'] = 'Tylko do odczytu';
$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_file_destination'] = 'Directory to save files into';
$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_default_blank'] = 'Default to blank';
$lang['title_default_blank_help'] = 'Default to blank (uncheck to default to today&#039;s date)';
$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['title_encrypt_database_data'] = 'Encrypt data stored in database';
$lang['title_crypt_cert'] = 'Certificate for encrypting data';
$lang['title_encryption_keyfile'] = 'Passphrase or path to file containing passphrase. (If using OpenSSL, this is the passphrase for the private key)';
$lang['title_encrypt_sortfields'] = 'Hash sort fields?';
$lang['title_private_key'] = 'Private Key to use for encrypting data';
$lang['title_encrypt_sortfields_help'] = 'This hashes the sort fields, but leaves the first few letters unencrypted. Cryptographically, this creates a vulnerability, but for most users it is an acceptable tradeoff between security and the ability to sort records. Sorting becomes approximate, but will remain pretty good. If you do not use this option, sort fields are stored in plaintext.';
$lang['title_encryption_functions'] = 'Storage Encryption Unavailable';
$lang['title_install_crypto'] = 'Please install the OpenSSL module or mcrypt support if you would like to enable database encryption.';
$lang['title_install_curl'] = 'Please make sure you have CURL support active in your PHP install. See http://www.php.net/manual/en/book.curl.php';
$lang['title_mle_version'] = 'Run in MLE Mode';
$lang['title_mle_version_long'] = 'Changes/support for CMSMS Multi-Language Edition fork. Do not check this if you are not running the MLE version.';
$lang['title_ensure_cert_key_match'] = 'Ensure that you select the private key that is appropriate for the certificate you are using for encryption!';
$lang['choose_crypt'] = 'Encryption Library';
$lang['title_encrypt_database_long'] = 'Check this to encrypt the stored data. This makes it more difficult (but not impossible) for hackers to view the information.';
$lang['choose_crypt_long'] = 'The options below only apply if you are using the OpenSSL Encryption library';
$lang['title_crypt_lib'] = 'Encryption Library';
$lang['openssl'] = 'OpenSSL Library';
$lang['mcrypt'] = 'PHP mcrypt Library';
$lang['title_feu_binding'] = 'Frontend User binding';
$lang['title_install_feu'] = 'Please install the Frontend User module to connect a form and its data to a specific user';
$lang['title_feu_bind_help'] = 'Check this to lock front-end access to this form&#039;s data to the logged-in front-end user.';
$lang['title_encryption'] = 'Encryption';
$lang['title_export_form_to_udt'] = 'Export form reference to UDT as $params[&#039;FORM&#039;]? (do not do this if you are going to print_r($params) )';
$lang['title_url_help'] = 'Entire URL, including protocol and path (e.g., http://myhost.com/form_handler.cgi)';
$lang['title_url'] = 'Form submission URL';
$lang['title_method'] = 'Form method';
$lang['title_maps_to'] = 'Map field &quot;%s&quot; to form submission variable';
$lang['title_additional'] = 'Additional submission';
$lang['title_additional_help'] = 'Anything to be appended to the submission payload, in URL-encoded form (.e.g, &quot;user=steve+jobs&amp;employee_number=1)';
$lang['title_include_in_submission'] = 'Include field in Submission';
$lang['title_date_order'] = 'Date component field order (for input)';
$lang['title_data_stored_in_fbr'] = 'Data will be stored in an XML format in the [PREFIX]_module_fb_frombrowser database table.';
$lang['error_has_no_fb_field'] = 'Error! Either the form has no form_builder disposition, or it failed to instantiate (due to memory issues?)';
$lang['help_date_order'] = 'Use &quot;m&quot; for Month, &quot;d&quot; for Day, and &quot;y&quot; for Year. Separate the items by hyphens.';
$lang['restricted_to_group'] = 'Tylko w grupie %s';
$lang['title_show_to_user'] = 'Wyświetlić użytkownikowi?';
$lang['title_use_random_generator'] = 'Use random number generator instead of static';
$lang['title_numbers_to_generate'] = 'How many numbers to generate in process';
$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_ignored_if_upload'] = '(This field ignored if you use the Uploads module to manage files)';
$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['help_rtf_file_template'] = 'Specify a file located in the FormBuilder/templates/ folder. This field is ignored if you use TXT as your file type.';
$lang['help_rtf_template_type'] = 'Basic: Use the textarea below to layout the field names/values in a single block.<br />
Advanced: Specify Smarty variables in the RTF Template File as you would below, but arrange them however you like and add formatting.<br />
&nbsp;You can still use the %%HEADER%% and %%FOOTER%% sections in the RTF file.';
$lang['help_unique_file_template'] = 'For TXT, this will be immediately after the Header Template.<br />
For RTF, this will replace the %%FIELDS%% string in the template file if RTF Template Type is set to &quot;Basic&quot;.<br />
This field will be ignored if using &quot;RTF&quot; as File Type and &quot;Advanced&quot; as RTF Template Type.';
$lang['help_file_header_template'] = 'For TXT, this will be placed at the top of the file. For RTF, this will replace the %%HEADER%% string in the template file.';
$lang['help_file_footer_template'] = 'For TXT, this will be placed at the bottom of the file. For RTF, this will replace the %%FOOTER%% string in the template file.';
$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_footer_template'] = 'Create Sample Footer Template';
$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_file_footer'] = 'Template for the footer of output file';
$lang['title_rtf_file_template'] = 'Template RTF file to use';
$lang['title_unique_file_template'] = 'Template for output';
$lang['title_file_type'] = 'Choose a file type to use';
$lang['title_rtf_template_type'] = 'Choose an RTF template type';
$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['title_submit_date'] = 'Date Submitted';
$lang['title_approval_date'] = 'Date Approved (by admin)';
$lang['title_user_approved'] = 'Date Approved (by submitter)';
$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_field_helptext'] = 'Tekst pomocy wyświetlany przy tym polu';
$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_string_unspaced'] = 'String (no spaces between fields)?';
$lang['title_compute_value'] = 'Wartość do obliczenia';
$lang['title_compute'] = 'Computed/PHP';
$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'] = 'Potrzebujesz 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['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'] = 'Wysłać użytkownikowi kopię formularza?';
$lang['title_send_usercopy_label'] = 'Etykieta dla Checkbox (jeśli użytkownik go wybierze)';
$lang['title_send_me_a_copy'] = 'Wyślij mi kopię formularza';
$lang['title_allow_subject_override'] = 'Pozwolić aby tytuł został nadpisany?';
$lang['title_allow_subject_override_long'] = 'Allow &#039;Email &quot;Subject&quot; Fields&#039; to override the subject specified in the pulldown.';
$lang['title_display_length'] = 'Wyświetl długość';
$lang['title_minimum_length'] = 'Minimum response length';
$lang['title_hide'] = 'Hide input';
$lang['title_hide_help'] = 'Show symbols rather plain text when user enters password?';
$lang['password_does_not_match'] = 'Password does not match %s';
$lang['back_top'] = 'Wr&oacute;c do strony gł&oacute;wnej modułu FormBuilder';
$lang['title_headers_to_modify'] = 'Which email headers should this input populate?';
$lang['title_blank_invalid'] = 'Do not accept blank space as valid response';
$lang['title_blank_invalid_long'] = 'If a field is required, checking this will require that people put in some alphanumeric characters, not just spaces';
$lang['title_must_save_order'] = 'Musisz wybrać &quot;zapisz&quot;, aby zmiany w kolejności p&oacute;l zostały zachowane.';
$lang['title_html5'] = 'Use HTML5 placeholder text instead of Javascript';
$lang['error_CompanyDirectory_module_not_available'] = 'Company Directory module is not available!';
$lang['option_never'] = 'Nigdy';
$lang['option_user_choice'] = 'Daj użytkownikowi wyb&oacute;r (checkbox)';
$lang['option_always'] = 'Zawsze';
$lang['option_from'] = '&quot;From&quot; email address';
$lang['option_reply'] = '&quot;Reply-To&quot; email address';
$lang['option_both'] = 'Both &quot;From&quot; and &quot;Reply-To&quot; email addresses';
$lang['option_dropdown'] = 'Dropdown';
$lang['option_selectlist_single'] = 'Select List (single)';
$lang['option_selectlist_multiple'] = 'Select List (multiple)';
$lang['option_radiogroup'] = 'Radio Group';
$lang['title_company_field_note'] = 'Note: Output will be in the form of<br/>&quot;company name&quot;=>&quot;value&quot;';
$lang['title_pick_categories'] = 'Pick a category (multiple)';
$lang['title_pick_fielddef'] = 'Pull a field Definition&#039;s value (single) <em>optional</em>';
$lang['title_choose_user_input'] = 'Choose User input';
$lang['title_see_also_udt'] = '(Also take a look at the Form Submission tab if you want to set a UDT for form validation)';
$lang['title_year_end_message'] = 'End year';
$lang['title_field_logic'] = 'Smarty data or logic that is meant to be sent with this field';
$lang['title_field_logic_long'] = 'Can be smarty data, javascript, or some other data you wan&#039;t to sent along with this field.<br />Goes through the Smarty compiler, so remember use {literal}{/literal} tags with <script></script>';
$lang['title_field_includelabels'] = 'Include labels';
$lang['title_field_includelabels_help'] = 'Enabling this includes labels to output. example - label: value,label2: value2';
$lang['title_field_siblings'] = 'Link this field to it&#039;s sibling';
$lang['title_field_siblings_help'] = 'Dropdown lists all siblings of this field and allows you to link this field to one of it&#039;s sibling. Makes possible controlling this field with selected sibling controls.';
$lang['title_field_hidebuttons'] = 'Hide control buttons';
$lang['title_field_hidebuttons_help'] = 'Hides frontend control buttons of this field.';
$lang['title_note'] = 'Note';
$lang['title_changing_triggers_reindex'] = 'Changing any of the above fields will trigger a reindex of *all* saved records, so it could take a while.';
$lang['illegal_file'] = 'Attempted upload of illegal file type (%s) from %s';
$lang['title_searchable'] = 'Make records accessible to Search Module';
$lang['title_searchable_help'] = 'Checking this will make all submitted data accessible to the Search Module. DO NOT use this if you encrypt your data -- the information gets exposed to search whether or not it is encrypted!';
$lang['uploaded_outside_webroot'] = '%s (outside web root)';
$lang['title_fbr_edit'] = 'Editable in FormBrowser Admin?';
$lang['error_usertag_disposition'] = 'User defined tag returned an error';
$lang['error_usertag'] = 'User defined tag %s returned an error.';
$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['help_module_interface'] = 'Using Module Interface';
$lang['help_module_interface_long'] = '<b>This field is used as a gateway to other modules!</b>
Use it by creating your form elements in the templates of the other module(s) you wish to incorporate, and using the <strong>{$FBid}</strong> to tie it back to FormBuilder. For example, to include form options based on the Products module, create the following template in Products:<br/>
<pre>
{foreach from=$items item=entry}
	{assign var=MData value=&#039;&#039;}
	{assign var=Cd value=&#039;&#039;}
		{foreach from=$FBvalue item=MData}
			{assign var=MData value=&#039;::&#039;|explode:$MData}
			{if $MData[1]==$entry->id}
				{assign var=Cd value=&#039; checked=&quot;checked&quot;&#039;}
			{/if}
		{/foreach}
	<div class=&quot;ProductDirectoryItem&quot;>
		<input type=&quot;checkbox&quot; value=&quot;{$entry->price}::{$entry->id}&quot; name=&quot;{$FBid}[]&quot; {$Cd} />{$entry->product_name} ({$entry->weight}{$weight_units}) &pound;{$entry->price}    
	</div>
{/foreach}
</pre>
<br/>
where in the input below you put something like <strong>{Products category=&quot;cat&quot; summarytemplate=&quot;Your_FB_template&quot;}</strong>';
$lang['title_add_tag'] = 'Add your tag';
$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['AF'] = 'Afghanistan';
$lang['AX'] = 'Aland Islands';
$lang['AL'] = 'Albania';
$lang['DZ'] = 'Algeria';
$lang['AS'] = 'American Samoa';
$lang['AD'] = 'Andorra';
$lang['AO'] = 'Angola';
$lang['AI'] = 'Anguilla';
$lang['AQ'] = 'Antarctica';
$lang['AG'] = 'Antigua and Barbuda';
$lang['AR'] = 'Argentina';
$lang['AM'] = 'Armenia';
$lang['AW'] = 'Aruba';
$lang['AU'] = 'Australia';
$lang['AT'] = 'Austria';
$lang['AZ'] = 'Azerbaijan';
$lang['BS'] = 'Bahamas';
$lang['BH'] = 'Bahrain';
$lang['BB'] = 'Barbados';
$lang['BD'] = 'Bangladesh';
$lang['BY'] = 'Belarus';
$lang['BE'] = 'Belgium';
$lang['BZ'] = 'Belize';
$lang['BJ'] = 'Benin';
$lang['BM'] = 'Bermuda';
$lang['BT'] = 'Bhutan';
$lang['BW'] = 'Botswana';
$lang['BO'] = 'Bolivia';
$lang['BA'] = 'Bosnia and Herzegovina';
$lang['BV'] = 'Bouvet Island';
$lang['BR'] = 'Brazil';
$lang['IO'] = 'British Indian Ocean Territory';
$lang['BN'] = 'Brunei Darussalam';
$lang['BG'] = 'Bulgaria';
$lang['BF'] = 'Burkina Faso';
$lang['BI'] = 'Burundi';
$lang['KH'] = 'Cambodia';
$lang['CM'] = 'Cameroon';
$lang['CA'] = 'Canada';
$lang['CV'] = 'Cape Verde';
$lang['KY'] = 'Cayman Islands';
$lang['CF'] = 'Central African Republic';
$lang['TD'] = 'Chad';
$lang['CL'] = 'Chile';
$lang['CN'] = 'China';
$lang['CX'] = 'Christmas Island';
$lang['CC'] = 'Cocos (Keeling) Islands';
$lang['CO'] = 'Colombia';
$lang['KM'] = 'Comoros';
$lang['CG'] = 'Congo';
$lang['CD'] = 'Congo,  Democratic Republic';
$lang['CK'] = 'Cook Islands';
$lang['CR'] = 'Costa Rica';
$lang['CI'] = 'Ivoire (Ivory Coast)';
$lang['HR'] = 'Croatia (Hrvatska)';
$lang['CU'] = 'Cuba';
$lang['CY'] = 'Cyprus';
$lang['CZ'] = 'Czech Republic';
$lang['DK'] = 'Denmark';
$lang['DJ'] = 'Djibouti';
$lang['DM'] = 'Dominica';
$lang['DO'] = 'Dominican Republic';
$lang['TP'] = 'East Timor';
$lang['EC'] = 'Ecuador';
$lang['EG'] = 'Egypt';
$lang['SV'] = 'El Salvador';
$lang['GQ'] = 'Equatorial Guinea';
$lang['ER'] = 'Eritrea';
$lang['EE'] = 'Estonia';
$lang['ET'] = 'Ethiopia';
$lang['FK'] = 'Falkland Islands (Malvinas)';
$lang['FO'] = 'Faroe Islands';
$lang['FJ'] = 'Fiji';
$lang['FI'] = 'Finland';
$lang['FR'] = 'France';
$lang['FX'] = 'France,  Metropolitan';
$lang['GF'] = 'Guernsey';
$lang['PF'] = 'French Polynesia';
$lang['TF'] = 'French Southern Territories';
$lang['MK'] = 'F.Y.R.O.M. (Macedonia)';
$lang['GA'] = 'Gabon';
$lang['GM'] = 'Gambia';
$lang['GE'] = 'Georgia';
$lang['DE'] = 'Germany';
$lang['GH'] = 'Ghana';
$lang['GI'] = 'Gibraltar';
$lang['GB'] = 'Great Britain (UK)';
$lang['GR'] = 'Greece';
$lang['GL'] = 'Greenland';
$lang['GD'] = 'Grenada';
$lang['GP'] = 'Guadeloupe';
$lang['GU'] = 'Guam';
$lang['GT'] = 'Guatemala';
$lang['GN'] = 'Guinea';
$lang['GW'] = 'Guinea-Bissau';
$lang['GY'] = 'Guyana';
$lang['HT'] = 'Haiti';
$lang['HM'] = 'Heard and McDonald Islands';
$lang['HN'] = 'Honduras';
$lang['HK'] = 'Hong Kong';
$lang['HU'] = 'Hungary';
$lang['IS'] = 'Iceland';
$lang['IN'] = 'India';
$lang['ID'] = 'Indonesia';
$lang['IR'] = 'Iran';
$lang['IQ'] = 'Iraq';
$lang['IE'] = 'Ireland';
$lang['IL'] = 'Israel';
$lang['IM'] = 'Isle of Man';
$lang['IT'] = 'Italy';
$lang['JE'] = 'Jersey';
$lang['JM'] = 'Jamaica';
$lang['JP'] = 'Japan';
$lang['JO'] = 'Jordan';
$lang['KZ'] = 'Kazakhstan';
$lang['KE'] = 'Kenya';
$lang['KI'] = 'Kiribati';
$lang['KP'] = 'Korea (North)';
$lang['KR'] = 'Korea (South)';
$lang['KW'] = 'Kuwait';
$lang['KG'] = 'Kyrgyzstan';
$lang['LA'] = 'Laos';
$lang['LV'] = 'Latvia';
$lang['LB'] = 'Lebanon';
$lang['LI'] = 'Liechtenstein';
$lang['LR'] = 'Liberia';
$lang['LY'] = 'Libya';
$lang['LS'] = 'Lesotho';
$lang['LT'] = 'Lithuania';
$lang['LU'] = 'Luxembourg';
$lang['MO'] = 'Macau';
$lang['MG'] = 'Madagascar';
$lang['MW'] = 'Malawi';
$lang['MY'] = 'Malaysia';
$lang['MV'] = 'Maldives';
$lang['ML'] = 'Mali';
$lang['MT'] = 'Malta';
$lang['MH'] = 'Marshall Islands';
$lang['MQ'] = 'Martinique';
$lang['MR'] = 'Mauritania';
$lang['MU'] = 'Mauritius';
$lang['YT'] = 'Mayotte';
$lang['MX'] = 'Mexico';
$lang['FM'] = 'Micronesia';
$lang['MC'] = 'Monaco';
$lang['MD'] = 'Moldova';
$lang['MA'] = 'Morocco';
$lang['MN'] = 'Mongolia';
$lang['MS'] = 'Montserrat';
$lang['MZ'] = 'Mozambique';
$lang['MM'] = 'Myanmar';
$lang['NA'] = 'Namibia';
$lang['NR'] = 'Nauru';
$lang['NP'] = 'Nepal';
$lang['NL'] = 'Netherlands';
$lang['AN'] = 'Netherlands Antilles';
$lang['NT'] = 'Neutral Zone';
$lang['NC'] = 'New Caledonia';
$lang['NZ'] = 'New Zealand (Aotearoa)';
$lang['NI'] = 'Nicaragua';
$lang['NE'] = 'Niger';
$lang['NG'] = 'Nigeria';
$lang['NU'] = 'Niue';
$lang['NF'] = 'Norfolk Island';
$lang['MP'] = 'Northern Mariana Islands';
$lang['NO'] = 'Norway';
$lang['OM'] = 'Oman';
$lang['PK'] = 'Pakistan';
$lang['PW'] = 'Palau';
$lang['PS'] = 'Palestinian Territory';
$lang['PA'] = 'Panama';
$lang['PG'] = 'Papua New Guinea';
$lang['PY'] = 'Paraguay';
$lang['PE'] = 'Peru';
$lang['PH'] = 'Philippines';
$lang['PN'] = 'Pitcairn';
$lang['PL'] = 'Poland';
$lang['PT'] = 'Portugal';
$lang['PR'] = 'Puerto Rico';
$lang['QA'] = 'Qatar';
$lang['RE'] = 'Reunion';
$lang['RO'] = 'Romania';
$lang['RU'] = 'Russian Federation';
$lang['RW'] = 'Rwanda';
$lang['GS'] = 'S. Georgia and S. Sandwich Isls.';
$lang['KN'] = 'Saint Kitts and Nevis';
$lang['LC'] = 'Saint Lucia';
$lang['VC'] = 'Saint Vincent &amp; the Grenadines';
$lang['WS'] = 'Samoa';
$lang['SM'] = 'San Marino';
$lang['ST'] = 'Sao Tome and Principe';
$lang['SA'] = 'Saudi Arabia';
$lang['SN'] = 'Senegal';
$lang['SC'] = 'Seychelles';
$lang['SL'] = 'Sierra Leone';
$lang['SG'] = 'Singapore';
$lang['SI'] = 'Slovenia';
$lang['SK'] = 'Slovak Republic';
$lang['SB'] = 'Solomon Islands';
$lang['SO'] = 'Somalia';
$lang['ZA'] = 'South Africa';
$lang['ES'] = 'Spain';
$lang['LK'] = 'Sri Lanka';
$lang['SH'] = 'St. Helena';
$lang['PM'] = 'St. Pierre and Miquelon ';
$lang['SD'] = 'Sudan';
$lang['SR'] = 'Suriname';
$lang['SJ'] = 'Svalbard &amp; Jan Mayen Islands';
$lang['SZ'] = 'Swaziland';
$lang['SE'] = 'Sweden';
$lang['CH'] = 'Switzerland';
$lang['SY'] = 'Syria';
$lang['TW'] = 'Taiwan';
$lang['TJ'] = 'Tajikistan';
$lang['TZ'] = 'Tanzania';
$lang['TH'] = 'Thailand';
$lang['TG'] = 'Togo';
$lang['TK'] = 'Tokelau';
$lang['TO'] = 'Tonga';
$lang['TT'] = 'Trinidad and Tobago';
$lang['TN'] = 'Tunisia';
$lang['TR'] = 'Turkey';
$lang['TM'] = 'Turkmenistan';
$lang['TC'] = 'Turks and Caicos Islands';
$lang['TV'] = 'Tuvalu';
$lang['UG'] = 'Uganda';
$lang['UA'] = 'Ukraine';
$lang['AE'] = 'United Arab Emirates';
$lang['UK'] = 'United Kingdom';
$lang['US'] = 'United States';
$lang['UM'] = 'US Minor Outlying Islands';
$lang['UY'] = 'Uruguay';
$lang['UZ'] = 'Uzbekistan';
$lang['VU'] = 'Vanuatu';
$lang['VA'] = 'Vatican City State (Holy See)';
$lang['VE'] = 'Venezuela';
$lang['VN'] = 'Viet Nam';
$lang['VG'] = 'Virgin Islands (British)';
$lang['VI'] = 'Virgin Islands (U.S.)';
$lang['WF'] = 'Wallis and Futuna Islands';
$lang['EH'] = 'Western Sahara';
$lang['YE'] = 'Yemen';
$lang['YU'] = 'Yugoslavia';
$lang['ZM'] = 'Zambia';
$lang['ZW'] = 'Zimbabwe';
$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: odznaczony';
$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['utma'] = '156861353.130117701.1281030249.1295630375.1295692107.43';
$lang['utmz'] = '156861353.1295285085.38.24.utmccn=(organic)|utmcsr=google|utmctr=cmsms translation|utmcmd=organic';
$lang['qca'] = 'P0-1706049120-1281030249820';
$lang['utmb'] = '156861353';
$lang['utmc'] = '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_CatalogerItemsField'] = 'Выберите одну или более позицию из каталога';
$lang['field_type_FieldsetEnd'] = 'Конец группы полей (fieldset)';
$lang['field_type_FieldsetStart'] = 'Начало группы полей (fieldset)';
$lang['field_type_TextField'] = 'Текстовое поле (input)';
$lang['field_type_HTML5NumberField'] = 'HTML5 числовое поле ввода';
$lang['field_type_HTML5EmailField'] = 'HTML5 поле ввода Email';
$lang['field_type_HTML5URLField'] = 'HTML5 поле ввода URL';
$lang['field_type_PasswordField'] = 'Пароль';
$lang['field_type_PasswordAgainField'] = 'Пароль снова (проверка)';
$lang['field_type_TextFieldExpandable'] = 'Текстовое поле (несколько штук)';
$lang['field_type_TextAreaField'] = 'Текстовое окно (textarea)';
$lang['field_type_ButtonField'] = 'Кнопка';
$lang['field_type_CheckboxField'] = 'Галочка (checkbox)';
$lang['field_type_CheckboxGroupField'] = 'Несколько галочек (checkbox group)';
$lang['field_type_PulldownField'] = 'Выпадающий список';
$lang['field_type_YearPullDownField'] = 'Year Pulldown';
$lang['field_type_MultiselectField'] = 'Множественный выбор';
$lang['field_type_StatePickerField'] = 'Выбор штатов США';
$lang['field_type_ProvincePickerField'] = 'Выбор канадской провинции';
$lang['field_type_CountryPickerField'] = 'Выбор страны';
$lang['field_type_DatePickerField'] = 'Выбор даты';
$lang['field_type_TimePickerField'] = 'Выбор времени';
$lang['field_type_RadioGroupField'] = 'Группа радиокнопок';
$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'] = '*Отправить результат на указанные e-mail адреса';
$lang['field_type_DispositionEmailConfirmation'] = '*Проверка-через-Email адрес';
$lang['field_type_DispositionFromEmailAddressField'] = '*Поле Email "От кого(адрес)", и отправить копию';
$lang['field_type_DispositionFile'] = '*Записать результаты в файл';
$lang['field_type_DispositionUniqueFile'] = '*Write Results to a Unique Flat File for each submission';
$lang['field_type_DispositionDatabase'] = '*Записать результаты в базу данных';
$lang['field_type_DispositionFormBrowser'] = '*Записать результаты в формате FormBrowser Module v.3';
$lang['field_type_DispositionUserTag'] = '*Вызвать тег пользователя с результатами формы в качестве параметров';
$lang['field_type_DispositionForm'] = '*Submit to an arbitrary form action';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Отправить по адресу, указанному пользователем';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Отправить администратору CMS';
$lang['field_type_DispositionEmailBasedFrontendFields'] = '*Email results based on frontend fields';
$lang['field_type_PageBreakField'] = '-Разрыв страницы';
$lang['field_type_FileUploadField'] = 'Загрузка файла';
$lang['field_type_FromEmailAddressField'] = 'Почтовое поле "E-mail отправителя"';
$lang['field_type_FromEmailAddressAgainField'] = 'Почтовое поле "E-mail отправителя" - повтор';
$lang['field_type_FromEmailNameField'] = 'Почтовое поле "Имя отправителя"';
$lang['field_type_FromEmailSubjectField'] = 'Почтовое поле "Тема"';
$lang['field_type_StaticTextField'] = '-Статический текст';
$lang['field_type_SystemLinkField'] = '-Статическая ссылка';
$lang['field_type_LinkField'] = 'Ссылка (пользователя)';
$lang['field_type_HiddenField'] = '-Скрытое поле';
$lang['field_type_ComputedField'] = '-Вычисленное поле';
$lang['field_type_UniqueIntegerField'] = '-Не повторяющееся целое число (serial)';
$lang['field_type_UserTagField'] = '-User Defined Tag Call';
$lang['field_type_CompanyDirectoryField'] = 'Company Directory Field';
$lang['field_type_ModuleInterfaceField'] = '-Module Interface Field';
$lang['validation_none'] = 'Нет проверки';
$lang['validation_numeric'] = 'Число';
$lang['validation_integer'] = 'Целое число';
$lang['validation_email_address'] = 'Адрес e-mail';
$lang['validation_usphone'] = 'Номер телефона (США)';
$lang['validation_must_check'] = 'Должна быть проставлена галочка';
$lang['validation_regex_match'] = 'Должно подходить под регулярное выражение';
$lang['validation_regex_nomatch'] = 'Не должно подходить под регулярное выражение';
$lang['required_field_missing'] = 'Обязательное поле формы не было заполнено';
$lang['please_enter_a_value'] = 'Пожалуйста, заполните поле "%s"';
$lang['please_enter_a_number'] = 'Пожалуйста, введите число для поля "%s"';
$lang['please_enter_valid'] = 'Пожалуйста, корректно заполните поле "%s"';
$lang['please_enter_an_integer'] = 'Пожалуйста, введите целое число для поля "%s"';
$lang['please_enter_an_email'] = 'Введите корректный e-mail адрес в поле "%s"';
$lang['email_address_does_not_match'] = 'Введенный e-mail адрес не совпадает с полем "%s"';
$lang['please_enter_a_phone'] = 'Пожалуйста, введите в поле "%s" корректный номер телефона';
$lang['please_login'] = 'Пожалуйста, войдите, чтобы использовать эту форму';
$lang['not_valid_email'] = 'Адрес, введенный в поле "%s" не является корректным e-mail адресом!';
$lang['please_enter_no_longer'] = 'Пожалуйста, введите значение не превышающее %s символов';
$lang['please_enter_at_least'] = 'Пожалуйста, введите значение, по крайней мере %s символов';
$lang['title_list_delimiter'] = 'Символ для использования в качестве разделителя в результатах, когда возвращается более одного значения';
$lang['you_need_permission'] = 'Вам нужны права "%s", чтобы выполнить это действие.';
$lang['lackpermission'] = 'Извините, но у вас нет прав доступа к этой части сайта.';
$lang['field_order_updated'] = 'Порядок полей обновлен.';
$lang['form_deleted'] = 'Форма удалена.';
$lang['field_deleted'] = 'Поле удалено.';
$lang['configuration_updated'] = 'Конфигурация обновлена.';
$lang['you_must_check'] = 'Вы должны проверить "%s", чтобы продолжить.';
$lang['must_specify_one_destination'] = 'Вам необходимо указать как минимум один адрес назначения!';
$lang['are_you_sure_delete_form'] = 'Вы уверены, что хотите удалить форму %s?';
$lang['are_you_sure_delete_field'] = 'Вы уверены, что хотите удалить поле %s?';
$lang['notice_select_type'] = 'Пока не указан тип поля, дополнительные настройки не отображаются.';
$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'] = 'Каждому полю должно быть присвоено имя, если только это не отключено в настройках Конструктора форм.';
$lang['no_field_assigned'] = 'Нет поля предназначенного для %s';
$lang['anonymous'] = 'Анонимно';
$lang['abbreviation_length'] = 'Длина: %s';
$lang['boxes'] = '%s boxes';
$lang['options'] = '%s опций';
$lang['text_length'] = '%s символов.';
$lang['order'] = 'Порядок';
$lang['unspecified'] = '[не указано]';
$lang['added'] = 'добавлено';
$lang['updated'] = 'обновлено';
$lang['sort_options'] = 'Сортировать настройки при выводе';
$lang['select_one'] = 'Выберите один из предлагаемых вариантов';
$lang['select_type'] = 'Выберите тип';
$lang['to'] = 'Кому';
$lang['yes'] = 'Да';
$lang['no'] = 'Нет';
$lang['recipients'] = 'получатели';
$lang['fields'] = 'поля';
$lang['file_count'] = '%s возможных файлов';
$lang['destination_count'] = '%s направлений';
$lang['save'] = 'Сохранить';
$lang['add'] = 'Добавить';
$lang['update'] = 'Обновить';
$lang['save_and_continue'] = 'Сохранить и продолжить редактирование';
$lang['information'] = 'Информация';
$lang['automatic'] = 'Автоматически';
$lang['forms'] = 'Формы';
$lang['form'] = 'Форма "%s"';
$lang['configuration'] = 'Конфигурация';
$lang['field_requirement_updated'] = 'Обязательное поле, состояние обновлено.';
$lang['maximum_size'] = 'Макс. размер';
$lang['permitted_extensions'] = 'Расширения';
$lang['permitted_filetypes'] = 'Разрешенные типы файлов';
$lang['file_too_large'] = 'Закачанный файл слишком велик! Максимальный допустимый размер:';
$lang['illegal_file_type'] = 'Закачка файлов этого типа запрещена. Пожалуйста, проверьте, что дали файлу корректное расширение.';
$lang['upload'] = 'Закачать';
$lang['form_imported'] = 'Форма импортирована.';
$lang['form_import_failed'] = 'Форма не была импортирована! Формат XML-файла некорректный.';
$lang['rows'] = '%s строк';
$lang['cols'] = '%s колонок';
$lang['12_hour'] = '12-часовые часы';
$lang['24_hour'] = '24-часовые часы';
$lang['hour'] = 'Час';
$lang['min'] = 'Минута';
$lang['merid'] = 'Меридиан';
$lang['date_range'] = 'Интервал: %s - %s';
$lang['thanks'] = 'Спасибо! Ваш запрос был получен.';
$lang['edit'] = 'Редактировать';
$lang['delete'] = 'Удалить';
$lang['day'] = 'День';
$lang['mon'] = 'Месяц';
$lang['year'] = 'Год';
$lang['none'] = '(нет)';
$lang['css'] = 'СSS';
$lang['uninstalled'] = 'Модуль удален.';
$lang['installed'] = 'Модуль версии %s установлен.';
$lang['upgraded'] = 'Модуль обновлен до версии %s.';
$lang['button_previous'] = 'Назад...';
$lang['button_submit'] = 'Отправить';
$lang['button_continue'] = 'Далее...';
$lang['value_checked'] = 'Проставлена галочка';
$lang['value_unchecked'] = 'Не проставлена галочка';
$lang['tab_main'] = 'Основные настройки';
$lang['tab_symbol'] = 'Настройки отображения формы';
$lang['tab_submit'] = 'Настройки отправки формы';
$lang['tab_captcha'] = 'Настройки Captcha';
$lang['tab_advanced'] = 'Дополнительные настройки';
$lang['tab_templatelayout'] = 'Шаблон формы';
$lang['tab_submissiontemplate'] = 'Шаблон отправки формы';
$lang['tab_udt'] = 'UDT интеграция';
$lang['canuse_smarty'] = '<em>В этом поле можно использовать переменные Smarty.</em>';
$lang['add_options'] = 'Добавить ещё опций';
$lang['delete_options'] = 'Удалить отмеченные опции';
$lang['add_checkboxes'] = 'Добавить ещё галочек';
$lang['delete_checkboxes'] = 'Удалить отмеченные галочки';
$lang['add_address'] = 'Добавить другой адрес';
$lang['delete_address'] = 'Удалить отмеченные адреса';
$lang['add_destination'] = 'Добавить другое назначение';
$lang['delete_destination'] = 'Удалить помеченные назначения';
$lang['suspected_spam'] = 'С Вашего IP-адреса поступает слишком много запросов. Система защиты от спама заблокировала отправку формы.';
$lang['suspected_spam_log'] = 'Предполагаемый спам с IP-адреса %s остановлен.';
$lang['reorder'] = 'Поменять порядок полей';
$lang['cancel'] = 'Отмена';
$lang['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'] = 'Регулярное выражение позволяет фильтровать элементы каталога по имени';
$lang['help_field_height'] = 'Высота множественного поля';
$lang['title_name_regex'] = 'Cataloger Item Name Regular Expression';
$lang['title_field_height'] = 'Высота поля';
$lang['title_file_path'] = 'Целевой каталог для выходных файлов';
$lang['title_udt_name'] = 'Тег пользователя';
$lang['title_uploads_destpage'] = 'Page to return to with uploads link';
$lang['title_uploadmodule_summary'] = 'Отправлено formbuilder';
$lang['title_uploads_category'] = 'Категория загрузок';
$lang['title_sendto_uploads'] = 'Отправить этот файл в модуль загрузок';
$lang['title_allow_overwrite'] = 'Разрешить загружать на перезапись ранние файлы?';
$lang['title_allow_overwrite_long'] = 'Загружаемый файл перезаписывает ранее загруженный файл, если он имеет тоже имя?';
$lang['overwrite'] = 'Позволить перезапись';
$lang['nooverwrite'] = 'Запретить перезапись';
$lang['file_already_exists'] = 'Файл %s уже существует, и не может быть перезаписан.';
$lang['title_file_rename'] = 'Шаблон имени файла';
$lang['original_file_extension'] = 'Оригинальное расширение файла (включая ".")';
$lang['title_suppress_filename'] = 'Suppress filename in emails and forms the end user will see';
$lang['file_rename_help'] = 'To rename a file upon uploading, create the template here. Leave blank to preserve original filename';
$lang['title_legend'] = 'Легенда';
$lang['title_maximum_length'] = 'Максимальная длина';
$lang['title_checkbox_label'] = 'Подпись елемента Checkbox (галочка)';
$lang['title_radio_label'] = 'Подпись елемента Radio Button (радио кнопка)';
$lang['title_checked_value'] = 'Значение когда проставлена галочка';
$lang['title_unchecked_value'] = 'Значение когда нет галочки';
$lang['title_checkbox_details'] = 'Checkbox Group Details';
$lang['title_delete'] = 'Удалить?';
$lang['title_select_one_message'] = '"Select One" Text';
$lang['title_selection_value'] = 'Выбор значения';
$lang['title_selection_displayname'] = 'Selection Display Name';
$lang['title_selection_subject'] = 'Выбор темы';
$lang['title_select_default_country'] = 'Выбор по умолчанию';
$lang['title_select_default_state'] = 'Выбор по умолчанию';
$lang['title_select_default_province'] = 'Выбор по умолчанию';
$lang['title_option_name'] = 'Option Name';
$lang['title_option_value'] = 'Значение отправлено';
$lang['title_pulldown_details'] = 'Pulldown Options';
$lang['title_multiselect_details'] = 'Multiselect Options';
$lang['title_destination_address'] = 'Назначенный почтовый адрес';
$lang['title_destination_filename'] = 'Назначенное имя файла';
$lang['title_email_from_name'] = '"От кого" для email';
$lang['title_relaxed_email_regex'] = 'Использовать слабую проверку email';
$lang['title_relaxed_regex_long'] = 'Использовать слабую проверку email (прим., разрешает "x@y", а не требует "x@y.tld")';
$lang['title_email_from_address'] = '"От куда" для email';
$lang['title_email_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'] = 'Страница для перенаправления после отправки формы';
$lang['title_not_ready2'] = 'Пожалуйста, добавьте поле в форму, так чтобы входные данные пользователя обрабатывались. Вы можете';
$lang['title_not_ready_link'] = 'использовать этот ярлык';
$lang['title_form_alias'] = 'Алиас формы';
$lang['title_field_alias_short'] = 'Алиас';
$lang['title_form_fields'] = 'Поля формы';
$lang['title_field_id'] = 'ID поля';
$lang['title_show_fieldaliases'] = 'Показать алиасы полей';
$lang['title_show_fieldaliases_long'] = 'Нажатие на эту кнопку отображает поле алиасов при добавлении или редактировании формы';
$lang['title_field_name'] = 'Имя поля';
$lang['title_field_alias'] = 'Алиас поля';
$lang['title_radiogroup_details'] = 'Radio Button Group Details';
$lang['title_field_type'] = 'Тип поля';
$lang['title_not_ready3'] = 'создать форму обработки поля.';
$lang['title_add_new_form'] = 'Добавить новую форму';
$lang['title_show_version'] = 'Показать версию Form Builder?';
$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'] = 'Текст кнопки отправки формы';
$lang['title_button_text'] = 'Текст кнопки';
$lang['title_submit_button_safety'] = 'Add Javascript to Submit Button to prevent multiple submissions?';
$lang['title_submit_button_safety_help'] = 'Добавить скрипт безопасности';
$lang['title_form_next_button'] = 'Текст кнопки перехода на следующую страницу (используется для многостраничных форм)';
$lang['title_form_prev_button'] = 'Текст кнопки перехода на предыдущую страницу  (используется для многостраничных форм)';
$lang['title_field_validation'] = 'Проверка поля';
$lang['title_field_to_validate'] = 'Поле для проверки';
$lang['title_field_css_id'] = 'CSS id для этого поля';
$lang['title_form_css_class'] = 'CSS класс для этой формы';
$lang['title_field_css_class'] = 'CSS класс для этого поля';
$lang['title_form_predisplay_udt'] = 'Пользовательский тег вызова перед отображением формы';
$lang['title_form_predisplay_each_udt'] = 'Тэг пользователя (UDT) вызываемый перед отображением формы (вызывается на каждой странице многостраничной формы)';
$lang['title_form_validate_udt'] = 'Тег пользователя вызываемый во время проверки формы';
$lang['title_form_required_symbol'] = 'Символ для отметки обязательных полей';
$lang['title_field_required'] = 'Обязательно';
$lang['title_field_required_long'] = 'Поле обязательно для заполнения';
$lang['title_hide_label'] = 'Скрыть подпись';
$lang['title_hide_label_long'] = 'Скрыть имя этого поля на форме';
$lang['title_textarea_length'] = 'Максимальная длина содержимого поля (0 или пусто без ограничений)';
$lang['title_text'] = 'Статический текст для показа';
$lang['title_field_regex'] = 'Проверка Regex';
$lang['title_lines_to_show'] = 'Количество строк для показа';
$lang['title_read_only'] = 'Только чтение';
$lang['no_default'] = 'Не по умолчанию';
$lang['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'] = 'Обязательно';
$lang['title_hide_errors'] = 'Скрыть ошибки';
$lang['title_form_displaytype'] = 'Тип отображения формы';
$lang['title_hide_errors_long'] = 'Prevent debug / error messages from being seen by users.';
$lang['title_email_template'] = 'Шаблон Email';
$lang['title_maximum_size'] = 'Максимальный размер загружаемого файла (килобайты)';
$lang['title_maximum_size_long'] = 'This limitation is in addition to any limits set by the php or web server configuration';
$lang['title_file_destination'] = 'Каталог для сохранения файлов';
$lang['title_permitted_extensions'] = 'Разрешенные расширения';
$lang['title_permitted_extensions_long'] = 'Введите список расширений через запятую, расширение вводите без точки, (т.е., "jpg,gif,jpeg"). Пробелы игнорируются. Пустое поля подразумевает отсутствие ограничений.';
$lang['title_show_limitations'] = 'Отображать ограничения?';
$lang['title_show_limitations_long'] = 'Отображать ограничения на размера и раширение для поля загрузки файла?';
$lang['title_form_template'] = 'Шаблон используемый для отображения формы';
$lang['title_page_x_of_y'] = 'Страница %s из %s';
$lang['title_no_advanced_options'] = 'Поле не имеет дополнительных параметров.';
$lang['title_form_unspecified'] = 'Текст возвращаемый при неопределенных значениях ';
$lang['title_enable_fastadd_long'] = 'Включить быстрое добавление полей для форм в выпадающем списке?';
$lang['title_enable_fastadd'] = 'Включить быстрое добавление полей в выпадающем списке?';
$lang['title_fastadd'] = 'Быстрое добавление поля';
$lang['title_enable_antispam_long'] = 'Кликните чтобы разрешить отправку не более 10 электронных писем в час для 1 IP адреса.';
$lang['title_enable_antispam'] = 'Включить примитивные анти-спам функции?';
$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'] = 'Загрузить форму из XML файла';
$lang['title_xml_upload_formname'] = 'Использовать это имя для формы';
$lang['title_import_legend'] = 'Форма импорта XML';
$lang['title_xml_upload_formalias'] = 'Использовать этот алиас для формы';
$lang['title_html_email'] = 'Генерировать письмо в HTML?';
$lang['title_link_autopopulate'] = 'Заполнять автоматически?';
$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'] = 'Ссылка на страницу сайта';
$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'] = 'Использовать Captcha для защиты отправки формы?';
$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'] = 'Пожалуйста подтвердите что вы человек, введя буквы с изображения.';
$lang['title_user_captcha_error'] = 'Ошибка в тексте для Captcha';
$lang['wrong_captcha'] = 'Captcha некорректна.';
$lang['title_title_user_captcha'] = 'Текст подсказки для Captcha';
$lang['title_dont_submit_unchecked'] = 'Не отправлять значения не отмеченные галочкой';
$lang['title_dont_submit_unchecked_help'] = 'Check this if you only want checked boxes to return values.';
$lang['link_label'] = 'Подпись ссылки';
$lang['link_destination'] = 'URL назначения';
$lang['title_default_set'] = 'По умолчанию отмечено?';
$lang['title_24_hour'] = 'Использовать 24-часовой формат?';
$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_default_blank'] = 'Default to blank';
$lang['title_default_blank_help'] = 'Default to blank (uncheck to default to today\'s date)';
$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['title_encrypt_database_data'] = 'Шифровать данные хранящиеся в базе данных';
$lang['title_crypt_cert'] = 'Certificate for encrypting data';
$lang['title_encryption_keyfile'] = 'Passphrase or path to file containing passphrase. (If using OpenSSL, this is the passphrase for the private key)';
$lang['title_encrypt_sortfields'] = 'Hash sort fields?';
$lang['title_private_key'] = 'Private Key to use for encrypting data';
$lang['title_encrypt_sortfields_help'] = 'This hashes the sort fields, but leaves the first few letters unencrypted. Cryptographically, this creates a vulnerability, but for most users it is an acceptable tradeoff between security and the ability to sort records. Sorting becomes approximate, but will remain pretty good. If you do not use this option, sort fields are stored in plaintext.';
$lang['title_encryption_functions'] = 'Storage Encryption Unavailable';
$lang['title_install_crypto'] = 'Please install the OpenSSL module or mcrypt support if you would like to enable database encryption.';
$lang['title_install_curl'] = 'Please make sure you have CURL support active in your PHP install. See http://www.php.net/manual/en/book.curl.php';
$lang['title_mle_version'] = 'Запуск в режиме MLE';
$lang['title_mle_version_long'] = 'Changes/support for CMSMS Multi-Language Edition fork. Do not check this if you are not running the MLE version.';
$lang['title_ensure_cert_key_match'] = 'Ensure that you select the private key that is appropriate for the certificate you are using for encryption!';
$lang['choose_crypt'] = 'Библиотека шифрования';
$lang['title_encrypt_database_long'] = 'Check this to encrypt the stored data. This makes it more difficult (but not impossible) for hackers to view the information.';
$lang['choose_crypt_long'] = 'The options below only apply if you are using the OpenSSL Encryption library';
$lang['title_crypt_lib'] = 'Библиотека шифрования';
$lang['openssl'] = 'Библиотека OpenSSL';
$lang['mcrypt'] = 'PHP библиотека mcrypt';
$lang['title_feu_binding'] = 'Frontend User binding';
$lang['title_install_feu'] = 'Please install the Frontend User module to connect a form and its data to a specific user';
$lang['title_feu_bind_help'] = 'Check this to lock front-end access to this form\'s data to the logged-in front-end user.';
$lang['title_encryption'] = 'Шифрование';
$lang['title_export_form_to_udt'] = 'Export form reference to UDT as $params[\'FORM\']? (do not do this if you are going to print_r($params) )';
$lang['title_url_help'] = 'Entire URL, including protocol and path (e.g., http://myhost.com/form_handler.cgi)';
$lang['title_url'] = 'Form submission URL';
$lang['title_method'] = 'Метод формы';
$lang['title_maps_to'] = 'Map field "%s" to form submission variable';
$lang['title_additional'] = 'Additional submission';
$lang['title_additional_help'] = 'Anything to be appended to the submission payload, in URL-encoded form (.e.g, "user=steve+jobs&employee_number=1)';
$lang['title_include_in_submission'] = 'Include field in Submission';
$lang['title_date_order'] = 'Date component field order (for input)';
$lang['title_data_stored_in_fbr'] = 'Data will be stored in an XML format in the [PREFIX]_module_fb_frombrowser database table.';
$lang['error_has_no_fb_field'] = 'Error! Either the form has no form_builder disposition, or it failed to instantiate (due to memory issues?)';
$lang['help_date_order'] = 'Use "m" for Month, "d" for Day, and "y" for Year. Separate the items by hyphens.';
$lang['restricted_to_group'] = 'Only in group %s';
$lang['title_show_to_user'] = 'Отображать пользователей?';
$lang['title_use_random_generator'] = 'Use random number generator instead of static';
$lang['title_numbers_to_generate'] = 'How many numbers to generate in process';
$lang['help_leaveempty'] = 'Это поле можно оставить пустым';
$lang['help_variables_for_template'] = 'Переменные для шаблона';
$lang['help_variables_for_computation'] = 'Доступные переменные';
$lang['help_php_variable_name'] = 'Переменные PHP';
$lang['help_submission_date'] = 'Дата отправки';
$lang['help_server_name'] = 'Ваш сервер';
$lang['help_sub_source_ip'] = 'IP адрес персоны использующей форму';
$lang['help_sub_url'] = 'URL страницы содержащей форму';
$lang['help_fb_version'] = 'Версия FormBuilder';
$lang['help_tab'] = 'Символ табуляции';
$lang['help_ignored_if_upload'] = '(This field ignored if you use the Uploads module to manage files)';
$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'] = 'Переменная';
$lang['help_form_field'] = 'Поле представленно';
$lang['help_rtf_file_template'] = 'Specify a file located in the FormBuilder/templates/ folder. This field is ignored if you use TXT as your file type.';
$lang['help_rtf_template_type'] = 'Basic: Use the textarea below to layout the field names/values in a single block.<br />
Advanced: Specify Smarty variables in the RTF Template File as you would below, but arrange them however you like and add formatting.<br />
&nbsp;You can still use the %%HEADER%% and %%FOOTER%% sections in the RTF file.';
$lang['help_unique_file_template'] = 'For TXT, this will be immediately after the Header Template.<br />
For RTF, this will replace the %%FIELDS%% string in the template file if RTF Template Type is set to "Basic".<br />
This field will be ignored if using "RTF" as File Type and "Advanced" as RTF Template Type.';
$lang['help_file_header_template'] = 'For TXT, this will be placed at the top of the file. For RTF, this will replace the %%HEADER%% string in the template file.';
$lang['help_file_footer_template'] = 'For TXT, this will be placed at the bottom of the file. For RTF, this will replace the %%FOOTER%% string in the template file.';
$lang['link_back_to_form'] = '« Назад к форме';
$lang['title_create_sample_template'] = 'Создать простой шаблон';
$lang['title_create_sample_html_template'] = 'Создать простой HTML шаблон';
$lang['title_create_sample_header_template'] = 'Создать простой шаблон заголовка';
$lang['title_create_sample_footer_template'] = 'Создать простой шаблон футера';
$lang['title_create_sample_header'] = 'Создать простой заголовок';
$lang['help_tab_symbol'] = 'символ табуляции';
$lang['title_file_template'] = 'Шаблон для однострочного выходного файла';
$lang['title_file_header'] = 'Шаблон для заголовка выходного файла';
$lang['title_file_footer'] = 'Шаблон для подвала выходного файла';
$lang['title_rtf_file_template'] = 'Шаблон RTF файла для использования';
$lang['title_unique_file_template'] = 'Шаблон для вывода';
$lang['title_file_type'] = 'Выбрать тип файла для использования';
$lang['title_rtf_template_type'] = 'Выбрать тип шаблона RTF';
$lang['title_confirmation_url'] = 'URL to click for form confirmation';
$lang['title_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['title_submit_date'] = 'Дата отправки';
$lang['title_approval_date'] = 'Дата утверждения (администратора)';
$lang['title_user_approved'] = 'Дата утверждения (отправителя)';
$lang['display_text'] = 'Отображать "Шаблон отправки"';
$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'] = 'Страница назначения';
$lang['title_require_fieldnames'] = 'Обязательны имена полей';
$lang['title_require_fieldnames_long'] = 'Обязательные поля имеют названия?';
$lang['title_unique_fieldnames'] = 'Обязательны уникальные имена полей';
$lang['title_unique_fieldnames_long'] = 'Обязательные поля имеют уникальные названия?';
$lang['title_reorder_form'] = 'Изменить порядок полей';
$lang['title_load_template'] = 'Загрузить шаблон';
$lang['title_add_button_text'] = 'Текст кнопки добавления/создания';
$lang['title_del_button_text'] = 'Текст кнопки удаления';
$lang['title_field_helptext'] = 'Справка-текст, отображаемый с этим полем';
$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_string_unspaced'] = 'Строка (без пробелов между полями)?';
$lang['title_compute_value'] = 'Значение для расччета';
$lang['title_compute'] = 'Computed/PHP';
$lang['title_string'] = 'Строка';
$lang['title_numeric'] = 'Число';
$lang['title_inline_form'] = 'Показывать форму встроенной?';
$lang['title_inline_form_help'] = 'Встроенная означает, что последующая форма заменяет тег {cms_module}, невстроенная заменяет тег {content}.';
$lang['title_field_default_value'] = 'Значение поля по умолчанию';
$lang['title_clear_default'] = 'Очистить значение по умолчанию при клике?';
$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 для поля';
$lang['title_field_javascript_long'] = 'Make this the complete Javascript call, including the event you want to trap, например, 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'] = 'Нужно больше типов полей?';
$lang['title_switch_basic'] = 'Слишком много типов полей?';
$lang['title_switch_advanced_link'] = 'Переключиться на расширенный режим';
$lang['title_switch_basic_link'] = 'Переключить на простой режим';
$lang['title_file_root'] = 'Каталог для сохранения файла в';
$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.<br />
If left blank, this will default to your default uploads directory ($config[\'uploads_path\']).';
$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'] = 'Отправить мне копию формы';
$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['title_display_length'] = 'Показать длину';
$lang['title_minimum_length'] = 'Минимальная длина ответа';
$lang['title_hide'] = 'Скрыть поле ввода';
$lang['title_hide_help'] = 'Show symbols rather plain text when user enters password?';
$lang['password_does_not_match'] = 'Пароль не совпадает %s';
$lang['back_top'] = 'Вернуться к главной странице Конструктора форм';
$lang['title_headers_to_modify'] = 'Which email headers should this input populate?';
$lang['title_blank_invalid'] = 'Do not accept blank space as valid response';
$lang['title_blank_invalid_long'] = 'If a field is required, checking this will require that people put in some alphanumeric characters, not just spaces';
$lang['title_must_save_order'] = 'You must click one of the "save" buttons to make your new field order permanent.';
$lang['title_html5'] = 'Use HTML5 placeholder text instead of Javascript';
$lang['error_CompanyDirectory_module_not_available'] = 'Модуль Company Directory не доступен!';
$lang['option_never'] = 'Никогда';
$lang['option_user_choice'] = 'Дать пользователю выбор (checkbox)';
$lang['option_always'] = 'Всегда';
$lang['option_from'] = '"От кого" email адрес';
$lang['option_reply'] = '"Куда" почтовый адрес';
$lang['option_both'] = 'Both "From" and "Reply-To" email addresses';
$lang['option_dropdown'] = 'Dropdown';
$lang['option_selectlist_single'] = 'Select List (single)';
$lang['option_selectlist_multiple'] = 'Select List (multiple)';
$lang['option_radiogroup'] = 'Radio Group';
$lang['title_company_field_note'] = 'Note: Output will be in the form of<br/>"company name"=>"value"';
$lang['title_pick_categories'] = 'Pick a category (multiple)';
$lang['title_pick_fielddef'] = 'Pull a field Definition\'s value (single) <em>optional</em>';
$lang['title_choose_user_input'] = 'Choose User input';
$lang['title_see_also_udt'] = '(Also take a look at the Form Submission tab if you want to set a UDT for form validation)';
$lang['title_year_end_message'] = 'End year';
$lang['title_field_logic'] = 'Данные или логика Smarty, которые должны быть отправлены с этим полем';
$lang['title_field_logic_long'] = 'Может быть данные Smarty, javascript или другие данные, которые вы хотите отправить вместе с этим полем,<br />будут проходить через компилятор Smarty, не забудьте использовать тег {literal}{/literal} вместе с <script></script>.';
$lang['title_field_includelabels'] = 'Подключать подписи(метки)';
$lang['title_field_includelabels_help'] = 'Enabling this includes labels to output. example - label: value,label2: value2';
$lang['title_field_siblings'] = 'Link this field to it\'s sibling';
$lang['title_field_siblings_help'] = 'Dropdown lists all siblings of this field and allows you to link this field to one of it\'s sibling. Makes possible controlling this field with selected sibling controls.';
$lang['title_field_hidebuttons'] = 'Hide control buttons';
$lang['title_field_hidebuttons_help'] = 'Hides frontend control buttons of this field.';
$lang['title_note'] = 'Примечание';
$lang['title_changing_triggers_reindex'] = 'Changing any of the above fields will trigger a reindex of *all* saved records, so it could take a while.';
$lang['illegal_file'] = 'Attempted upload of illegal file type (%s) from %s';
$lang['title_searchable'] = 'Make records accessible to Search Module';
$lang['title_searchable_help'] = 'Checking this will make all submitted data accessible to the Search Module. DO NOT use this if you encrypt your data -- the information gets exposed to search whether or not it is encrypted!';
$lang['uploaded_outside_webroot'] = '%s (outside web root)';
$lang['title_fbr_edit'] = 'Editable in FormBrowser Admin?';
$lang['error_usertag_disposition'] = 'User defined tag returned an error';
$lang['error_usertag'] = 'User defined tag %s returned an error.';
$lang['error_cataloger_module_not_available'] = '<strong>Модуль Cataloger не установлен или не активен.</strong>';
$lang['warning'] = 'ПРЕДУПРЕЖДЕНИЕ!';
$lang['default_template'] = 'Шаблон по умолчанию';
$lang['table_left_template'] = 'Табличный шаблон, подписи слева';
$lang['table_top_template'] = 'Табличный шаблон, подписи сверху';
$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'] = 'Ошибка при расчете "%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'] = 'Добавление, изменение и управление работой интерактивных форм';
$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['help_module_interface'] = 'Использование интерфейса модуля';
$lang['help_module_interface_long'] = '<b>This field is used as a gateway to other modules!</b>
Use it by creating your form elements in the templates of the other module(s) you wish to incorporate, and using the <strong>{$FBid}</strong> to tie it back to FormBuilder. For example, to include form options based on the Products module, create the following template in Products:<br/>
<pre>
{foreach from=$items item=entry}
	{assign var=MData value=\'\'}
	{assign var=Cd value=\'\'}
		{foreach from=$FBvalue item=MData}
			{assign var=MData value=\'::\'|explode:$MData}
			{if $MData[1]==$entry->id}
				{assign var=Cd value=\' checked="checked"\'}
			{/if}
		{/foreach}
	<div class="ProductDirectoryItem">
		<input type="checkbox" value="{$entry->price}::{$entry->id}" name="{$FBid}[]" {$Cd} />{$entry->product_name} ({$entry->weight}{$weight_units}) £{$entry->price}    
	</div>
{/foreach}
</pre>
<br/>
where in the input below you put something like <strong>{Products category="cat" summarytemplate="Your_FB_template"}</strong>';
$lang['title_add_tag'] = 'Добавить свой тег';
$lang['date_january'] = 'январь';
$lang['date_february'] = 'февраль';
$lang['date_march'] = 'март';
$lang['date_april'] = 'апрель';
$lang['date_may'] = 'май';
$lang['date_june'] = 'июнь';
$lang['date_july'] = 'июль';
$lang['date_august'] = 'август';
$lang['date_september'] = 'сентябрь';
$lang['date_october'] = 'октябрь';
$lang['date_november'] = 'ноябрь';
$lang['date_december'] = 'декабрь';
$lang['AF'] = 'Афганистан';
$lang['AX'] = 'Аландские острова';
$lang['AL'] = 'Албания';
$lang['DZ'] = 'Алжир';
$lang['AS'] = 'Американское Самоа';
$lang['AD'] = 'Андорра';
$lang['AO'] = 'Ангола';
$lang['AI'] = 'Ангилья';
$lang['AQ'] = 'Антарктида';
$lang['AG'] = 'Антигуа и Барбуда';
$lang['AR'] = 'Аргентина';
$lang['AM'] = 'Армения';
$lang['AW'] = 'Аруба';
$lang['AU'] = 'Австралия';
$lang['AT'] = 'Австрия';
$lang['AZ'] = 'Азербайджан';
$lang['BS'] = 'Багамские острова';
$lang['BH'] = 'Бахрейн';
$lang['BB'] = 'Барбадос';
$lang['BD'] = 'Бангладеш';
$lang['BY'] = 'Беларусь';
$lang['BE'] = 'Бельгия';
$lang['BZ'] = 'Белиз';
$lang['BJ'] = 'Бенин';
$lang['BM'] = 'Бермудские острова';
$lang['BT'] = 'Бутан';
$lang['BW'] = 'Ботсвана';
$lang['BO'] = 'Боливия';
$lang['BA'] = 'Босния и Герцеговина';
$lang['BV'] = 'Остров Буве';
$lang['BR'] = 'Бразилия';
$lang['IO'] = 'Британская территория в Индийском океане';
$lang['BN'] = 'Бруней-Даруссалам';
$lang['BG'] = 'Болгария';
$lang['BF'] = 'Буркина-Фасо';
$lang['BI'] = 'Бурунди';
$lang['KH'] = 'Камбоджа';
$lang['CM'] = 'Камерун';
$lang['CA'] = 'Канада';
$lang['CV'] = 'Кабо-Верде';
$lang['KY'] = 'Каймановы острова';
$lang['CF'] = 'Центрально-Африканская Республика';
$lang['TD'] = 'Чад';
$lang['CL'] = 'Чили';
$lang['CN'] = 'Китай';
$lang['CX'] = 'Остров Рождества';
$lang['CC'] = 'Кокосовые (Килинг) острова';
$lang['CO'] = 'Колумбия';
$lang['KM'] = 'Коморские острова';
$lang['CG'] = 'Конго';
$lang['CD'] = 'Демократическая Республика Конго';
$lang['CK'] = 'Острова Кука';
$lang['CR'] = 'Коста-Рика';
$lang['CI'] = 'Д\'Ивуар (Берег Слоновой Кости)';
$lang['HR'] = 'Хорватия (Hrvatska)';
$lang['CU'] = 'Куба';
$lang['CY'] = 'Кипр';
$lang['CZ'] = 'Чешская Республика';
$lang['DK'] = 'Дания';
$lang['DJ'] = 'Джибути';
$lang['DM'] = 'Доминика';
$lang['DO'] = 'Доминиканская Республика';
$lang['TP'] = 'Восточный Тимор';
$lang['EC'] = 'Эквадор';
$lang['EG'] = 'Египет';
$lang['SV'] = 'Сальвадор';
$lang['GQ'] = 'Экваториальная Гвинея';
$lang['ER'] = 'Эритрея';
$lang['EE'] = 'Эстония';
$lang['ET'] = 'Эфиопия';
$lang['FK'] = 'Фолклендские (Мальвинские) острова';
$lang['FO'] = 'Фарерские острова';
$lang['FJ'] = 'Фиджи';
$lang['FI'] = 'Финляндия';
$lang['FR'] = 'Франция';
$lang['FX'] = 'Франция, митрополит';
$lang['GF'] = 'Гернси';
$lang['PF'] = 'Французская Полинезия';
$lang['TF'] = 'Французские южные территории';
$lang['MK'] = 'F.Y.R.O.M. (Македония)';
$lang['GA'] = 'Габон';
$lang['GM'] = 'Гамбия';
$lang['GE'] = 'Грузия';
$lang['DE'] = 'Германия';
$lang['GH'] = 'Гана';
$lang['GI'] = 'Гибралтар';
$lang['GB'] = 'Великобритания (UK)';
$lang['GR'] = 'Греция';
$lang['GL'] = 'Гренландия';
$lang['GD'] = 'Гренада';
$lang['GP'] = 'Гваделупа';
$lang['GU'] = 'Гуам';
$lang['GT'] = 'Гватемала';
$lang['GN'] = 'Гвинея';
$lang['GW'] = 'Гвинея-Бисау';
$lang['GY'] = 'Гайана';
$lang['HT'] = 'Гаити';
$lang['HM'] = 'Херд и Макдональд';
$lang['HN'] = 'Гондурас';
$lang['HK'] = 'Гонконг';
$lang['HU'] = 'Венгрия';
$lang['IS'] = 'Исландия';
$lang['IN'] = 'Индия';
$lang['ID'] = 'Индонезия';
$lang['IR'] = 'Иран';
$lang['IQ'] = 'Ирак';
$lang['IE'] = 'Ирландия';
$lang['IL'] = 'Израиль';
$lang['IM'] = 'Остров Мэн';
$lang['IT'] = 'Италия';
$lang['JE'] = 'Джерси';
$lang['JM'] = 'Ямайка';
$lang['JP'] = 'Япония';
$lang['JO'] = 'Иордания';
$lang['KZ'] = 'Казахстан';
$lang['KE'] = 'Кения';
$lang['KI'] = 'Кирибати';
$lang['KP'] = 'Корея (North)';
$lang['KR'] = 'Корея (South)';
$lang['KW'] = 'Кувейт';
$lang['KG'] = 'Кыргызстан';
$lang['LA'] = 'Лаос';
$lang['LV'] = 'Латвия';
$lang['LB'] = 'Ливан';
$lang['LI'] = 'Лихтенштейн';
$lang['LR'] = 'Либерии';
$lang['LY'] = 'Ливия';
$lang['LS'] = 'Лесото';
$lang['LT'] = 'Литва';
$lang['LU'] = 'Люксембург';
$lang['MO'] = 'Макао';
$lang['MG'] = 'Мадагаскар';
$lang['MW'] = 'Малави';
$lang['MY'] = 'Малайзия';
$lang['MV'] = 'Мальдивы';
$lang['ML'] = 'Мали';
$lang['MT'] = 'Мальта';
$lang['MH'] = 'Маршалловы острова';
$lang['MQ'] = 'Мартиника';
$lang['MR'] = 'Мавритания';
$lang['MU'] = 'Маврикий';
$lang['YT'] = 'Майотта';
$lang['MX'] = 'Мексика';
$lang['FM'] = 'Микронезия';
$lang['MC'] = 'Монако';
$lang['MD'] = 'Молдова';
$lang['MA'] = 'Морокко';
$lang['MN'] = 'Монголия';
$lang['MS'] = 'Монтсеррат';
$lang['MZ'] = 'Мозамбик';
$lang['MM'] = 'Мьянмы';
$lang['NA'] = 'Намибия';
$lang['NR'] = 'Науру';
$lang['NP'] = 'Непал';
$lang['NL'] = 'Нидерланды';
$lang['AN'] = 'Нидерландские Антильские острова';
$lang['NT'] = 'Нейтральная зона';
$lang['NC'] = 'Новая Каледония';
$lang['NZ'] = 'Новая Зеландия (Аотеароа)';
$lang['NI'] = 'Никарагуа';
$lang['NE'] = 'Нигер';
$lang['NG'] = 'Нигерия';
$lang['NU'] = 'Ниуэ';
$lang['NF'] = 'Остров Норфолк';
$lang['MP'] = 'Северные Марианские острова';
$lang['NO'] = 'Норвегия';
$lang['OM'] = 'Оман';
$lang['PK'] = 'Пакистан';
$lang['PW'] = 'Палау';
$lang['PS'] = 'Палестинская территория';
$lang['PA'] = 'Панама';
$lang['PG'] = 'Папуа-Новая Гвинея';
$lang['PY'] = 'Парагвай';
$lang['PE'] = 'Перу';
$lang['PH'] = 'Филиппины';
$lang['PN'] = 'Питкэрн';
$lang['PL'] = 'Польша';
$lang['PT'] = 'Португалия';
$lang['PR'] = 'Пуэрто Рико';
$lang['QA'] = 'Катар';
$lang['RE'] = 'Воссоединение';
$lang['RO'] = 'Румыния';
$lang['RU'] = 'Россияская Федерация';
$lang['RW'] = 'Руанда';
$lang['GS'] = 'S. Georgia and S. Sandwich Isls. ';
$lang['KN'] = 'Сент-Китс и Невис';
$lang['LC'] = 'Сент-Люсия';
$lang['VC'] = 'Saint Vincent & the Grenadines';
$lang['WS'] = 'Самоа';
$lang['SM'] = 'Сан - Марино';
$lang['ST'] = 'Сан-Томе и Принсипи';
$lang['SA'] = 'Саудовская Аравия';
$lang['SN'] = 'Сенегал';
$lang['SC'] = 'Сейшельские острова';
$lang['SL'] = 'Сьерра-Леоне';
$lang['SG'] = 'Сингапур';
$lang['SI'] = 'Словения';
$lang['SK'] = 'Словацкая Республика';
$lang['SB'] = 'Соломоновы Острова';
$lang['SO'] = 'Сомали';
$lang['ZA'] = 'Южная Африка';
$lang['ES'] = 'Испания';
$lang['LK'] = 'Шри-Ланка';
$lang['SH'] = 'Св. Елены';
$lang['PM'] = 'Сен-Пьер и Микелон';
$lang['SD'] = 'Судан';
$lang['SR'] = 'Суринам';
$lang['SJ'] = 'Svalbard & Jan Mayen Islands';
$lang['SZ'] = 'Свазиленд';
$lang['SE'] = 'Швеция';
$lang['CH'] = 'Швейцария';
$lang['SY'] = 'Сирия';
$lang['TW'] = 'Тайвань';
$lang['TJ'] = 'Таджикистан';
$lang['TZ'] = 'Танзания';
$lang['TH'] = 'Тайланд';
$lang['TG'] = 'Того';
$lang['TK'] = 'Токелау';
$lang['TO'] = 'Тонга';
$lang['TT'] = 'Тринидад и Тобаго';
$lang['TN'] = 'Тунис';
$lang['TR'] = 'Турция';
$lang['TM'] = 'Туркменистан';
$lang['TC'] = 'Острова Теркс и Кайкос';
$lang['TV'] = 'Тувалу';
$lang['UG'] = 'Уганда';
$lang['UA'] = 'Украина';
$lang['AE'] = 'Объединенные Арабские Эмираты';
$lang['UK'] = 'Соединенное Королевство';
$lang['US'] = 'Соединенные Штаты';
$lang['UM'] = 'США Внешние малые острова';
$lang['UY'] = 'Уругвай';
$lang['UZ'] = 'Узбекистан';
$lang['VU'] = 'Вануату';
$lang['VA'] = 'Государство-город Ватикан (Святейший Престол)';
$lang['VE'] = 'Венесуэла';
$lang['VN'] = 'Вьетнам';
$lang['VG'] = 'Виргинские острова (Британские)';
$lang['VI'] = 'Виргинские острова (США)';
$lang['WF'] = 'Острова Уоллис и Футуна';
$lang['EH'] = 'Западная Сахара';
$lang['YE'] = 'Йемен';
$lang['YU'] = 'Югославия';
$lang['ZM'] = 'Замбия';
$lang['ZW'] = 'Зимбабве';
$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'] = 'Не могу найти модуль отправки';
$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 еще не готов!';
$lang['missing_cms_mailer'] = 'FormBuilder: Не удается обнаружить необходимый модуль 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'] = 'ID формы для внутренних операций';
$lang['formbuilder_params_general'] = 'Общие параметры для внутренних операций';
$lang['template_variable_help'] = '<h3>Переменные шаблона формы</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->helptext</td><td>the field\'s help text</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->alias</td><td>the alias specified for this field</td></tr>
<tr><td>field->id</td><td>the internal / opaque id FormBuilder uses for this field</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 the case of a multipage form, you will also have access to the value of previous fields. They
are in the $previous array, or accessible by their names (e.g., {$myfield->value} ).
You can use this in Static Text fields as well, which is a nice way to personalize forms!</p>

<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>in_formbrowser</td><td>1 if form is being viewed from FormBrowser</td></tr>
<tr><td>in_admin</td><td>1 if form is being viewed via FormBrowser admin</td></tr>
<tr><td>fbr_id</td><td>Response ID if form is being viewed from FormBrowser</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'] = 'FormBuilder установлен. Пожалуйста, ознакомьтесь с  документацией на странице справки  модуля.';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create 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 {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 ("), 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>Button. This doens\'t do anything, but you can hook it into some Javascript.</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>Password. This is an asterisked-out text field, useful for passwords.</li>
<li>Password Again (verify). This is a field that must match a Password field for submission
to succeed.</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>
<li>-User Tag. This calls the specified User Defined Tag, and displays anything it returns. The UDT gets called any time the field would be visible.</li>
</ul></li>
<li>-Module Include Tag. This allows you to embed other module output into your form, e.g., a list of products from the Products module.</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 $params[\'field_name\'], and as $params[\'field_alias\'] (if defined).</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 "From Address" Field, and send copy. This works like the Email "From Address" Field described above, but it provides options for sending a copy of the results to the user.</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 results based on frontend fields. This field is an email disposition that allows form fields\' user input to specify the Email Subject, "From Name", "From Address", and Destination Email Address.</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. <strong>Deprecated.</strong> Use Store Results for FormBrowser Module instead! 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>*Write Results to a Unique Flat File for each submission. This takes the form results and writes them to a unique text file for each form submission.
You can specify a filename pattern using values from form fields, set its format, and set the directory where the files will be stored.</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.0.3. Stores the form results in an XML structure as a single database record. This is the only interface to Form Browser. See section below.</li>
<li>*Submit to an arbitrary form action. Craft an HTTP GET or POST, and transmit it using cURL to the specified URL. This lets you use FormBuilder as a front-end to any CGI or Form Handling script out there.</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>{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 unwieldy or contain characters that don\'t work well with Smarty. So there is an
alternative like this:</p>
<p>{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 its 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. As of version 0.5, variables also have aliases, which you can use.</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>Use with FormBrowser v3</h3>
<p>There are some special features when using FormBuilder with FormBrowser. The new approach stores the form results in XML, so that far fewer
queries are needed to retrieve records. This means you can use FormBrowser with hundreds or even thousands of records. It also means you
will have to choose up front which fields you will want to be able to sort by. You can choose up to five. Changing these after there are submitted records will result in improper sorting! A re-index function will be added to a future version.</p>
<p>In advanced options, you can tie a form to Frontend Users. That means each user gets one record for the form; they can create it
a single time, subsequent times they will be editing their record. The record will not be visible to any other users (excluding admins).
This form should be added to your page using the syntax {FormBuilder action=\'feuserform\' form=\'form_name\'}.</p>
<p>For greater data safety, you can encrypt the stored forms in the database. You can use the built-in mycrypt library or the OpenSSL module.
In either case, for the passphrase, you can either enter text in the field or a file name. If you specify a file name, the contents of that
file will be used as the passphrase for encrypting.</p>
<p>If you encrypt, be aware that the fields you use for sorting are <strong>not</strong> encrypted. You can choose to hash them; the cheat here
is that the first four letters are left intact to allow for sorting. The sorting may not be perfect, and this weakens the security since it
exposes some cleartext, but it is better than nothing.</p>
<p><strong>DISCLAIMER</strong>. The encryption offered here should be considered just one more hurdle for a hacker, not as a guarantee that
your information will be secure. A smart hacker who has found some exploit to view database records may well be smart enough to get at
the module source code, and find their way to the passphrase. This will not protect you against an enemy who has full access to your
server, some familiarity with PHP, and the time to poke around. <em><strong>Do not</strong> use this to protect high-value information such as financial data,
sensitive political information, human rights data, or anything else that might be of value to a repressive government or organized crime
cartel.</em></p>
<h3>Using with User Defined Tags (UDTs)</h3>
<p>Several options for customizing behavior via UDTs is provided (thanks to kind code contributions, see credits).</p>

<ul><li>Call User Defined Tag With the Form Results. This field type submits the human-readable form results to the User-Defined
Tag you specify. The UDT can handle the results however it wants. Values are passed as $params[\'field_name\'], and
as $params[\'field_alias\'] (if defined). As per a suggestion, it also populates all of the Smarty values that would be visible to the Submission Template too!</li>
<li>User Tag Field. This calls the specified UDT, and displays anything it returns. The UDT gets called any time the field would be visible.</li>
<li>Validation UDT. Set this for a form, and the UDT will receive all of the form\\\'s human-readable results. The UDT should do whatever
validation it wants, and return an array with the first value being true or false (indication whether the form validates), and the second
value being error messages (if any).</li>
<li>User defined tag to call before form is displayed the first time (only called once). This
is set in the Form Admin in the UDT Integration tab. The UDT gets called on the first display
of the form.</li>
<li>User defined tag to call before form is displayed (called on every page of multipage
forms). This is set in the Form Admin in the UDT Integration tab. The UDT gets called
every time any page of the form is displayed (including when validation fails).</li>
</ul>
<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>Run in MLE Mode. This changes some queries against the content table to try to prevent ugly crashes under the MLE fork. Checking this will cause ugly crashes if you are NOT running the MLE fork.</li>
<li>Hide Errors. This is no longer set by default. Checking it will hide the more detailed errors that would 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>After a bit of nagging on the part of people who actually respect standards, FormBuilder no longer encourages tricks like embedding CSS in 
static text fields. Instead, it creates a stylesheet called "FormBuilder Default" that you are encouraged to attach to the page template
that you use for pages that contain your form.</p>  
<p>This default CSS was graciously provided by Paul Noone.</p>


<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->helptext</td><td>the field\'s help text</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->alias</td><td>the alias specified for this field</td></tr>
<tr><td>field->id</td><td>the internal / opaque id FormBuilder uses for this field</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 the case of a multipage form, you will also have access to the value of previous fields. They
are in the $previous array, or accessible by their names (e.g., {$myfield->value} ).
You can use this in Static Text fields as well, which is a nice way to personalize forms!</p>

<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>in_formbrowser</td><td>1 if form is being viewed from FormBrowser</td></tr>
<tr><td>in_admin</td><td>1 if form is being viewed via FormBrowser admin</td></tr>
<tr><td>fbr_id</td><td>Response ID if form is being viewed from FormBrowser</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>Credits</h3>
<p>Many people have contributed code, bug reports, cash, and ideas to FormBuilder. Among them (alphabetically):
<ul>
<li><a href="http://www.bpti.eu">Baltic institute of advanced technology</a> - code, funding </li>
<li>Jeremy Bass - code and suggestions</li>
<li>Alberto Benati - code</li>
<li>Tyler Boespflug - funding and ideas</li>
<li>Jeff Bosch - UDT Validation</li>
<li>Robert Campbell - numerous code contributions</li>
<li>Piotras Cimmperman - code</li>
<li>Nuno Costa - suggestions</li>
<li>Ryan Foster - code</li>
<li>Marc Geldon - code</li>
<li>Kevin Grandon - code</li>
<li>Ronny Krijt - code</li>
<li>Paul Noone - CSS and ideas</li>
<li>Morten Poulsen - code</li>
<li>Prue Rowland - bug fixes</li>
<li>Simon Schaufelberger - code</li>
<li>Adam Shaw-Vardi - funding and ideas</li>
</ul>
<p>I apologize for any omissions - notify me, and I\'ll correct the omission!</p>
<h3>Miscellaneous Notes</h3>
<ul>
<li>Any fields that sends email to a specified email address will also accept a comma-separated list of email addresses.</li>
</ul>
<h3>Known Issues</h3>
<ul>
<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>FormBuilder/FormBrowser <strong>requires</strong> PHP 5 or later to function correctly.</li>
<li>First step is to check you\'re running CMS 1.6 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> Make sure you can successfully send email via the test in the CMSMailer Module. It\'s simply amazing how many problems boil down to a misconfigured CMSMailer.</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>
<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 <em>hundreds and hundreds of hours</em> 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><form action="https://www.paypal.com/cgi-bin/webscr" method="post">
<input type="hidden" name="cmd" value="_s-xclick">
<input type="image" src="https://www.paypal.com/en_US/i/btn/btn_donateCC_LG.gif" border="0" name="submit" alt="PayPal - The safer, easier way to pay online!">
<img alt="" border="0" src="https://www.paypal.com/en_US/i/scr/pixel.gif" width="1" height="1">
<input type="hidden" name="encrypted" value="-----BEGIN PKCS7-----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-----END PKCS7-----
">
</form><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 © 2009, 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['utma'] = '156861353.750739657.1301355191.1306223606.1306231165.31';
$lang['utmz'] = '156861353.1306174044.26.3.utmccn=(referral)|utmcsr=dev.cmsmadesimple.org|utmcct=/bug/view/6338|utmcmd=referral';
$lang['qca'] = 'P0-2080502483-1301355191073';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353.1.10.1306231165';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/sk_SK.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Formul&aacute;re';
$lang['field_type_'] = 'Typ poľa nebol definovan&yacute;';
$lang['field_type_CatalogerItemsField'] = 'Vybrať jeden alebo viacero položiek katal&oacute;gu (cataloger)';
$lang['field_type_FieldsetEnd'] = 'Koniec pre značku Fieldset';
$lang['field_type_FieldsetStart'] = 'Začiatok pre značku Fieldset ';
$lang['field_type_TextField'] = 'Textov&eacute; pole';
$lang['field_type_TextFieldExpandable'] = 'Textov&eacute; pole (viacn&aacute;sobn&eacute;)';
$lang['field_type_TextAreaField'] = 'Textov&eacute; oblasť';
$lang['field_type_CheckboxField'] = 'Za&scaron;krt&aacute;vacie pole';
$lang['field_type_CheckboxGroupField'] = 'Skupina za&scaron;krt&aacute;va&iacute;ch pol&iacute;čok';
$lang['field_type_PulldownField'] = 'V&yacute;berov&eacute; pole';
$lang['field_type_MultiselectField'] = 'Viacv&yacute;berov&eacute; pole';
$lang['field_type_StatePickerField'] = 'V&yacute;berov&eacute; pole pre &scaron;t&aacute;ty';
$lang['field_type_ProvincePickerField'] = 'V&yacute;berov&eacute; pole pre provincie v Kanade';
$lang['field_type_CountryPickerField'] = 'V&yacute;berov&eacute; pole pre USA &scaron;t&aacute;ty';
$lang['field_type_DatePickerField'] = 'V&yacute;berov&eacute; pole pre d&aacute;tum';
$lang['field_type_TimePickerField'] = 'V&yacute;berov&eacute; pole pre čas';
$lang['field_type_RadioGroupField'] = 'Skupina radio poličok';
$lang['field_type_DispositionDirector'] = '*Zasielanie na e-maily na z&aacute;klade v&yacute;berov&eacute;ho poľa';
$lang['field_type_DispositionFileDirector'] = '*Ukladanie do s&uacute;bora na z&aacute;klade v&yacute;berov&eacute;ho poľa';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Ukladanie do s&uacute;borov na z&aacute;klade viacn&aacute;sobn&eacute;ho v&yacute;berov&eacute;ho poľa';
$lang['field_type_DispositionPageRedirector'] = '*Str&aacute;nka pre presmerovania na z&aacute;klade v&yacute;berov&eacute;ho poľa';
$lang['field_type_DispositionEmail'] = '*Zasielanie na vybran&eacute; e-mailov&eacute; adresy';
$lang['field_type_DispositionEmailConfirmation'] = '*Validate-via-Email Address';
$lang['field_type_DispositionFromEmailAddressField'] = '*Pole  &quot;z e-mailu&quot; pre odpoved, a zaslanie k&oacute;pie už&iacute;vateľovi';
$lang['field_type_DispositionFile'] = '*Uložiť formul&aacute;r do s&uacute;bora';
$lang['field_type_DispositionDatabase'] = '*Uložiť formul&aacute;r do DB';
$lang['field_type_DispositionFormBrowser'] = '*Uložiť formul&aacute;r pre modul prehliadača formul&aacute;rov v&eacute;rzie .3';
$lang['field_type_DispositionUserTag'] = '*Zavolať už&iacute;vateľsk&yacute; tag po dokončen&iacute;';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Pole pre e-mail, na ktor&yacute; bude z&aacute;roveň zaslan&yacute; e-mail';
$lang['field_type_DispositionEmailSiteAdmin'] = '*E-mail pre administr&aacute;tora CMS';
$lang['field_type_PageBreakField'] = '-zalomenie';
$lang['field_type_FileUploadField'] = 'Nahratie s&uacute;bora';
$lang['field_type_FromEmailAddressField'] = 'Email &quot;From Address&quot; Field';
$lang['field_type_FromEmailAddressAgainField'] = 'Pole  &quot;z e-mailu&quot; pre opakovan&eacute; zadanie ';
$lang['field_type_FromEmailNameField'] = 'Email &quot;From Name&quot; Field';
$lang['field_type_FromEmailSubjectField'] = 'Email &quot;Subject&quot; Field';
$lang['field_type_StaticTextField'] = '-Text';
$lang['field_type_SystemLinkField'] = '-Odkaz';
$lang['field_type_LinkField'] = 'Odkaz vložen&yacute; už&iacute;vateľom';
$lang['field_type_HiddenField'] = '-Skryt&eacute; pole';
$lang['field_type_ComputedField'] = '-Porovn&aacute;vanie';
$lang['field_type_UniqueIntegerField'] = '-Unik&aacute;tny reťazec';
$lang['validation_none'] = 'Bez kontroly';
$lang['validation_numeric'] = 'Č&iacute;slo';
$lang['validation_integer'] = 'Celoč&iacute;slen&aacute; hodnota';
$lang['validation_email_address'] = 'E-mailov&aacute; adresa';
$lang['validation_usphone'] = 'Telef&oacute;nne č&iacute;sle (pre USA)';
$lang['validation_must_check'] = 'Mus&iacute; byť  zadan&eacute;';
$lang['validation_regex_match'] = 'Regul&aacute;rny v&yacute;raz';
$lang['validation_regex_nomatch'] = 'Zhoda  s regul&aacute;rnym v&yacute;razom';
$lang['required_field_missing'] = 'Nebola vožena požadovan&aacute; hodnota';
$lang['please_enter_a_value'] = 'Pros&iacute;m, vložte hodnotu pre  &quot;%s&quot;';
$lang['please_enter_a_number'] = 'Pros&iacute;m, vložte č&iacute;seln&uacute; hodnotu pre  &quot;%s&quot;';
$lang['please_enter_valid'] = 'Pros&iacute;m, vložte spr&aacute;vnu hodnotu pre &quot;%s&quot;';
$lang['please_enter_an_integer'] = 'Pros&iacute;m, vložte celoč&iacute;seln&uacute; hodnotu pre  &quot;%s&quot;';
$lang['please_enter_an_email'] = 'Pros&iacute;m, vložte spr&aacute;vny tvar e-mailovej adresy pre  &quot;%s&quot;';
$lang['email_address_does_not_match'] = 'Nebol zadan&yacute; obsah pre e-mailov&uacute; adresu &quot;%s&quot;';
$lang['please_enter_a_phone'] = 'Pros&iacute;m, vložte spr&aacute;vny tvar pre telef&oacute;nne č&iacute;slo &quot;%s&quot;';
$lang['not_valid_email'] = '&quot;%s&quot; nie je spr&aacute;vny tvar e-mailovej adresy';
$lang['please_enter_no_longer'] = 'Pros&iacute;m, vložte obsah krat&scaron;&iacute; ako %s znakov';
$lang['title_list_delimiter'] = 'Znak sl&uacute;žiaci ako separ&aacute;tor pri viacer&yacute;ch hodnot&aacute;ch';
$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'] = 'Pole pre triedenie aktualizovan&eacute;';
$lang['form_deleted'] = 'Formul&aacute;r odstr&aacute;nen&yacute;';
$lang['field_deleted'] = 'Pole odstr&aacute;nen&eacute;';
$lang['configuration_updated'] = 'Nastavenia aktualizovan&eacute;';
$lang['you_must_check'] = 'Musite vybrať &quot;%s&quot; pre  pokračovanie';
$lang['must_specify_one_destination'] = 'Mus&iacute;te zadať aspoň jednu cieľov&uacute; adresu';
$lang['are_you_sure_delete_form'] = 'Naozaj chcete odstr&aacute;niť formul&aacute;r %s?';
$lang['are_you_sure_delete_field'] = 'Naozaj chcete odstr&aacute;niť pole %s?';
$lang['notice_select_type'] = 'Roz&scaron;&iacute;ren&eacute; vlasnosti nie s&uacute; dostupn&eacute; pokiaľ nebude zadan&yacute; typ poľa.';
$lang['field_name_in_use'] = 'N&aacute;zov poľa &quot;%s&quot; už existuje. Pros&iacute;m použite unik&aacute;tny n&aacute;zov, alebo v nastaveniach deaktivujte voľbu pre unik&aacute;tn&eacute; n&aacute;zvy pol&iacute;.';
$lang['field_no_name'] = 'Pole mus&iacute; mať n&aacute;zov';
$lang['anonymous'] = 'Anonym';
$lang['abbreviation_length'] = 'Len: %s';
$lang['boxes'] = '%s boxes';
$lang['options'] = '%s voľby';
$lang['text_length'] = '%s znakov';
$lang['order'] = 'Poradie';
$lang['unspecified'] = 'nezadan&eacute;';
$lang['added'] = 'pridan&eacute;';
$lang['updated'] = 'aktualizovan&eacute;';
$lang['sort_options'] = 'Trieť hodnoty na v&yacute;stupe';
$lang['select_one'] = 'Vybrať';
$lang['select_type'] = 'Vybrať typ';
$lang['to'] = 'Do';
$lang['yes'] = '&Aacute;no';
$lang['no'] = 'Nie';
$lang['recipients'] = 'pr&iacute;jimatelia';
$lang['file_count'] = '%s  povolen&eacute; s&uacute;bory';
$lang['destination_count'] = '%s ciele';
$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'] = 'Typ s&uacute;boru asi nem&ocirc;že byť nahran&yacute; na server. Pros&iacute;m skontrolujte či je tento typ povolen&yacute;';
$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'] = 'Vďaka! V&aacute;&scaron; formul&aacute;r bol odoslan&yacute;';
$lang['edit'] = 'Upraviť';
$lang['delete'] = 'Odstr&aacute;niť';
$lang['day'] = 'Deň';
$lang['mon'] = 'Mesiac';
$lang['year'] = 'Rok';
$lang['none'] = '(žiadny)';
$lang['css'] = 'CSS';
$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'] = 'Odoslať';
$lang['button_continue'] = 'Pokračovať...';
$lang['value_checked'] = 'Označiť';
$lang['value_unchecked'] = 'Odznačiť';
$lang['tab_main'] = 'Hlavn&eacute;';
$lang['tab_symbol'] = 'Nastavenia formul&aacute;ra';
$lang['tab_submit'] = 'Odoslanie formul&aacute;ra';
$lang['tab_captcha'] = 'Nastavenia pre Captcha';
$lang['tab_advanced'] = 'Roz&scaron;&iacute;ren&eacute; nastavenia';
$lang['tab_templatelayout'] = '&Scaron;abl&oacute;na';
$lang['tab_submissiontemplate'] = '&Scaron;abl&oacute;na po odoslan&iacute;';
$lang['canuse_smarty'] = '<em>Smarty premenn&eacute; su povolen&eacute; v tomto poli.</em>';
$lang['add_options'] = 'Pridať viac možnost&iacute;';
$lang['delete_options'] = 'Odstr&aacute;niť vyznačen&eacute;';
$lang['add_checkboxes'] = 'Pridať za&scaron;krt&aacute;vacie pole';
$lang['delete_checkboxes'] = 'Odstr&aacute;niť vybran&eacute;';
$lang['add_address'] = 'Pridať e-mailov&uacute; adresu';
$lang['delete_address'] = 'Odstr&aacute;niť vybran&eacute;';
$lang['add_destination'] = 'Pridať cieľ';
$lang['delete_destination'] = 'odstr&aacute;niť vybran&eacute;';
$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'] = 'Regul&aacute;rny v&yacute;raž povol&iacute; filtrovať katal&oacute;g (cataloger) pomocou n&aacute;zvu';
$lang['help_field_height'] = 'V&yacute;&scaron;ka viacn&aacute;sobn&eacute;ho v&yacute;berov&eacute;ho poľa';
$lang['title_name_regex'] = 'Regul&aacute;rny v&yacute;raz pre položku katal&oacute;gu (Cataloger)';
$lang['title_field_height'] = 'V&yacute;&scaron;ka poľa';
$lang['title_file_path'] = 'Cieľov&aacute; adresa pre s&uacute;bory na v&yacute;stupe';
$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'] = 'Odoslan&eacute; pomocou modulu Formul&aacute;ra';
$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'] = 'Cieľov&aacute; e-mailov&aacute; adresa';
$lang['title_destination_filename'] = 'Cieľov&yacute; n&aacute;zov s&uacute;boru';
$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'] = 'V&yacute;berov&eacute; pole pre zaslanie detailu formul&aacute;ra';
$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'] = 'Kontrola poľa';
$lang['title_field_to_validate'] = 'Pole pre kontrolu';
$lang['title_field_css_id'] = 'CSS id for this field';
$lang['title_form_css_class'] = 'CSS trieda pre tento formul&aacute;r';
$lang['title_field_css_class'] = 'CSS trieda pre toto pole';
$lang['title_form_predisplay_udt'] = 'User defined tag to call before form is displayed';
$lang['title_form_required_symbol'] = 'Znak pre označenie povinn&yacute;ch pol&iacute;';
$lang['title_field_required'] = 'Povinn&eacute;';
$lang['title_field_required_long'] = 'Vyžadovať kontrolu tohto poľa';
$lang['title_hide_label'] = 'Skryť popisok (label)';
$lang['title_hide_label_long'] = 'Hide this field&#039;s name on Form';
$lang['title_text'] = 'Text pre zobrazenie';
$lang['title_field_regex'] = 'Regul&aacute;rny v&yacute;raz pre kontrolu';
$lang['title_lines_to_show'] = 'Počet zobrazen&yacute;ch riadkov';
$lang['no_default'] = 'Bez prednastavenia';
$lang['redirect_after_approval'] = 'Str&aacute;nka pre presmerovanie po schv&aacute;len&iacute;';
$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'] = 'Skryť chyby';
$lang['title_form_displaytype'] = 'Typ pre zobrazenie formul&aacute;ra';
$lang['title_hide_errors_long'] = 'Prevent debug / error messages from being seen by users.';
$lang['title_email_template'] = '&Scaron;abl&oacute;na e-malu';
$lang['title_maximum_size'] = 'Maxim&aacute;lna veľkosť nahr&aacute;van&eacute;ho s&uacute;boru (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'] = 'Povolen&eacute; roz&scaron;&iacute;renia';
$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'] = 'Sabl&oacute;na pre zobrazenie formul&aacute;ra';
$lang['title_page_x_of_y'] = 'Strana %s z %s';
$lang['title_no_advanced_options'] = 'Pole nem&aacute; rož&iacute;ren&eacute; nastavenia';
$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'] = 'R&yacute;chle prid&aacute;vanie pol&iacute;';
$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'] = 'Zapn&uacute;ť jednotuchy anti-spam filter?';
$lang['title_show_fieldids'] = 'Uk&aacute;zať IDčka pol&iacute;';
$lang['title_show_fieldids_long'] = 'Clicking this will allow displaying field ids when adding or editing a form';
$lang['title_xml_to_upload'] = 'Nahrať formul&aacute;r z XML s&uacute;boru';
$lang['title_xml_upload_formname'] = 'Použiť tento n&aacute;zov formul&aacute;ra';
$lang['title_import_legend'] = 'XML import formul&aacute;ra';
$lang['title_xml_upload_formalias'] = 'Použiť tento alias formul&aacute;ra';
$lang['title_html_email'] = 'Generovať HTML e-mail?';
$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'] = 'Prednastaven&aacute; URL';
$lang['title_default_link_title'] = 'Prednastaven&yacute; odkaz textu';
$lang['title_link_to_sitepage'] = 'Odkaz na str&aacute;nku';
$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'] = 'Použiť Captcha ochanu pred spamom?';
$lang['title_use_captcha_help'] = 'Pozrieť inform&aacute;cie o <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 nebola op&iacute;san&aacute; spr&aacute;vne';
$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'] = 'Odkaz pre popis';
$lang['link_destination'] = 'Link Destination URL';
$lang['title_default_set'] = 'Checked by Default?';
$lang['title_24_hour'] = 'Použiť 24hodinov&yacute; čas?';
$lang['title_before_noon'] = 'AM';
$lang['title_after_noon'] = 'PM';
$lang['title_smarty_eval'] = 'Process smarty tags within field?';
$lang['title_textarea_rows'] = 'Riadky (poznamka:m&ocirc;žete meniť aj pomocou CSS)';
$lang['title_textarea_cols'] = 'Stĺpce  (pozn&aacute;mka: m&ocirc;žete meniť aj pomocou 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'] = 'Zobraziť už&iacute;vateľovi?';
$lang['help_leaveempty'] = 'Toto pole m&ocirc;že byť pr&aacute;zdne';
$lang['help_variables_for_template'] = 'Premenne pre &scaron;abl&oacute;nu';
$lang['help_variables_for_computation'] = 'Dostupn&eacute; premenn&eacute;';
$lang['help_php_variable_name'] = 'PHP premenn&eacute;';
$lang['help_submission_date'] = 'D&aacute;tum odoslania';
$lang['help_server_name'] = 'V&aacute;&scaron; server';
$lang['help_sub_source_ip'] = 'IP adresa odosielateľa';
$lang['help_sub_url'] = 'URL str&aacute;nky obsahuj&uacute;cej formul&aacute;r';
$lang['help_fb_version'] = 'Verzia modulu formul&aacute;ra';
$lang['help_tab'] = 'Znakov&aacute; sada';
$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'] = 'Premenn&aacute;';
$lang['help_form_field'] = 'Field Represented';
$lang['link_back_to_form'] = '&laquo; Back to Form';
$lang['title_create_sample_template'] = 'Vytvoriť uk&aacute;žku &scaron;abl&oacute;ny';
$lang['title_create_sample_html_template'] = 'Vytvoriť uk&aacute;žku HTML &scaron;abl&oacute;ny';
$lang['title_create_sample_header_template'] = 'Vytvoriť uk&aacute;žku hlavičky &scaron;abl&oacute;ny';
$lang['title_create_sample_header'] = 'Vytvoriť uk&aacute;žku hlavičky';
$lang['help_tab_symbol'] = 'znakov&aacute; sada';
$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'] = 'Polia pre triedenie #%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'] = 'Prednastaven&yacute; rok';
$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'] = 'Zobraziť &quot;&scaron;abl&oacute;nu po odoslan&iacute;&quot;';
$lang['redirect_to_page'] = 'Presmerovať na str&aacute;nku';
$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'] = 'Cieľov&aacute; str&aacute;nka';
$lang['title_require_fieldnames'] = 'Povinn&eacute; n&aacute;zvy pol&iacute;';
$lang['title_require_fieldnames_long'] = 'Vyžadovať zad&aacute;vanie n&aacute;zvov pre polia';
$lang['title_unique_fieldnames'] = 'Vyžadovať unik&aacute;tne n&aacute;zvy pre polia';
$lang['title_unique_fieldnames_long'] = 'Vyžiadovať unik&aacute;tne n&aacute;zvy';
$lang['title_reorder_form'] = 'Preh&aacute;dzať polia';
$lang['title_load_template'] = 'Nahrať &scaron;abl&oacute;nu';
$lang['title_add_button_text'] = 'Pridať text tlač&iacute;tka';
$lang['title_del_button_text'] = 'odstr&aacute;niť text trač&iacute;tka';
$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'] = 'Hodnota pre porovnanie';
$lang['title_string'] = 'Reťazec';
$lang['title_numeric'] = 'Č&iacute;slo';
$lang['title_inline_form'] = 'Zobrazovať priamo v obsahu (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'] = 'Prednastaven&aacute; hodnota prepole';
$lang['title_clear_default'] = 'Vyčistiť po kliknut&iacute;?';
$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 pre pole';
$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 po odoslan&iacute; forml&aacute;ra';
$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'] = 'Viac typov pol&iacute;? ';
$lang['title_switch_basic'] = 'Too many confusing field types? ';
$lang['title_switch_advanced_link'] = 'Prepn&uacute;ť do rozč&iacute;ren&eacute;ho m&oacute;du';
$lang['title_switch_basic_link'] = 'Prepn&uacute;ť do jednoduch&eacute;ho m&oacute;du';
$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_usertag_disposition'] = 'User defined tag returned an error';
$lang['error_cataloger_module_not_available'] = '<strong>Cataloger module does not seem to be installed/active.</strong>';
$lang['warning'] = 'Upozornenie!';
$lang['default_template'] = 'Prednastaven&aacute; &scaron;abl&oacute;na';
$lang['table_left_template'] = 'Tabuľka, popisok k poli vľavo';
$lang['table_top_template'] = 'Tabuľka, popisok k poľu nad';
$lang['form_template_name'] = '&Scaron;abl&oacute;na z %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'] = 'N&aacute;zov formul&aacute;ra';
$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['utma'] = '156861353.2507374031899462000.1214233131.1243849425.1243873113.29';
$lang['utmz'] = '156861353.1243849425.28.10.utmcsr=dev.cmsmadesimple.org|utmccn=(referral)|utmcmd=referral|utmcct=/';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/sl_SI.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'] = '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 &quot;From Address&quot; 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 &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'] = '-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'] = 'Ni pravilno izpolnjen';
$lang['required_field_missing'] = 'A value was not supplied for a required field';
$lang['please_enter_a_value'] = 'Prosimo, izpolnite &quot;%s&quot;';
$lang['please_enter_a_number'] = 'Prosimo, vpi&scaron;ite &scaron;tevilko &quot;%s&quot;';
$lang['please_enter_valid'] = 'Prosimo, vpi&scaron;ite veljaven zapis &quot;%s&quot;';
$lang['please_enter_an_integer'] = 'Prosimo, vpi&scaron;ite &scaron;tevilko &quot;%s&quot;';
$lang['please_enter_an_email'] = 'Prosimo, vpi&scaron;ite veljaven E-po&scaron;tni naslov v polju &quot;%s&quot;';
$lang['email_address_does_not_match'] = 'E-mail naslov se ne ujema z &quot;%s&quot;';
$lang['please_enter_a_phone'] = 'Prosimo, vpi&scaron;ite veljavno telefonsko &scaron;tevilko v polju &quot;%s&quot;';
$lang['not_valid_email'] = '&quot;%s&quot; ni veljaven E-po&scaron;tni naslov';
$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'] = '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['css'] = 'CSS';
$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['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;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_field_css_id'] = 'CSS id for this field';
$lang['title_form_css_class'] = 'CSS Class for this form';
$lang['title_field_css_class'] = 'CSS Class for this field';
$lang['title_form_predisplay_udt'] = 'User defined tag to call before form is displayed';
$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'] = 'Stran %s od %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['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_usertag_disposition'] = 'User defined tag returned an error';
$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'] = '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_<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;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>
';
$lang['post_install'] = '<br />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.<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&#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 &quot;From Address&quot; 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 &quot;From Name&quot; 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 &quot;From Address&quot; Field, and send copy. This works like the Email &quot;From Address&quot; Field described above, but it provides options for sending a copy of the results to the user.</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>After a bit of nagging on the part of people who actually respect standards, FormBuilder no longer encourages tricks like embedding CSS in 
static text fields. Instead, it creates a stylesheet called &quot;FormBuilder Default&quot; that you are encouraged to attach to the page template
that you use for pages that contain your form.</p>  
<p>This default CSS was graciously provided by Paul Noone.</p>


<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;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> Make sure you can successfully send email via the test in the CMSMailer Module. It&#039;s simply amazing how many problems boil down to a misconfigured CMSMailer.</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>
<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"><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['utma'] = '156861353.946566493304929700.1236179099.1236850313.1236861512.6';
$lang['utmz'] = '156861353.1236861512.6.5.utmccn=(referral)|utmcsr=jupiter.sinusiks.net|utmcct=/admin/addtemplate.php|utmcmd=referral';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/sr_YU.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
$lang['friendlyname'] = 'Kreator formi';
$lang['field_type_DispositionEmailFromFEUProperty'] = '*Email users matching an FEU property';
$lang['field_type_'] = 'Tip polja nije pode&scaron;en';
$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_HTML5NumberField'] = 'HTML5 numeričko polje';
$lang['field_type_HTML5EmailField'] = 'HTML5 polje za e-mail adresu';
$lang['field_type_HTML5URLField'] = 'HTML5 polje za URL';
$lang['field_type_SiteAdminField'] = 'Administracija sajta';
$lang['field_type_PasswordField'] = 'Lozinka';
$lang['field_type_PasswordAgainField'] = 'Ponovo lozinka (verifikacija)';
$lang['field_type_TextFieldExpandable'] = 'Text Input (Multiple)';
$lang['field_type_TextAreaField'] = 'Text Area';
$lang['field_type_ButtonField'] = 'Dugme';
$lang['field_type_CheckboxField'] = 'Ček-boks';
$lang['field_type_CheckboxGroupField'] = 'Grupa ček-boksova';
$lang['field_type_PulldownField'] = 'Pulldown';
$lang['field_type_YearPullDownField'] = 'Year Pulldown';
$lang['field_type_MultiselectField'] = 'Multiselect';
$lang['field_type_StatePickerField'] = 'Izbor savezne države SAD';
$lang['field_type_ProvincePickerField'] = 'Izbor kanadske provincije';
$lang['field_type_CountryPickerField'] = 'Izbor države';
$lang['field_type_DatePickerField'] = 'Izbor datuma';
$lang['field_type_TimePickerField'] = 'Izbor vremena';
$lang['field_type_RadioGroupField'] = 'Radio Button Group';
$lang['field_type_DispositionDirector'] = '*Po&scaron;alji rezultate na e-mail, na osnovu izbora';
$lang['field_type_DispositionFileDirector'] = '*Snimi rezultate u izabranu datoteku';
$lang['field_type_DispositionMultiselectFileDirector'] = '*Save Results to File(s) Based on Multiple Selections';
$lang['field_type_DispositionPageRedirector'] = '*Redirektuj na stranicu u zavisnosti od izbora';
$lang['field_type_DispositionEmail'] = '*Po&scaron;alji rezultate na izabranu adresu (ili vi&scaron;e adresa)';
$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'] = '*Upi&scaron;i rezultate u običnu datoteku';
$lang['field_type_DispositionUniqueFile'] = '*Upi&scaron;i rezultate u zasebnu datoteku prilikom svakog slanja';
$lang['field_type_DispositionDatabase'] = '*Snimi rezultate u bazu podataka';
$lang['field_type_DispositionFormBrowser'] = '*Sačuvaj rezultate za <em>FormBrowser</em> Modul v.0.3';
$lang['field_type_DispositionUserTag'] = '*Pokreni Korisnički Definisan Tag i prosledi mu podatke iz forme';
$lang['field_type_DispositionForm'] = '*Submit to an arbitrary form action';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Po&scaron;alji na e-mail adresu koju unese korisnik';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Po&scaron;alji administratoru sistema';
$lang['field_type_DispositionEmailBasedFrontendFields'] = '*Email results based on frontend fields';
$lang['field_type_PageBreakField'] = '-Page Break';
$lang['field_type_FileUploadField'] = 'Otpremanje datoteke';
$lang['field_type_FromEmailAddressField'] = 'E-mail &quot;adresa po&scaron;iljaoca&quot; polje';
$lang['field_type_FromEmailAddressAgainField'] = 'E-mail &quot;adresa po&scaron;iljaoca&quot; polje (ponovo)';
$lang['field_type_FromEmailNameField'] = 'E-mail &quot;ime po&scaron;iljaoca&quot; polje';
$lang['field_type_FromEmailSubjectField'] = 'E-mail &quot;Tema poruke&quot; polje';
$lang['field_type_CCEmailAddressField'] = 'E-mail CC (<em>carbon copy</em>) polje';
$lang['field_type_StaticTextField'] = '-Statični tekst';
$lang['field_type_SystemLinkField'] = '-Statični link';
$lang['field_type_LinkField'] = 'Link (unosi korisnik)';
$lang['field_type_HiddenField'] = '-Skriveno polje';
$lang['field_type_ComputedField'] = '-Izračunato polje';
$lang['field_type_UniqueIntegerField'] = '-Jedinstvena celobrojna vrednost (serijska)';
$lang['field_type_UserTagField'] = '-Poziv Korisnički Definisanog Taga';
$lang['field_type_CompanyDirectoryField'] = 'Company Directory Field';
$lang['field_type_ModuleInterfaceField'] = '-Module Interface Field';
$lang['field_type_CheckboxExtendedField'] = 'Checkbox extended';
$lang['validation_none'] = 'Nema validacije';
$lang['validation_numeric'] = 'Numeričko';
$lang['validation_integer'] = 'Celobrojna vrednost';
$lang['validation_email_address'] = 'E-mail adresa';
$lang['validation_usphone'] = 'Broj telefona (SAD)';
$lang['validation_must_check'] = 'Mora biti selektovano';
$lang['validation_regex_match'] = 'Poklapa se sa regularnim izrazom';
$lang['validation_regex_nomatch'] = 'Ne poklapa se sa regularnim izrazom';
$lang['validation_empty'] = 'Ne može biti prazno';
$lang['required'] = 'Obavezno';
$lang['not_required'] = 'Nije obavezno';
$lang['not_available'] = 'Nije dostupno';
$lang['error_emailfromfeuprop'] = 'Gre&scaron;ka u pode&scaron;avanjima polja';
$lang['error_nofeu'] = 'Modul <em>FrontEndUsers</em> ne može biti pronađen. Ovo polje neće funkcionisati';
$lang['error_nofeudefns'] = 'Nije pronađeno odgovarajuće FEU svojstvo.  Ovo polje neće funkcionisati.';
$lang['required_field_missing'] = 'Nije uneta vrednost u obavezno polje';
$lang['please_enter_a_value'] = 'Molimo unesite vrednost u polje &quot;%s&quot;';
$lang['please_enter_a_number'] = 'Molimo unesite brojčanu vrednost u polje &quot;%s&quot;';
$lang['please_enter_valid'] = 'Molimo unesite validnu vrednost u polje &quot;%s&quot;';
$lang['please_enter_an_integer'] = 'Molimo unesite celobrojnu brojčanu vrednost u polje &quot;%s&quot;';
$lang['please_enter_an_email'] = 'Molimo unesite validnu e-mail adresu u polje &quot;%s&quot;';
$lang['email_address_does_not_match'] = 'E-mail adresa se ne poklapa sa vrednos&scaron;ću u &quot;%s&quot;';
$lang['please_enter_a_phone'] = 'Molimo unesite validan broj telefona u polje &quot;%s&quot;';
$lang['please_login'] = 'Molimo prijavite se da biste koristili ovu formu';
$lang['not_valid_email'] = 'Čini se da &quot;%s&quot; nije validna e-mail adresa.';
$lang['please_enter_no_longer'] = 'Molimo unesite vrednost čija dužina ne prelazi %s karaktera';
$lang['please_enter_at_least'] = 'Molimo unesite vrednost koja je duga najmanje %s karaktera';
$lang['title_list_delimiter'] = 'Karakter (delimiter) koji će razdvajati rezultate, u slučajevima kada se vraća vi&scaron;e od jedne vrednosti';
$lang['you_need_permission'] = 'Morate imati &quot;%s&quot; dozvolu da biste izvodili tu operaciju.';
$lang['lackpermission'] = 'Žao nam je, nemate dovoljno dozvola da biste pristupili ovom delu sajta.';
$lang['field_order_updated'] = 'Redosled polja je osvežen.';
$lang['form_deleted'] = 'Forma obrisana.';
$lang['field_deleted'] = 'Polje obrisano.';
$lang['configuration_updated'] = 'Pode&scaron;avanja osvežena.';
$lang['you_must_check'] = 'Morate selektovati &quot;%s&quot; da biste nastavili dalje.';
$lang['must_specify_one_destination'] = 'Morate specificirati najmanje jednu odredi&scaron;nu adresu.';
$lang['are_you_sure_delete_form'] = 'Da li ste sigurni da želite obrisati formu %s?';
$lang['are_you_sure_delete_field'] = 'Da li ste sigurni da želite obrisati polje %s?';
$lang['notice_select_type'] = 'Napredne opcije biće dostupne tek kada izaberete tip polja.';
$lang['field_name_in_use'] = 'Naziv polja &quot;%s&quot; je već u upotebi. Molimo koristite jedinstvene nazive polja ili u pode&scaron;avanjima Kreatora formi isključite opciju koja zahteva da nazivi polja budu jedinstveni.';
$lang['field_no_name'] = 'Polja moraju imati nazive, osim ukoliko ne isključite tu opciju u pode&scaron;avanjima Kreatora formi.';
$lang['no_field_assigned'] = 'No field assigned for %s';
$lang['anonymous'] = 'Anonymous';
$lang['abbreviation_length'] = 'Dužina: %s';
$lang['boxes'] = '%s boksova';
$lang['options'] = '%s opcija';
$lang['text_length'] = '%s karaktera.';
$lang['order'] = 'Redosled';
$lang['unspecified'] = '[nije specificirano]';
$lang['added'] = 'dodato';
$lang['updated'] = 'osveženo';
$lang['sort_options'] = 'Sort options on output';
$lang['select_one'] = 'Selektujte jedno';
$lang['select_type'] = 'Izaberite tip';
$lang['to'] = 'Za';
$lang['yes'] = 'Da';
$lang['no'] = 'Ne';
$lang['recipients'] = 'primaoci';
$lang['fields'] = 'polja';
$lang['file_count'] = '%s mogućih polja';
$lang['destination_count'] = '%s odredi&scaron;ta';
$lang['save'] = 'Snimi';
$lang['add'] = 'Dodaj';
$lang['update'] = 'Osveži';
$lang['save_and_continue'] = 'Snimi i nastavi sa izmenama';
$lang['information'] = 'Informacija';
$lang['automatic'] = 'Automatski';
$lang['forms'] = 'Forme';
$lang['form'] = 'Forma %s';
$lang['configuration'] = 'Pode&scaron;avanje';
$lang['field_requirement_updated'] = 'Field required state updated.';
$lang['maximum_size'] = 'Maks. veličina';
$lang['permitted_extensions'] = 'Ekstenzije';
$lang['permitted_filetypes'] = 'Dozvoljeni tipovi datoteka';
$lang['file_too_large'] = 'Otpremljena datoteka je prevelika. Maskimalna dozvoljena veličina je: ';
$lang['illegal_file_type'] = 'Datoteka ovog tipa ne može biti otpremljena. Molimo proverite da li ima odgovarajuću ekstenziju.';
$lang['upload'] = 'Optremi';
$lang['form_imported'] = 'Forma uvežena.';
$lang['form_import_failed'] = 'Form import failed! There was a problem with the format of the XML file.';
$lang['rows'] = '%s redova';
$lang['cols'] = '%s kolona';
$lang['12_hour'] = '12-časovni sat';
$lang['24_hour'] = '24-časovni sat';
$lang['hour'] = 'Sat';
$lang['min'] = 'Minut';
$lang['merid'] = 'Meridijan';
$lang['date_range'] = 'Opseg: %s - %s';
$lang['thanks'] = 'Thanks! Your submissions have been received.';
$lang['edit'] = 'Izmeni';
$lang['delete'] = 'Obri&scaron;i';
$lang['day'] = 'Dan';
$lang['mon'] = 'Mesec';
$lang['year'] = 'Godina';
$lang['none'] = '(none)';
$lang['css'] = 'CSS';
$lang['uninstalled'] = 'Modul je deinstaliran.';
$lang['installed'] = 'Modul verzije %s je instaliran.';
$lang['upgraded'] = 'Modul je uspe&scaron;no nadograđen na verziju %s.';
$lang['button_previous'] = 'Nazad...';
$lang['button_submit'] = 'Po&scaron;alji formu';
$lang['button_continue'] = 'Nastavi...';
$lang['value_checked'] = 'Selektovano';
$lang['value_unchecked'] = 'Nije selektovano';
$lang['tab_main'] = 'Glavna';
$lang['tab_symbol'] = 'Pode&scaron;avanja prikaza forme';
$lang['tab_submit'] = 'Slanje forme';
$lang['tab_captcha'] = 'Captcha pode&scaron;avanja';
$lang['tab_advanced'] = 'Napredna pode&scaron;avanja';
$lang['tab_templatelayout'] = '&Scaron;ablon forme';
$lang['tab_submissiontemplate'] = 'Submission Template';
$lang['tab_udt'] = 'Integracija KDT';
$lang['title_feu_property'] = '<em>FrontEndUsers</em> svojstvo';
$lang['info_feu_property'] = 'Only certain property types can be used for matching (dropdowns, multiselect fields, etc).';
$lang['canuse_smarty'] = '<em>Smarty promenljive su dopu&scaron;tene u ovom polju.</em>';
$lang['add_options'] = 'Dodaj jo&scaron; opcija';
$lang['delete_options'] = 'Obri&scaron;i označene opcije';
$lang['add_checkboxes'] = 'Dodaj jo&scaron; ček-boksova';
$lang['delete_checkboxes'] = 'Obri&scaron;i označene ček-boksove';
$lang['add_address'] = 'Dodaj jo&scaron; jednu adresu';
$lang['delete_address'] = 'Obri&scaron;i označene adrese';
$lang['add_destination'] = 'Dodaj jo&scaron; jedno odredi&scaron;te';
$lang['delete_destination'] = 'Obri&scaron;i označena odredi&scaron;ta';
$lang['suspected_spam'] = 'Sa Va&scaron;e IP adrese je već poslato previ&scaron;e e-mail poruka. Anti-Spam kod je sprečio dalje slanje.';
$lang['suspected_spam_log'] = 'Zaustavljen potencijalni SPAM sa IP adrese %s.';
$lang['reorder'] = 'Promeni redosled polja';
$lang['cancel'] = 'Otkaži';
$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['title_textfield_label'] = 'Textfield label';
$lang['title_show_textfield'] = 'Show textfield?';
$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'] = 'Visina polja';
$lang['title_file_path'] = 'Odredi&scaron;ni direktorijum za izlazne datoteke';
$lang['title_udt_name'] = 'Korisnički Definisan Tag';
$lang['title_uploads_destpage'] = 'Page to return to with uploads link';
$lang['title_uploadmodule_summary'] = 'Poslato preko kreatora formi';
$lang['title_uploads_category'] = 'Otpremna kategorija';
$lang['title_sendto_uploads'] = 'Send this file to the uploads module';
$lang['title_allow_overwrite'] = 'Dozvoli da postojeće datoteke budu prepisane prilikom otpremanja?';
$lang['title_allow_overwrite_long'] = 'Da li dozvoliti da otposlata datoteka zameni datoteku sa istim nazivom, koja je otpremljena ranije?';
$lang['overwrite'] = 'Omogućava prepisivanje (<em>overwriting</em>)';
$lang['nooverwrite'] = 'Nema prepisivanja (<em>overwriting</em>)';
$lang['file_already_exists'] = 'Datoteka %s već postoji i preko nje ne može biti pisano.';
$lang['title_file_rename'] = '&Scaron;ablon naziva';
$lang['original_file_extension'] = 'Originalna ekstenzija datoteke (uključuje i &quot;.&quot;)';
$lang['title_suppress_filename'] = 'Suppress filename in emails and forms the end user will see';
$lang['title_suppress_attachment'] = 'Ne dozvoli kačenje datoteka uz e-mail poruke';
$lang['file_rename_help'] = 'Ukoliko želite da naziv datoteke bude promenjen nakon otpremanja, unesite &scaron;ablon novog naziva u ovo polje. U suprotnom, ostavite ovo polje prazno i naziv otpremljene datoteke neće biti promenjen.';
$lang['title_legend'] = 'Legenda';
$lang['title_maximum_length'] = 'Maksimalna dužina';
$lang['title_checkbox_label'] = 'Labela ček-boksa';
$lang['title_radio_label'] = 'Radio Button label';
$lang['title_checked_value'] = 'Vrendost kada je selektovan';
$lang['title_unchecked_value'] = 'Vrednost kada nije selektovan';
$lang['title_checkbox_details'] = 'Detalji o grupi ček-boksova';
$lang['title_delete'] = 'Obrisati?';
$lang['title_select_one_message'] = '&quot;Izaberite jedno&quot; tekst';
$lang['title_selection_value'] = 'Vrednost selekcije';
$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'] = 'Naziv opcije';
$lang['title_option_value'] = 'Vrendost poslata';
$lang['title_pulldown_details'] = 'Pulldown Options';
$lang['title_multiselect_details'] = 'Multiselect Options';
$lang['title_destination_address'] = 'Odredi&scaron;na e-mail adresa';
$lang['title_destination_filename'] = 'Naziv odredi&scaron;ne datoteke';
$lang['title_email_from_name'] = '&quot;From name&quot; for email';
$lang['title_relaxed_email_regex'] = 'Koristi manje strogu validaciju e-mail adrese';
$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'] = 'Naziv datoteke';
$lang['title_email_subject'] = 'Tema poruke';
$lang['title_form_name'] = 'Naziv forme';
$lang['title_form_status'] = 'Status forme';
$lang['title_ready_for_deployment'] = 'Ready for Deployment';
$lang['title_not_ready1'] = 'Nije spremno';
$lang['title_redirect_page'] = 'Stranica na koju će korisnik biti odveden nakon slanja forme';
$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'] = 'koristi ovu prečicu';
$lang['title_form_alias'] = 'Alias forme';
$lang['title_field_alias_short'] = 'Alias';
$lang['title_form_fields'] = 'Polja forme';
$lang['title_field_id'] = 'ID polja';
$lang['title_show_fieldaliases'] = 'Prikaži aliase polja';
$lang['title_show_fieldaliases_long'] = 'Clicking this will display field aliases when adding or editing a form';
$lang['title_field_name'] = 'Naziv polja';
$lang['title_field_alias'] = 'Field Alias and DOM id (CSS id) attribute';
$lang['title_radiogroup_details'] = 'Radio Button Group Details';
$lang['title_field_type'] = 'Tip polja';
$lang['title_not_ready3'] = 'to create a form handling field.';
$lang['title_add_new_form'] = 'Dodaj novu formu';
$lang['title_show_version'] = 'Prikazati verziju Kreatora formi?';
$lang['title_show_version_long'] = 'Ovo će (u formi HTML komentara) prikazati verziju Kreatora formi koju imate instaliranu na Va&scaron;em sistemu, kako bi se potpomoglo detektovanje i otklanjanje gre&scaron;aka.';
$lang['title_add_new_field'] = 'Dodaj polje';
$lang['title_form_submit_button'] = 'Tekst na dugmetu za slanje forme';
$lang['title_button_text'] = 'Tekst na dugmetu';
$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'] = 'Validacija polja';
$lang['title_field_to_validate'] = 'Polje koje treba validirati';
$lang['title_field_css_id'] = 'CSS id ovog polja';
$lang['title_form_css_class'] = 'CSS klasa za ovu formu';
$lang['title_field_css_class'] = 'CSS klasa za ovo polje';
$lang['title_form_predisplay_udt'] = 'Korisnički definisan tag koji će biti pozvan pre prvog prikazivanja forme (izvr&scaron;ava se samo jednom)';
$lang['title_form_predisplay_each_udt'] = 'Korisnički definisan tag koji će biti pozvan pre prikazivanja forme (izvr&scaron;ava se na svakoj stranici vi&scaron;estraničnih formi)';
$lang['title_form_validate_udt'] = 'Korisnički definisan tag koji će biti pozvan prilikom validacije forme';
$lang['title_form_required_symbol'] = 'Simbol koji će označavati obavezna polja';
$lang['title_field_required'] = 'Obavezno';
$lang['title_field_required_long'] = 'Zahtevajte unos u ovo polje';
$lang['title_hide_label'] = 'Sakrij labelu';
$lang['title_hide_label_long'] = 'Hide this field&#039;s name on Form';
$lang['title_textarea_length'] = 'Maximum length of field content (0 or blank means no limit)';
$lang['title_text'] = 'Statični tekst koji će biti prikazan';
$lang['title_field_regex'] = 'Validacioni regularni izraz';
$lang['title_lines_to_show'] = 'Broj linija koje treba prikazati';
$lang['title_read_only'] = 'Read Only';
$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_file_destination'] = 'Directory to save files into';
$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_default_blank'] = 'Default to blank';
$lang['title_default_blank_help'] = 'Default to blank (uncheck to default to today&#039;s date)';
$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['title_encrypt_database_data'] = 'Encrypt data stored in database';
$lang['title_crypt_cert'] = 'Certificate for encrypting data';
$lang['title_encryption_keyfile'] = 'Passphrase or path to file containing passphrase. (If using OpenSSL, this is the passphrase for the private key)';
$lang['title_encrypt_sortfields'] = 'Hash sort fields?';
$lang['title_private_key'] = 'Private Key to use for encrypting data';
$lang['title_encrypt_sortfields_help'] = 'This hashes the sort fields, but leaves the first few letters unencrypted. Cryptographically, this creates a vulnerability, but for most users it is an acceptable tradeoff between security and the ability to sort records. Sorting becomes approximate, but will remain pretty good. If you do not use this option, sort fields are stored in plaintext.';
$lang['title_encryption_functions'] = 'Storage Encryption Unavailable';
$lang['title_install_crypto'] = 'Please install the OpenSSL module or mcrypt support if you would like to enable database encryption.';
$lang['title_install_curl'] = 'Please make sure you have CURL support active in your PHP install. See http://www.php.net/manual/en/book.curl.php';
$lang['title_mle_version'] = 'Run in MLE Mode';
$lang['title_mle_version_long'] = 'Changes/support for CMSMS Multi-Language Edition fork. Do not check this if you are not running the MLE version.';
$lang['title_ensure_cert_key_match'] = 'Ensure that you select the private key that is appropriate for the certificate you are using for encryption!';
$lang['choose_crypt'] = 'Encryption Library';
$lang['title_encrypt_database_long'] = 'Check this to encrypt the stored data. This makes it more difficult (but not impossible) for hackers to view the information.';
$lang['choose_crypt_long'] = 'The options below only apply if you are using the OpenSSL Encryption library';
$lang['title_crypt_lib'] = 'Encryption Library';
$lang['openssl'] = 'OpenSSL Library';
$lang['mcrypt'] = 'PHP mcrypt Library';
$lang['title_feu_binding'] = 'Frontend User binding';
$lang['title_install_feu'] = 'Please install the Frontend User module to connect a form and its data to a specific user';
$lang['title_feu_bind_help'] = 'Check this to lock front-end access to this form&#039;s data to the logged-in front-end user.';
$lang['title_encryption'] = 'Encryption';
$lang['title_export_form_to_udt'] = 'Export form reference to UDT as $params[&#039;FORM&#039;]? (do not do this if you are going to print_r($params) )';
$lang['title_url_help'] = 'Entire URL, including protocol and path (e.g., http://myhost.com/form_handler.cgi)';
$lang['title_url'] = 'Form submission URL';
$lang['title_method'] = 'Form method';
$lang['title_maps_to'] = 'Map field &quot;%s&quot; to form submission variable';
$lang['title_additional'] = 'Additional submission';
$lang['title_additional_help'] = 'Anything to be appended to the submission payload, in URL-encoded form (.e.g, &quot;user=steve+jobs&amp;employee_number=1)';
$lang['title_include_in_submission'] = 'Include field in Submission';
$lang['title_date_order'] = 'Date component field order (for input)';
$lang['title_data_stored_in_fbr'] = 'Data will be stored in an XML format in the [PREFIX]_module_fb_formbrowser database table.';
$lang['error_has_no_fb_field'] = 'Error! Either the form has no Form Browser Disposition, or it failed to instantiate (due to memory issues?)';
$lang['help_date_order'] = 'Use &quot;m&quot; for Month, &quot;d&quot; for Day, and &quot;y&quot; for Year. Separate the items by hyphens.';
$lang['restricted_to_group'] = 'Only in group %s';
$lang['title_show_to_user'] = 'Display to user';
$lang['title_use_random_generator'] = 'Use random number generator instead of static';
$lang['title_numbers_to_generate'] = 'How many numbers to generate in process';
$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_ignored_if_upload'] = '(This field ignored if you use the Uploads module to manage files)';
$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 containing:<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['help_rtf_file_template'] = 'Specify a file located in the FormBuilder/templates/ folder. This field is ignored if you use TXT as your file type.';
$lang['help_rtf_template_type'] = 'Basic: Use the textarea below to layout the field names/values in a single block.<br />
Advanced: Specify Smarty variables in the RTF Template File as you would below, but arrange them however you like and add formatting.<br />
&nbsp;You can still use the %%HEADER%% and %%FOOTER%% sections in the RTF file.';
$lang['help_unique_file_template'] = 'For TXT, this will be immediately after the Header Template.<br />
For RTF, this will replace the %%FIELDS%% string in the template file if RTF Template Type is set to &quot;Basic&quot;.<br />
This field will be ignored if using &quot;RTF&quot; as File Type and &quot;Advanced&quot; as RTF Template Type.';
$lang['help_file_header_template'] = 'For TXT, this will be placed at the top of the file. For RTF, this will replace the %%HEADER%% string in the template file.';
$lang['help_file_footer_template'] = 'For TXT, this will be placed at the bottom of the file. For RTF, this will replace the %%FOOTER%% string in the template file.';
$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_footer_template'] = 'Create Sample Footer 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_file_footer'] = 'Template for the footer of output file';
$lang['title_rtf_file_template'] = 'Template RTF file to use';
$lang['title_unique_file_template'] = 'Template for output';
$lang['title_file_type'] = 'Choose a file type to use';
$lang['title_rtf_template_type'] = 'Choose an RTF template type';
$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 for display (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['title_submit_date'] = 'Date Submitted';
$lang['title_approval_date'] = 'Date Approved (by admin)';
$lang['title_user_approved'] = 'Date Approved (by submitter)';
$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_field_helptext'] = 'Help-text to display with this field';
$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_string_unspaced'] = 'String (no spaces between fields)?';
$lang['title_compute_value'] = 'Value to compute';
$lang['title_compute'] = 'Computed/PHP';
$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 {FormBuilder} 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.<br />
If left blank, this will default to your default uploads directory ($config[&#039;uploads_path&#039;]).';
$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['title_display_length'] = 'Display length';
$lang['title_minimum_length'] = 'Minimum response length';
$lang['title_hide'] = 'Hide input';
$lang['title_hide_help'] = 'Show symbols rather plain text when user enters password?';
$lang['password_does_not_match'] = 'Password does not match %s';
$lang['back_top'] = 'Back to FormBuilder Main Page';
$lang['title_headers_to_modify'] = 'Which email headers should this input populate?';
$lang['title_blank_invalid'] = 'Do not accept blank space as valid response';
$lang['title_blank_invalid_long'] = 'If a field is required, checking this will require that people put in some alphanumeric characters, not just spaces';
$lang['title_must_save_order'] = 'You must click one of the &quot;save&quot; buttons to make your new field order permanent.';
$lang['title_html5'] = 'Use HTML5 placeholder text instead of Javascript';
$lang['title_email_cc_address'] = 'Address(es) to email as Carbon copy (CC). Use commas to delimit multiple addresses.';
$lang['title_use_bcc'] = 'Use Blind carbon copy (BCC instead of CC)';
$lang['title_send_using'] = 'Mail Addressing';
$lang['title_field_to_modify'] = 'Email field to add CC address';
$lang['title_modifies'] = 'Add CC to &quot;%s&quot;';
$lang['bcc_field'] = '&quot;BCC&quot; recipients';
$lang['cc_field'] = '&quot;CC&quot; recipients';
$lang['to_field'] = 'Normal (&quot;To&quot; recipients)';
$lang['bcc'] = 'BCC';
$lang['cc'] = 'CC';
$lang['error_CompanyDirectory_module_not_available'] = 'Company Directory module is not available!';
$lang['option_never'] = 'Never';
$lang['option_user_choice'] = 'Give user a choice (checkbox)';
$lang['option_always'] = 'Always';
$lang['option_from'] = '&quot;From&quot; email address';
$lang['option_reply'] = '&quot;Reply-To&quot; email address';
$lang['option_both'] = 'Both &quot;From&quot; and &quot;Reply-To&quot; email addresses';
$lang['option_dropdown'] = 'Dropdown';
$lang['option_selectlist_single'] = 'Select List (single)';
$lang['option_selectlist_multiple'] = 'Select List (multiple)';
$lang['option_radiogroup'] = 'Radio Group';
$lang['title_company_field_note'] = 'Note: Output will be in the form of<br/>&quot;company name&quot;=>&quot;value&quot;';
$lang['title_pick_categories'] = 'Pick a category (multiple)';
$lang['title_pick_fielddef'] = 'Pull a field Definition&#039;s value (single) <em>optional</em>';
$lang['title_choose_user_input'] = 'Choose User input';
$lang['title_see_also_udt'] = '(Also take a look at the Form Submission tab if you want to set a UDT for form validation)';
$lang['title_year_end_message'] = 'End year';
$lang['title_field_logic'] = 'Smarty data or logic that is meant to be sent with this field';
$lang['title_field_logic_long'] = 'Can be smarty data, javascript, or some other data you want to sent along with this field.<br />Goes through the Smarty compiler, so remember use {literal}{/literal} tags with <script></script>';
$lang['title_field_includelabels'] = 'Include labels';
$lang['title_field_includelabels_help'] = 'Enabling this includes labels to output. example - label: value,label2: value2';
$lang['title_field_siblings'] = 'Link this field to it&#039;s sibling';
$lang['title_field_siblings_help'] = 'Dropdown lists all siblings of this field and allows you to link this field to one of it&#039;s sibling. Makes possible controlling this field with selected sibling controls.';
$lang['title_field_hidebuttons'] = 'Hide control buttons';
$lang['title_field_hidebuttons_help'] = 'Hides frontend control buttons of this field.';
$lang['title_note'] = 'Note';
$lang['title_changing_triggers_reindex'] = 'Changing any of the above fields will trigger a reindex of *all* saved records, so it could take a while.';
$lang['illegal_file'] = 'Attempted upload of illegal file type (%s) from %s';
$lang['title_searchable'] = 'Make records accessible to Search Module';
$lang['title_searchable_help'] = 'Checking this will make all submitted data accessible to the Search Module. DO NOT use this if you encrypt your data -- the information gets exposed to search whether or not it is encrypted!';
$lang['uploaded_outside_webroot'] = '%s (outside web root)';
$lang['title_fbr_edit'] = 'Editable in FormBrowser Admin?';
$lang['title_active_only'] = 'Only include active users?';
$lang['error_usertag_disposition'] = 'User defined tag returned an error';
$lang['error_usertag'] = 'User defined tag %s returned an error.';
$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 Response Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_no_field_error'] = 'Validation Response 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['must_specify_one_admin'] = 'Must specify an Admin';
$lang['operators_help'] = 'If you use String evaluation, the only operation available is concatenation (+). If you use Number evaluation you have basic, very simple math (, +, -, *, /, ). If you use Computed/PHP evaluation, you can
use any function you want, but you need to quote things (substitution occurs before evaluation), e.g., substr(&#039;$fld_22&#039;,0,2).&#039;$fld_23&#039;.';
$lang['help_module_interface'] = 'Using Module Interface';
$lang['help_module_interface_long'] = '<b>This field is used as a gateway to other modules!</b>
Use it by creating your form elements in the templates of the other module(s) you wish to incorporate, and using the <strong>{$FBid}</strong> to tie it back to FormBuilder. For example, to include form options based on the Products module, create the following template in Products:<br/>
<pre>
{foreach from=$items item=entry}
	{assign var=MData value=&#039;&#039;}
	{assign var=Cd value=&#039;&#039;}
		{foreach from=$FBvalue item=MData}
			{assign var=MData value=&#039;::&#039;|explode:$MData}
			{if $MData[1]==$entry->id}
				{assign var=Cd value=&#039; checked=&quot;checked&quot;&#039;}
			{/if}
		{/foreach}
	<div class=&quot;ProductDirectoryItem&quot;>
		<input type=&quot;checkbox&quot; value=&quot;{$entry->price}::{$entry->id}&quot; name=&quot;{$FBid}[]&quot; {$Cd} />{$entry->product_name} ({$entry->weight}{$weight_units}) &pound;{$entry->price}    
	</div>
{/foreach}
</pre>
<br/>
where in the input below you put something like <strong>{Products category=&quot;cat&quot; summarytemplate=&quot;Your_FB_template&quot;}</strong>';
$lang['title_add_tag'] = 'Add your tag';
$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['AF'] = 'Afghanistan';
$lang['AX'] = 'Aland Islands';
$lang['AL'] = 'Albania';
$lang['DZ'] = 'Algeria';
$lang['AS'] = 'American Samoa';
$lang['AD'] = 'Andorra';
$lang['AO'] = 'Angola';
$lang['AI'] = 'Anguilla';
$lang['AQ'] = 'Antarctica';
$lang['AG'] = 'Antigua and Barbuda';
$lang['AR'] = 'Argentina';
$lang['AM'] = 'Armenia';
$lang['AW'] = 'Aruba';
$lang['AU'] = 'Australia';
$lang['AT'] = 'Austria';
$lang['AZ'] = 'Azerbaijan';
$lang['BS'] = 'Bahamas';
$lang['BH'] = 'Bahrain';
$lang['BB'] = 'Barbados';
$lang['BD'] = 'Bangladesh';
$lang['BY'] = 'Belarus';
$lang['BE'] = 'Belgium';
$lang['BZ'] = 'Belize';
$lang['BJ'] = 'Benin';
$lang['BM'] = 'Bermuda';
$lang['BT'] = 'Bhutan';
$lang['BW'] = 'Botswana';
$lang['BO'] = 'Bolivia';
$lang['BA'] = 'Bosnia and Herzegovina';
$lang['BV'] = 'Bouvet Island';
$lang['BR'] = 'Brazil';
$lang['IO'] = 'British Indian Ocean Territory';
$lang['BN'] = 'Brunei Darussalam';
$lang['BG'] = 'Bulgaria';
$lang['BF'] = 'Burkina Faso';
$lang['BI'] = 'Burundi';
$lang['KH'] = 'Cambodia';
$lang['CM'] = 'Cameroon';
$lang['CA'] = 'Canada';
$lang['CV'] = 'Cape Verde';
$lang['KY'] = 'Cayman Islands';
$lang['CF'] = 'Central African Republic';
$lang['TD'] = 'Chad';
$lang['CL'] = 'Chile';
$lang['CN'] = 'China';
$lang['CX'] = 'Christmas Island';
$lang['CC'] = 'Cocos (Keeling) Islands';
$lang['CO'] = 'Colombia';
$lang['KM'] = 'Comoros';
$lang['CG'] = 'Congo';
$lang['CD'] = 'Congo,  Democratic Republic';
$lang['CK'] = 'Cook Islands';
$lang['CR'] = 'Costa Rica';
$lang['CI'] = 'Ivoire (Ivory Coast)';
$lang['HR'] = 'Croatia (Hrvatska)';
$lang['CU'] = 'Cuba';
$lang['CY'] = 'Cyprus';
$lang['CZ'] = 'Czech Republic';
$lang['DK'] = 'Denmark';
$lang['DJ'] = 'Djibouti';
$lang['DM'] = 'Dominica';
$lang['DO'] = 'Dominican Republic';
$lang['TP'] = 'East Timor';
$lang['EC'] = 'Ecuador';
$lang['EG'] = 'Egypt';
$lang['SV'] = 'El Salvador';
$lang['GQ'] = 'Equatorial Guinea';
$lang['ER'] = 'Eritrea';
$lang['EE'] = 'Estonia';
$lang['ET'] = 'Ethiopia';
$lang['FK'] = 'Falkland Islands (Malvinas)';
$lang['FO'] = 'Faroe Islands';
$lang['FJ'] = 'Fiji';
$lang['FI'] = 'Finland';
$lang['FR'] = 'France';
$lang['FX'] = 'France,  Metropolitan';
$lang['GF'] = 'Guernsey';
$lang['PF'] = 'French Polynesia';
$lang['TF'] = 'French Southern Territories';
$lang['MK'] = 'F.Y.R.O.M. (Macedonia)';
$lang['GA'] = 'Gabon';
$lang['GM'] = 'Gambia';
$lang['GE'] = 'Georgia';
$lang['DE'] = 'Germany';
$lang['GH'] = 'Ghana';
$lang['GI'] = 'Gibraltar';
$lang['GB'] = 'Great Britain (UK)';
$lang['GR'] = 'Greece';
$lang['GL'] = 'Greenland';
$lang['GD'] = 'Grenada';
$lang['GP'] = 'Guadeloupe';
$lang['GU'] = 'Guam';
$lang['GT'] = 'Guatemala';
$lang['GN'] = 'Guinea';
$lang['GW'] = 'Guinea-Bissau';
$lang['GY'] = 'Guyana';
$lang['HT'] = 'Haiti';
$lang['HM'] = 'Heard and McDonald Islands';
$lang['HN'] = 'Honduras';
$lang['HK'] = 'Hong Kong';
$lang['HU'] = 'Hungary';
$lang['IS'] = 'Iceland';
$lang['IN'] = 'India';
$lang['ID'] = 'Indonesia';
$lang['IR'] = 'Iran';
$lang['IQ'] = 'Iraq';
$lang['IE'] = 'Ireland';
$lang['IL'] = 'Israel';
$lang['IM'] = 'Isle of Man';
$lang['IT'] = 'Italy';
$lang['JE'] = 'Jersey';
$lang['JM'] = 'Jamaica';
$lang['JP'] = 'Japan';
$lang['JO'] = 'Jordan';
$lang['KZ'] = 'Kazakhstan';
$lang['KE'] = 'Kenya';
$lang['KI'] = 'Kiribati';
$lang['KP'] = 'Korea (North)';
$lang['KR'] = 'Korea (South)';
$lang['KW'] = 'Kuwait';
$lang['KG'] = 'Kyrgyzstan';
$lang['LA'] = 'Laos';
$lang['LV'] = 'Latvia';
$lang['LB'] = 'Lebanon';
$lang['LI'] = 'Liechtenstein';
$lang['LR'] = 'Liberia';
$lang['LY'] = 'Libya';
$lang['LS'] = 'Lesotho';
$lang['LT'] = 'Lithuania';
$lang['LU'] = 'Luxembourg';
$lang['MO'] = 'Macau';
$lang['MG'] = 'Madagascar';
$lang['MW'] = 'Malawi';
$lang['MY'] = 'Malaysia';
$lang['MV'] = 'Maldives';
$lang['ML'] = 'Mali';
$lang['MT'] = 'Malta';
$lang['MH'] = 'Marshall Islands';
$lang['MQ'] = 'Martinique';
$lang['MR'] = 'Mauritania';
$lang['MU'] = 'Mauritius';
$lang['YT'] = 'Mayotte';
$lang['MX'] = 'Mexico';
$lang['FM'] = 'Micronesia';
$lang['MC'] = 'Monaco';
$lang['MD'] = 'Moldova';
$lang['MA'] = 'Morocco';
$lang['MN'] = 'Mongolia';
$lang['MS'] = 'Montserrat';
$lang['MZ'] = 'Mozambique';
$lang['MM'] = 'Myanmar';
$lang['NA'] = 'Namibia';
$lang['NR'] = 'Nauru';
$lang['NP'] = 'Nepal';
$lang['NL'] = 'Netherlands';
$lang['AN'] = 'Netherlands Antilles';
$lang['NT'] = 'Neutral Zone';
$lang['NC'] = 'New Caledonia';
$lang['NZ'] = 'New Zealand (Aotearoa)';
$lang['NI'] = 'Nicaragua';
$lang['NE'] = 'Niger';
$lang['NG'] = 'Nigeria';
$lang['NU'] = 'Niue';
$lang['NF'] = 'Norfolk Island';
$lang['MP'] = 'Northern Mariana Islands';
$lang['NO'] = 'Norway';
$lang['OM'] = 'Oman';
$lang['PK'] = 'Pakistan';
$lang['PW'] = 'Palau';
$lang['PS'] = 'Palestinian Territory';
$lang['PA'] = 'Panama';
$lang['PG'] = 'Papua New Guinea';
$lang['PY'] = 'Paraguay';
$lang['PE'] = 'Peru';
$lang['PH'] = 'Philippines';
$lang['PN'] = 'Pitcairn';
$lang['PL'] = 'Poland';
$lang['PT'] = 'Portugal';
$lang['PR'] = 'Puerto Rico';
$lang['QA'] = 'Qatar';
$lang['RE'] = 'Reunion';
$lang['RO'] = 'Romania';
$lang['RU'] = 'Russian Federation';
$lang['RW'] = 'Rwanda';
$lang['GS'] = 'S. Georgia and S. Sandwich Isls.';
$lang['KN'] = 'Saint Kitts and Nevis';
$lang['LC'] = 'Saint Lucia';
$lang['VC'] = 'Saint Vincent &amp; the Grenadines';
$lang['WS'] = 'Samoa';
$lang['SM'] = 'San Marino';
$lang['ST'] = 'Sao Tome and Principe';
$lang['SA'] = 'Saudi Arabia';
$lang['SN'] = 'Senegal';
$lang['SC'] = 'Seychelles';
$lang['SL'] = 'Sierra Leone';
$lang['SG'] = 'Singapore';
$lang['SI'] = 'Slovenia';
$lang['SK'] = 'Slovak Republic';
$lang['SB'] = 'Solomon Islands';
$lang['SO'] = 'Somalia';
$lang['ZA'] = 'South Africa';
$lang['ES'] = 'Spain';
$lang['LK'] = 'Sri Lanka';
$lang['SH'] = 'St. Helena';
$lang['PM'] = 'St. Pierre and Miquelon ';
$lang['SD'] = 'Sudan';
$lang['SR'] = 'Suriname';
$lang['SJ'] = 'Svalbard &amp; Jan Mayen Islands';
$lang['SZ'] = 'Swaziland';
$lang['SE'] = 'Sweden';
$lang['CH'] = 'Switzerland';
$lang['SY'] = 'Syria';
$lang['TW'] = 'Taiwan';
$lang['TJ'] = 'Tajikistan';
$lang['TZ'] = 'Tanzania';
$lang['TH'] = 'Thailand';
$lang['TG'] = 'Togo';
$lang['TK'] = 'Tokelau';
$lang['TO'] = 'Tonga';
$lang['TT'] = 'Trinidad and Tobago';
$lang['TN'] = 'Tunisia';
$lang['TR'] = 'Turkey';
$lang['TM'] = 'Turkmenistan';
$lang['TC'] = 'Turks and Caicos Islands';
$lang['TV'] = 'Tuvalu';
$lang['UG'] = 'Uganda';
$lang['UA'] = 'Ukraine';
$lang['AE'] = 'United Arab Emirates';
$lang['UK'] = 'United Kingdom';
$lang['US'] = 'United States';
$lang['UM'] = 'US Minor Outlying Islands';
$lang['UY'] = 'Uruguay';
$lang['UZ'] = 'Uzbekistan';
$lang['VU'] = 'Vanuatu';
$lang['VA'] = 'Vatican City State (Holy See)';
$lang['VE'] = 'Venezuela';
$lang['VN'] = 'Viet Nam';
$lang['VG'] = 'Virgin Islands (British)';
$lang['VI'] = 'Virgin Islands (U.S.)';
$lang['WF'] = 'Wallis and Futuna Islands';
$lang['EH'] = 'Western Sahara';
$lang['YE'] = 'Yemen';
$lang['YU'] = 'Yugoslavia';
$lang['ZM'] = 'Zambia';
$lang['ZW'] = 'Zimbabwe';
$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->helptext</td><td>the field&#039;s help text</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->alias</td><td>the alias specified for this field</td></tr>
<tr><td>field->id</td><td>the internal / opaque id FormBuilder uses for this field</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 the case of a multipage form, you will also have access to the value of previous fields. They
are in the $previous array, or accessible by their names (e.g., {$myfield->value} ).
You can use this in Static Text fields as well, which is a nice way to personalize forms!</p>

<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>in_formbrowser</td><td>1 if form is being viewed from FormBrowser</td></tr>
<tr><td>in_admin</td><td>1 if form is being viewed via FormBrowser admin</td></tr>
<tr><td>fbr_id</td><td>Response ID if form is being viewed from FormBrowser</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'] = 'FormBuilder installed. Please consult the module&#039;s Help page for documentation.';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create 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 {FormBuilder 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>Button. This doens&#039;t do anything, but you can hook it into some Javascript.</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>Password. This is an asterisked-out text field, useful for passwords.</li>
<li>Password Again (verify). This is a field that must match a Password field for submission
to succeed.</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 &quot;From Address&quot; 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 &quot;From Name&quot; 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>
<li>-User Tag. This calls the specified User Defined Tag, and displays anything it returns. The UDT gets called any time the field would be visible.</li>
</ul></li>
<li>-Module Include Tag. This allows you to embed other module output into your form, e.g., a list of products from the Products module.</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 $params[&#039;field_name&#039;], and as $params[&#039;field_alias&#039;] (if defined).</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 &quot;From Address&quot; Field, and send copy. This works like the Email &quot;From Address&quot; Field described above, but it provides options for sending a copy of the results to the user.</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 results based on frontend fields. This field is an email disposition that allows form fields&#039; user input to specify the Email Subject, &quot;From Name&quot;, &quot;From Address&quot;, and Destination Email Address.</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. <strong>Deprecated.</strong> Use Store Results for FormBrowser Module instead! 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>*Write Results to a Unique Flat File for each submission. This takes the form results and writes them to a unique text file for each form submission.
You can specify a filename pattern using values from form fields, set its format, and set the directory where the files will be stored.</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.0.3. Stores the form results in an XML structure as a single database record. This is the only interface to Form Browser. See section below.</li>
<li>*Submit to an arbitrary form action. Craft an HTTP GET or POST, and transmit it using cURL to the specified URL. This lets you use FormBuilder as a front-end to any CGI or Form Handling script out there.</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>{FormBuilder 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 unwieldy or contain characters that don&#039;t work well with Smarty. So there is an
alternative like this:</p>
<p>{FormBuilder 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 its 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. As of version 0.5, variables also have aliases, which you can use.</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>Use with FormBrowser v3</h3>
<p>There are some special features when using FormBuilder with FormBrowser. The new approach stores the form results in XML, so that far fewer
queries are needed to retrieve records. This means you can use FormBrowser with hundreds or even thousands of records. It also means you
will have to choose up front which fields you will want to be able to sort by. You can choose up to five. Changing these after there are submitted records will result in improper sorting! A re-index function will be added to a future version.</p>
<p>In advanced options, you can tie a form to Frontend Users. That means each user gets one record for the form; they can create it
a single time, subsequent times they will be editing their record. The record will not be visible to any other users (excluding admins).
This form should be added to your page using the syntax {FormBuilder action=&#039;feuserform&#039; form=&#039;form_name&#039;}.</p>
<p>For greater data safety, you can encrypt the stored forms in the database. You can use the built-in mycrypt library or the OpenSSL module.
In either case, for the passphrase, you can either enter text in the field or a file name. If you specify a file name, the contents of that
file will be used as the passphrase for encrypting.</p>
<p>If you encrypt, be aware that the fields you use for sorting are <strong>not</strong> encrypted. You can choose to hash them; the cheat here
is that the first four letters are left intact to allow for sorting. The sorting may not be perfect, and this weakens the security since it
exposes some cleartext, but it is better than nothing.</p>
<p><strong>DISCLAIMER</strong>. The encryption offered here should be considered just one more hurdle for a hacker, not as a guarantee that
your information will be secure. A smart hacker who has found some exploit to view database records may well be smart enough to get at
the module source code, and find their way to the passphrase. This will not protect you against an enemy who has full access to your
server, some familiarity with PHP, and the time to poke around. <em><strong>Do not</strong> use this to protect high-value information such as financial data,
sensitive political information, human rights data, or anything else that might be of value to a repressive government or organized crime
cartel.</em></p>
<h3>Using with User Defined Tags (UDTs)</h3>
<p>Several options for customizing behavior via UDTs is provided (thanks to kind code contributions, see credits).</p>

<ul><li>Call User Defined Tag With the Form Results. This field type submits the human-readable form results to the User-Defined
Tag you specify. The UDT can handle the results however it wants. Values are passed as $params[&#039;field_name&#039;], and
as $params[&#039;field_alias&#039;] (if defined). As per a suggestion, it also populates all of the Smarty values that would be visible to the Submission Template too!</li>
<li>User Tag Field. This calls the specified UDT, and displays anything it returns. The UDT gets called any time the field would be visible.</li>
<li>Validation UDT. Set this for a form, and the UDT will receive all of the form\&#039;s human-readable results. The UDT should do whatever
validation it wants, and return an array with the first value being true or false (indication whether the form validates), and the second
value being error messages (if any).</li>
<li>User defined tag to call before form is displayed the first time (only called once). This
is set in the Form Admin in the UDT Integration tab. The UDT gets called on the first display
of the form.</li>
<li>User defined tag to call before form is displayed (called on every page of multipage
forms). This is set in the Form Admin in the UDT Integration tab. The UDT gets called
every time any page of the form is displayed (including when validation fails).</li>
</ul>
<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>Run in MLE Mode. This changes some queries against the content table to try to prevent ugly crashes under the MLE fork. Checking this will cause ugly crashes if you are NOT running the MLE fork.</li>
<li>Hide Errors. This is no longer set by default. Checking it will hide the more detailed errors that would 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>After a bit of nagging on the part of people who actually respect standards, FormBuilder no longer encourages tricks like embedding CSS in 
static text fields. Instead, it creates a stylesheet called &quot;FormBuilder Default&quot; that you are encouraged to attach to the page template
that you use for pages that contain your form.</p>  
<p>This default CSS was graciously provided by Paul Noone.</p>


<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->helptext</td><td>the field&#039;s help text</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->alias</td><td>the alias specified for this field</td></tr>
<tr><td>field->id</td><td>the internal / opaque id FormBuilder uses for this field</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 the case of a multipage form, you will also have access to the value of previous fields. They
are in the $previous array, or accessible by their names (e.g., {$myfield->value} ).
You can use this in Static Text fields as well, which is a nice way to personalize forms!</p>

<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>in_formbrowser</td><td>1 if form is being viewed from FormBrowser</td></tr>
<tr><td>in_admin</td><td>1 if form is being viewed via FormBrowser admin</td></tr>
<tr><td>fbr_id</td><td>Response ID if form is being viewed from FormBrowser</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>Credits</h3>
<p>Many people have contributed code, bug reports, cash, and ideas to FormBuilder. Among them (alphabetically):
<ul>
<li><a href="http://www.bpti.eu">Baltic institute of advanced technology</a> - code, funding </li>
<li>Jeremy Bass - code and suggestions</li>
<li>Alberto Benati - code</li>
<li>Tyler Boespflug - funding and ideas</li>
<li>Jeff Bosch - UDT Validation</li>
<li>Robert Campbell - numerous code contributions</li>
<li>Piotras Cimmperman - code</li>
<li>Nuno Costa - suggestions</li>
<li>Ryan Foster - code</li>
<li>Marc Geldon - code</li>
<li>Kevin Grandon - code</li>
<li>Ronny Krijt - code</li>
<li>Paul Noone - CSS and ideas</li>
<li>Morten Poulsen - code</li>
<li>Prue Rowland - bug fixes</li>
<li>Simon Schaufelberger - code</li>
<li>Adam Shaw-Vardi - funding and ideas</li>
</ul>
<p>I apologize for any omissions - notify me, and I&#039;ll correct the omission!</p>
<h3>Miscellaneous Notes</h3>
<ul>
<li>Any fields that sends email to a specified email address will also accept a comma-separated list of email addresses.</li>
</ul>
<h3>Known Issues</h3>
<ul>
<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>FormBuilder/FormBrowser <strong>requires</strong> PHP 5 or later to function correctly.</li>
<li>First step is to check you&#039;re running CMS 1.6 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> Make sure you can successfully send email via the test in the CMSMailer Module. It&#039;s simply amazing how many problems boil down to a misconfigured CMSMailer.</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>
<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 <em>hundreds and hundreds of hours</em> 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><form action=&quot;https://www.paypal.com/cgi-bin/webscr&quot; method=&quot;post&quot;>
<input type=&quot;hidden&quot; name=&quot;cmd&quot; value=&quot;_s-xclick&quot;>
<input type=&quot;image&quot; src=&quot;https://www.paypal.com/en_US/i/btn/btn_donateCC_LG.gif&quot; border=&quot;0&quot; name=&quot;submit&quot; alt=&quot;PayPal - The safer, easier way to pay online!&quot;>
<img alt=&quot;&quot; border=&quot;0&quot; src=&quot;https://www.paypal.com/en_US/i/scr/pixel.gif&quot; width=&quot;1&quot; height=&quot;1&quot;>
<input type=&quot;hidden&quot; name=&quot;encrypted&quot; value=&quot;-----BEGIN PKCS7-----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-----END PKCS7-----
&quot;>
</form><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; 2009, 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['utma'] = '156861353.933673340.1320437161.1320567601.1320576045.4';
$lang['utmz'] = '156861353.1320567601.3.3.utmcsr=feedburner|utmccn=Feed: cmsmadesimple/blog (CMS Made Simple)|utmcmd=feed';
$lang['qca'] = 'P0-91463818-1318971343774';
$lang['utmb'] = '156861353';
$lang['utmc'] = '156861353';
?>]]></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_PasswordField'] = 'L&ouml;senord';
$lang['field_type_PasswordAgainField'] = 'L&ouml;senord igen';
$lang['field_type_TextFieldExpandable'] = 'Inmatningsf&auml;lt (flera)';
$lang['field_type_TextAreaField'] = 'Textruta (textarea)';
$lang['field_type_ButtonField'] = 'Knapp';
$lang['field_type_CheckboxField'] = 'Kryssruta (check box)';
$lang['field_type_CheckboxGroupField'] = 'Kryssrutegrupp (check box group)';
$lang['field_type_PulldownField'] = 'Rullgardinsmeny';
$lang['field_type_YearPullDownField'] = '&Aring;r Rullgardinsmeny';
$lang['field_type_MultiselectField'] = 'Multiv&auml;ljare';
$lang['field_type_StatePickerField'] = 'V&auml;ljare f&ouml;r amerikansk stat';
$lang['field_type_ProvincePickerField'] = 'Kanadensisk Provins V&auml;ljare';
$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_DispositionForm'] = '*Submit to an arbitrary form action';
$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'] = '- Unikt heltal (Serie)';
$lang['field_type_UserTagField'] = '-Anv&auml;ndar Definierat Tag Anrop';
$lang['field_type_CompanyDirectoryField'] = 'F&ouml;retagskatalog f&auml;lt';
$lang['field_type_ModuleInterfaceField'] = '-Modulgr&auml;nssnitts f&auml;lt';
$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['please_login'] = 'V&auml;nligen logga in f&ouml;r att anv&auml;nda formul&auml;ret';
$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['please_enter_at_least'] = 'Var v&auml;nlig ange ett v&auml;rde som &auml;r minst %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['css'] = 'CSS';
$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['tab_udt'] = 'UDT Integration';
$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'] = 'V&auml;rdeupps&auml;ttning: %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'] = 'Ett vanligt uttryck f&ouml;r att till&aring;ta filtrering av kataloger genom namn';
$lang['help_field_height'] = 'H&ouml;jden p&aring; flervalsf&auml;ltet';
$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_field_alias_short'] = 'Alias';
$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'] = 'Om du klickar h&auml;r kommer f&auml;ltalias att visas n&auml;r du l&auml;gger till eller redigerar ett formul&auml;r';
$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_button_text'] = 'Knapp text';
$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_field_css_id'] = 'CSS id f&ouml;r detta f&auml;lt';
$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_predisplay_udt'] = 'Anv&auml;ndardefinierad tag att l&auml;sa in f&ouml;re formul&auml;ret visas';
$lang['title_form_predisplay_each_udt'] = 'Anv&auml;ndardefinierad tag att anropa innan formul&auml;r visas (anropad p&aring; varje sida som ing&aring;r i ett formul&auml;r med flera sidor)';
$lang['title_form_validate_udt'] = 'Anv&auml;ndardefinierad tag att anropa under formul&auml;r validation';
$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['title_read_only'] = 'Read Only';
$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'] = 'Klicka h&auml;r om du bara vill ha f&ouml;rkryssade rutors v&auml;rden.';
$lang['link_label'] = 'L&auml;nktetikett';
$lang['link_destination'] = 'URL';
$lang['title_default_set'] = 'Ikryssad som standard?';
$lang['title_24_hour'] = 'Anv&auml;nd 24-timmars tidsangivelse?';
$lang['title_before_noon'] = 'EM';
$lang['title_after_noon'] = 'FM';
$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_default_blank'] = 'Default to blank';
$lang['title_default_blank_help'] = 'Default to blank (uncheck to default to today&#039;s date)';
$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'] = 'Begr&auml;nsa anv&auml;ndarlistan till anv&auml;ndare i viss grupp';
$lang['title_encrypt_database_data'] = 'Kryptera lagrad data i databasen';
$lang['title_crypt_cert'] = 'Certifikat f&ouml;r kryptering av data';
$lang['title_encryption_keyfile'] = 'Passphrase or path to file containing passphrase. (If using OpenSSL, this is the passphrase for the private key)';
$lang['title_encrypt_sortfields'] = 'Hash sort fields?';
$lang['title_private_key'] = 'Privat nyckel f&ouml;r kryptering av data';
$lang['title_encrypt_sortfields_help'] = 'This hashes the sort fields, but leaves the first few letters unencrypted. Cryptographically, this creates a vulnerability, but for most users it is an acceptable tradeoff between security and the ability to sort records. Sorting becomes approximate, but will remain pretty good. If you do not use this option, sort fields are stored in plaintext.';
$lang['title_encryption_functions'] = 'Lagringskryptering otillg&auml;nglig';
$lang['title_install_crypto'] = 'Var v&auml;nlig installera OpenSSL modulen eller mcrypt st&ouml;d om du vill m&ouml;jligg&ouml;ra databaskryptering';
$lang['title_install_curl'] = 'Kontrollera att du har st&ouml;d f&ouml;r CURL aktiverat i din PHP installation. Se http://www.php.net/manual/en/book.curl.php';
$lang['title_mle_version'] = 'K&ouml;r i MLE l&auml;ge';
$lang['title_mle_version_long'] = 'Changes/support for CMSMS Multi-Language Edition fork. Do not check this if you are not running the MLE version.';
$lang['title_ensure_cert_key_match'] = 'Ensure that you select the private key that is appropriate for the certificate you are using for encryption!';
$lang['choose_crypt'] = 'Krypterings bibliotek';
$lang['title_encrypt_database_long'] = 'Check this to encrypt the stored data. This makes it more difficult (but not impossible) for hackers to view the information.';
$lang['choose_crypt_long'] = 'The options below only apply if you are using the OpenSSL Encryption library';
$lang['title_crypt_lib'] = 'Krypterings bibliotek';
$lang['openssl'] = 'OpenSSL Library';
$lang['mcrypt'] = 'PHP mcrypt Library';
$lang['title_feu_binding'] = 'Frontend User binding';
$lang['title_install_feu'] = 'Var v&auml;nlig installera Frontend User modulen f&ouml;r att koppla ett formul&auml;r och dess data till en specifik anv&auml;ndare';
$lang['title_feu_bind_help'] = 'Check this to lock front-end access to this form&#039;s data to the logged-in front-end user.';
$lang['title_encryption'] = 'Kryptering';
$lang['title_export_form_to_udt'] = 'Export form reference to UDT as $params[&#039;FORM&#039;]?';
$lang['title_url_help'] = 'Entire URL, including protocol and path (e.g., http://myhost.com/form_handler.cgi)';
$lang['title_url'] = 'Form submission URL';
$lang['title_method'] = 'Form method';
$lang['title_maps_to'] = 'Map field &quot;%s&quot; to form submission variable';
$lang['title_additional'] = 'Additional submission';
$lang['title_additional_help'] = 'Anything to be appended to the submission payload, in URL-encoded form (.e.g, &quot;user=steve+jobs&amp;employee_number=1)';
$lang['title_include_in_submission'] = 'Include field in Submission';
$lang['title_data_stored_in_fbr'] = 'Data will be stored in an XML format in the [PREFIX]_module_fb_frombrowser database table.';
$lang['error_has_no_fb_field'] = 'Error! Either the form has no form_builder disposition, or it failed to instantiate (due to memory issues?)';
$lang['restricted_to_group'] = 'Endast i grupp %s';
$lang['title_show_to_user'] = 'Visa f&ouml;r anv&auml;ndare?';
$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'] = 'Skapa Provmall f&ouml;r Headern';
$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'] = 'Start p&aring; &aring;romf&aring;ng';
$lang['title_end_year'] = 'Slut p&aring; &aring;romf&aring;ng';
$lang['title_default_year'] = 'Standard &Aring;r';
$lang['title_default_year_help'] = '(S&auml;tt till -1 f&ouml;r att standard&aring;r ska vara nuvarande &aring;r)';
$lang['title_submit_action'] = 'Efter att formul&auml;ret l&auml;mnats in';
$lang['title_submit_response'] = 'Response to display';
$lang['title_submit_date'] = 'Date Submitted';
$lang['title_approval_date'] = 'Datum Godk&auml;nd (av admin)';
$lang['title_user_approved'] = 'Date Approved (by submitter)';
$lang['display_text'] = 'Display &quot;Submission Template&quot;';
$lang['redirect_to_page'] = 'Skicka till sida';
$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'] = 'Kr&auml;ver f&auml;ltnamn';
$lang['title_require_fieldnames_long'] = 'Kr&auml;v att f&auml;lt har ett namn?';
$lang['title_unique_fieldnames'] = 'Kr&auml;v unika f&auml;ltnamn';
$lang['title_unique_fieldnames_long'] = 'Kr&auml;v att f&auml;lt har unika namn?';
$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'] = 'Radera knapptext';
$lang['title_field_helptext'] = 'Hj&auml;lp-text att visas med det h&auml;r f&auml;ltet';
$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'] = 'Standardv&auml;rde f&ouml;r f&auml;lt';
$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 f&ouml;r f&auml;lt';
$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'] = 'V&auml;lj inte bara en slumpartad adress h&auml;r -- m&aring;nga ISPs kommer <br /> inte att leverera mailet om du anv&auml;nder en annan dom&auml;n &auml;n ditt verkliga <br /> host (d.v.s., anv&auml;nd n&aring;got som namn@%s)';
$lang['title_switch_advanced'] = 'Beh&ouml;ver du fler f&auml;lttyper? ';
$lang['title_switch_basic'] = 'F&ouml;r m&aring;nga f&ouml;rvirrande f&auml;lttyper?';
$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'] = 'Folder f&ouml;r att spara filer i';
$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'] = 'Skicka mig en kopia av formul&auml;ret';
$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['title_display_length'] = 'Display length';
$lang['title_minimum_length'] = 'Minimum response length';
$lang['title_hide'] = 'Hide input';
$lang['title_hide_help'] = 'Show symbols rather plain text when user enters password?';
$lang['password_does_not_match'] = 'L&ouml;senord matchar inte %s';
$lang['back_top'] = 'Back to FormBuilder Main Page';
$lang['title_headers_to_modify'] = 'Which email headers should this input populate?';
$lang['title_blank_invalid'] = 'Do not accept blank space as valid response';
$lang['title_blank_invalid_long'] = 'If a field is required, checking this will require that people put in some alphanumeric characters, not just spaces';
$lang['error_CompanyDirectory_module_not_available'] = 'Company Directory module is not available!';
$lang['option_never'] = 'Aldrig';
$lang['option_user_choice'] = 'Ge bes&ouml;karen ett val (checkbox)';
$lang['option_always'] = 'Alltid';
$lang['option_from'] = '&quot;From&quot; email address';
$lang['option_reply'] = '&quot;Reply-To&quot; email address';
$lang['option_both'] = 'Both &quot;From&quot; and &quot;Reply-To&quot; email addresses';
$lang['option_dropdown'] = 'Dropdown';
$lang['option_selectlist_single'] = 'Select List (single)';
$lang['option_selectlist_multiple'] = 'Select List (multiple)';
$lang['option_radiogroup'] = 'Radio Group';
$lang['title_company_field_note'] = 'Note: Output will be in the form of<br/>&quot;company name&quot;=>&quot;value&quot;';
$lang['title_pick_categories'] = 'Pick a category (multiple)';
$lang['title_pick_fielddef'] = 'Pull a field Definition&#039;s value (single) <em>optional</em>';
$lang['title_choose_user_input'] = 'Choose User input';
$lang['title_see_also_udt'] = '(Also take a look at the Form Submission tab if you want to set a UDT for form validation)';
$lang['title_year_end_message'] = 'End year';
$lang['error_usertag_disposition'] = 'User defined tag returned an error';
$lang['error_usertag'] = 'User defined tag %s returned an error.';
$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['help_module_interface'] = 'Using Module Interface';
$lang['help_module_interface_long'] = '<b>This field is used as a gateway to other modules!</b>
Use it by creating your form elements in the templates of the other module(s) you wish to incorporate, and using the <strong>{$FBid}</strong> to tie it back to FormBuilder. For example, to include form options based on the Products module, create the following template in Products:<br/>
<pre>
{foreach from=$items item=entry}
	{assign var=MData value=&#039;&#039;}
	{assign var=Cd value=&#039;&#039;}
		{foreach from=$FBvalue item=MData}
			{assign var=MData value=&#039;::&#039;|explode:$MData}
			{if $MData[1]==$entry->id}
				{assign var=Cd value=&#039; checked=&quot;checked&quot;&#039;}
			{/if}
		{/foreach}
	<div class=&quot;ProductDirectoryItem&quot;>
		<input type=&quot;checkbox&quot; value=&quot;{$entry->price}::{$entry->id}&quot; name=&quot;{$FBid}[]&quot; {$Cd} />{$entry->product_name} ({$entry->weight}{$weight_units}) &pound;{$entry->price}    
	</div>
{/foreach}
</pre>
<br/>
where in the input below you put something like <strong>{Products category=&quot;cat&quot; summarytemplate=&quot;Your_FB_template&quot;}</strong>';
$lang['title_add_tag'] = 'L&auml;gg till din tag';
$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'] = 'Uppladdnings/Bifogningsfel f&ouml;r fil %s (tmp_name: %s, av typen %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'] = 'Standard: omarkerad';
$lang['checked_by_default'] = 'Standard: markerad';
$lang['email_default_template'] = 'FormBuilder Submission';
$lang['email_template_not_set'] = '<br/>Ingen epostmall &auml;r tillsatt!';
$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, 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['qca'] = 'P0-245748072-1251504180990';
$lang['utmz'] = '156861353.1269894903.22.15.utmcsr=google|utmccn=(organic)|utmcmd=organic|utmctr=modules cmsms';
$lang['utma'] = '156861353.2917280715391859000.1251504181.1269540149.1269891113.22';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353.1.10.1269891113';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/ext/tr_TR.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'] = 'Text Input';
$lang['field_type_HTML5NumberField'] = 'HTML5 Number Input';
$lang['field_type_HTML5EmailField'] = 'HTML5 Email Input';
$lang['field_type_HTML5URLField'] = 'HTML5 URL Input';
$lang['field_type_PasswordField'] = 'Şifre';
$lang['field_type_PasswordAgainField'] = 'Şifre Tekrar (doğrulama)';
$lang['field_type_TextFieldExpandable'] = 'Text Input (Multiple)';
$lang['field_type_TextAreaField'] = 'Text Area';
$lang['field_type_ButtonField'] = 'Buton';
$lang['field_type_CheckboxField'] = 'Check Box';
$lang['field_type_CheckboxGroupField'] = 'Check Box Group';
$lang['field_type_PulldownField'] = 'Pulldown';
$lang['field_type_YearPullDownField'] = 'Year 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 &quot;From Address&quot; Field, and send copy';
$lang['field_type_DispositionFile'] = '*Write Results to Flat File';
$lang['field_type_DispositionUniqueFile'] = '*Write Results to a Unique Flat File for each submission';
$lang['field_type_DispositionDatabase'] = '*Store Results in Database';
$lang['field_type_DispositionFormBrowser'] = '*Store Results for FormBrowser Module v.0.3';
$lang['field_type_DispositionUserTag'] = '*Call A User Defined Tag With the Form Results';
$lang['field_type_DispositionForm'] = '*Submit to an arbitrary form action';
$lang['field_type_DispositionDeliverToEmailAddressField'] = '*Email to User-Supplied Email Address';
$lang['field_type_DispositionEmailSiteAdmin'] = '*Email to CMS Admin User';
$lang['field_type_DispositionEmailBasedFrontendFields'] = '*Email results based on frontend fields';
$lang['field_type_PageBreakField'] = '-Sayfa Sonu';
$lang['field_type_FileUploadField'] = 'File Upload';
$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'] = '-Statik Yazı';
$lang['field_type_SystemLinkField'] = '-Statik 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['field_type_UserTagField'] = '-User Defined Tag Call';
$lang['field_type_CompanyDirectoryField'] = 'Company Directory Alanı';
$lang['field_type_ModuleInterfaceField'] = '-Module Interface Field';
$lang['validation_none'] = 'No Validation';
$lang['validation_numeric'] = 'Numerik';
$lang['validation_integer'] = 'Integer';
$lang['validation_email_address'] = 'Email Adresi';
$lang['validation_usphone'] = 'Telefon Numarası (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['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['please_login'] = 'Please log in to use this form';
$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['please_enter_at_least'] = 'Please enter a value that is at least %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 silindi.';
$lang['field_deleted'] = 'Field silindi.';
$lang['configuration_updated'] = 'Konfig&uuml;rasyon G&uuml;ncellendi.';
$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['no_field_assigned'] = 'No field assigned for %s';
$lang['anonymous'] = 'Bilinmeyen';
$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'] = 'eklendi';
$lang['updated'] = 'g&uuml;ncellendi';
$lang['sort_options'] = 'Sort options on output';
$lang['select_one'] = 'Se&ccedil;iniz';
$lang['select_type'] = 'Se&ccedil;iniz';
$lang['to'] = 'To';
$lang['yes'] = 'Evet';
$lang['no'] = 'Hayır';
$lang['recipients'] = 'recipients';
$lang['fields'] = 'fields';
$lang['file_count'] = '%s possible files';
$lang['destination_count'] = '%s destinations';
$lang['save'] = 'Kaydet';
$lang['add'] = 'Ekle';
$lang['update'] = 'G&uuml;ncelle';
$lang['save_and_continue'] = 'Kaydet ve d&uuml;zenlemeye devam et';
$lang['information'] = 'Bilgi';
$lang['automatic'] = 'Otomatik';
$lang['forms'] = 'Formlar';
$lang['form'] = 'Form %s';
$lang['configuration'] = 'Ayarlar';
$lang['field_requirement_updated'] = 'Field required state updated.';
$lang['maximum_size'] = 'Max. Size';
$lang['permitted_extensions'] = 'Extensions';
$lang['permitted_filetypes'] = 'İzin verilen dosya tipleri';
$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'] = 'Y&uuml;kle';
$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 Saat';
$lang['24_hour'] = '24 Saat';
$lang['hour'] = 'Saat';
$lang['min'] = 'Dakika';
$lang['merid'] = 'Meridian';
$lang['date_range'] = 'Range: %s - %s';
$lang['thanks'] = 'Thanks! Your submissions have been received.';
$lang['edit'] = 'D&uuml;zenle';
$lang['delete'] = 'Sil';
$lang['day'] = 'G&uuml;n';
$lang['mon'] = 'Ay';
$lang['year'] = 'yıl';
$lang['none'] = '(yok)';
$lang['css'] = 'CSS';
$lang['uninstalled'] = 'Mod&uuml;l kaldırıldı.';
$lang['installed'] = 'Module version %s installed.';
$lang['upgraded'] = 'Module upgraded to version %s.';
$lang['button_previous'] = 'Geri...';
$lang['button_submit'] = 'G&ouml;nder';
$lang['button_continue'] = 'Devam...';
$lang['value_checked'] = 'Se&ccedil;ili';
$lang['value_unchecked'] = 'Se&ccedil;ili Değil';
$lang['tab_main'] = 'Main';
$lang['tab_symbol'] = 'Form G&ouml;r&uuml;n&uuml;m Ayarları';
$lang['tab_submit'] = 'Form Submission';
$lang['tab_captcha'] = 'Captcha Ayarları';
$lang['tab_advanced'] = 'Gelişmiş Ayarlar';
$lang['tab_templatelayout'] = 'Form Şablonu';
$lang['tab_submissiontemplate'] = 'Submission Template';
$lang['tab_udt'] = 'UDT Entegrasyonu';
$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'] = 'İptal';
$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_allow_overwrite'] = 'Allow upload to overwrite previously files?';
$lang['title_allow_overwrite_long'] = 'Should uploaded file overwrite previously uploaded file if it has the same name?';
$lang['overwrite'] = 'Allows Overwriting';
$lang['nooverwrite'] = 'No Overwrite';
$lang['file_already_exists'] = 'File %s already exists, and cannot be overwritten.';
$lang['title_file_rename'] = 'Filename template';
$lang['original_file_extension'] = 'Original file extension (includes the &quot;.&quot;)';
$lang['title_suppress_filename'] = 'Suppress filename in emails and forms the end user will see';
$lang['file_rename_help'] = 'To rename a file upon uploading, create the template here. Leave blank to preserve original filename';
$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'] = 'Sil?';
$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'] = 'Dosya Adı';
$lang['title_email_subject'] = 'Email Konu Alanı';
$lang['title_form_name'] = 'Form Adı';
$lang['title_form_status'] = 'Form Stat&uuml;s&uuml;';
$lang['title_ready_for_deployment'] = 'Ready for Deployment';
$lang['title_not_ready1'] = 'Hazır Değil';
$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_field_alias_short'] = 'Alias';
$lang['title_form_fields'] = 'Form Alanları';
$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 and DOM id (CSS id) attribute';
$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'] = 'Yeni Form Ekle';
$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_button_text'] = '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_field_css_id'] = 'CSS id for this field';
$lang['title_form_css_class'] = 'CSS Class for this form';
$lang['title_field_css_class'] = 'CSS Class for this field';
$lang['title_form_predisplay_udt'] = 'User defined tag to call before form is displayed the first time (only called once)';
$lang['title_form_predisplay_each_udt'] = 'User defined tag to call before form is displayed (called on every page of multipage forms)';
$lang['title_form_validate_udt'] = 'User defined tag to call during form validation';
$lang['title_form_required_symbol'] = 'Symbol to mark required Fields';
$lang['title_field_required'] = 'Zorunlu';
$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_textarea_length'] = 'Maximum length of field content (0 or blank means no limit)';
$lang['title_text'] = 'Static text to display';
$lang['title_field_regex'] = 'Validation Regex';
$lang['title_lines_to_show'] = 'Number of Lines to display';
$lang['title_read_only'] = 'Salt Okunur';
$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'] = 'Hataları Gizle';
$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 Şablonu';
$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_file_destination'] = 'Directory to save files into';
$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'] = 'Hızlı Alan Ekleyici';
$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_default_blank'] = 'Default to blank';
$lang['title_default_blank_help'] = 'Default to blank (uncheck to default to today&#039;s date)';
$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['title_encrypt_database_data'] = 'Encrypt data stored in database';
$lang['title_crypt_cert'] = 'Certificate for encrypting data';
$lang['title_encryption_keyfile'] = 'Passphrase or path to file containing passphrase. (If using OpenSSL, this is the passphrase for the private key)';
$lang['title_encrypt_sortfields'] = 'Hash sort fields?';
$lang['title_private_key'] = 'Private Key to use for encrypting data';
$lang['title_encrypt_sortfields_help'] = 'This hashes the sort fields, but leaves the first few letters unencrypted. Cryptographically, this creates a vulnerability, but for most users it is an acceptable tradeoff between security and the ability to sort records. Sorting becomes approximate, but will remain pretty good. If you do not use this option, sort fields are stored in plaintext.';
$lang['title_encryption_functions'] = 'Storage Encryption Unavailable';
$lang['title_install_crypto'] = 'Please install the OpenSSL module or mcrypt support if you would like to enable database encryption.';
$lang['title_install_curl'] = 'Please make sure you have CURL support active in your PHP install. See http://www.php.net/manual/en/book.curl.php';
$lang['title_mle_version'] = 'Run in MLE Mode';
$lang['title_mle_version_long'] = 'Changes/support for CMSMS Multi-Language Edition fork. Do not check this if you are not running the MLE version.';
$lang['title_ensure_cert_key_match'] = 'Ensure that you select the private key that is appropriate for the certificate you are using for encryption!';
$lang['choose_crypt'] = 'Encryption Library';
$lang['title_encrypt_database_long'] = 'Check this to encrypt the stored data. This makes it more difficult (but not impossible) for hackers to view the information.';
$lang['choose_crypt_long'] = 'The options below only apply if you are using the OpenSSL Encryption library';
$lang['title_crypt_lib'] = 'Encryption Library';
$lang['openssl'] = 'OpenSSL Library';
$lang['mcrypt'] = 'PHP mcrypt Library';
$lang['title_feu_binding'] = 'Frontend User binding';
$lang['title_install_feu'] = 'Please install the Frontend User module to connect a form and its data to a specific user';
$lang['title_feu_bind_help'] = 'Check this to lock front-end access to this form&#039;s data to the logged-in front-end user.';
$lang['title_encryption'] = 'Encryption';
$lang['title_export_form_to_udt'] = 'Export form reference to UDT as $params[&#039;FORM&#039;]? (do not do this if you are going to print_r($params) )';
$lang['title_url_help'] = 'Entire URL, including protocol and path (e.g., http://myhost.com/form_handler.cgi)';
$lang['title_url'] = 'Form submission URL';
$lang['title_method'] = 'Form method';
$lang['title_maps_to'] = 'Map field &quot;%s&quot; to form submission variable';
$lang['title_additional'] = 'Additional submission';
$lang['title_additional_help'] = 'Anything to be appended to the submission payload, in URL-encoded form (.e.g, &quot;user=steve+jobs&amp;employee_number=1)';
$lang['title_include_in_submission'] = 'Include field in Submission';
$lang['title_date_order'] = 'Date component field order (for input)';
$lang['title_data_stored_in_fbr'] = 'Data will be stored in an XML format in the [PREFIX]_module_fb_frombrowser database table.';
$lang['error_has_no_fb_field'] = 'Error! Either the form has no form_builder disposition, or it failed to instantiate (due to memory issues?)';
$lang['help_date_order'] = 'Use &quot;m&quot; for Month, &quot;d&quot; for Day, and &quot;y&quot; for Year. Separate the items by hyphens.';
$lang['restricted_to_group'] = 'Only in group %s';
$lang['title_show_to_user'] = 'Display to user?';
$lang['title_use_random_generator'] = 'Use random number generator instead of static';
$lang['title_numbers_to_generate'] = 'How many numbers to generate in process';
$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'] = 'Tarih';
$lang['help_server_name'] = '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 versiyon';
$lang['help_tab'] = 'Tab Karakteri';
$lang['help_ignored_if_upload'] = '(This field ignored if you use the Uploads module to manage files)';
$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['help_rtf_file_template'] = 'Specify a file located in the FormBuilder/templates/ folder. This field is ignored if you use TXT as your file type.';
$lang['help_rtf_template_type'] = 'Basic: Use the textarea below to layout the field names/values in a single block.<br />
Advanced: Specify Smarty variables in the RTF Template File as you would below, but arrange them however you like and add formatting.<br />
&nbsp;You can still use the %%HEADER%% and %%FOOTER%% sections in the RTF file.';
$lang['help_unique_file_template'] = 'For TXT, this will be immediately after the Header Template.<br />
For RTF, this will replace the %%FIELDS%% string in the template file if RTF Template Type is set to &quot;Basic&quot;.<br />
This field will be ignored if using &quot;RTF&quot; as File Type and &quot;Advanced&quot; as RTF Template Type.';
$lang['help_file_header_template'] = 'For TXT, this will be placed at the top of the file. For RTF, this will replace the %%HEADER%% string in the template file.';
$lang['help_file_footer_template'] = 'For TXT, this will be placed at the bottom of the file. For RTF, this will replace the %%FOOTER%% string in the template file.';
$lang['link_back_to_form'] = '&laquo; Forma Geri D&ouml;n';
$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_footer_template'] = 'Create Sample Footer 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_file_footer'] = 'Template for the footer of output file';
$lang['title_rtf_file_template'] = 'Template RTF file to use';
$lang['title_unique_file_template'] = 'Template for output';
$lang['title_file_type'] = 'Choose a file type to use';
$lang['title_rtf_template_type'] = 'Choose an RTF template type';
$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 for display (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'] = 'Yıl aralığı başlangıcı';
$lang['title_end_year'] = 'Yıl aralığı sonu';
$lang['title_default_year'] = 'Varsayılan Yıl';
$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['title_submit_date'] = 'Date Submitted';
$lang['title_approval_date'] = 'Date Approved (by admin)';
$lang['title_user_approved'] = 'Date Approved (by submitter)';
$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'] = 'Y&ouml;nlendirilecek Sayfa';
$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_field_helptext'] = 'Help-text to display with this field';
$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_string_unspaced'] = 'String (no spaces between fields)?';
$lang['title_compute_value'] = 'Value to compute';
$lang['title_compute'] = 'Computed/PHP';
$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 {FormBuilder} 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['title_display_length'] = 'Display length';
$lang['title_minimum_length'] = 'Minimum response length';
$lang['title_hide'] = 'Hide input';
$lang['title_hide_help'] = 'Show symbols rather plain text when user enters password?';
$lang['password_does_not_match'] = 'Password does not match %s';
$lang['back_top'] = 'Back to FormBuilder Main Page';
$lang['title_headers_to_modify'] = 'Which email headers should this input populate?';
$lang['title_blank_invalid'] = 'Do not accept blank space as valid response';
$lang['title_blank_invalid_long'] = 'If a field is required, checking this will require that people put in some alphanumeric characters, not just spaces';
$lang['title_must_save_order'] = 'You must click one of the &quot;save&quot; buttons to make your new field order permanent.';
$lang['title_html5'] = 'Use HTML5 placeholder text instead of Javascript';
$lang['error_CompanyDirectory_module_not_available'] = 'Company Directory module is not available!';
$lang['option_never'] = 'Never';
$lang['option_user_choice'] = 'Give user a choice (checkbox)';
$lang['option_always'] = 'Always';
$lang['option_from'] = '&quot;From&quot; email address';
$lang['option_reply'] = '&quot;Reply-To&quot; email address';
$lang['option_both'] = 'Both &quot;From&quot; and &quot;Reply-To&quot; email addresses';
$lang['option_dropdown'] = 'Dropdown';
$lang['option_selectlist_single'] = 'Select List (single)';
$lang['option_selectlist_multiple'] = 'Select List (multiple)';
$lang['option_radiogroup'] = 'Radio Group';
$lang['title_company_field_note'] = 'Note: Output will be in the form of<br/>&quot;company name&quot;=>&quot;value&quot;';
$lang['title_pick_categories'] = 'Pick a category (multiple)';
$lang['title_pick_fielddef'] = 'Pull a field Definition&#039;s value (single) <em>optional</em>';
$lang['title_choose_user_input'] = 'Choose User input';
$lang['title_see_also_udt'] = '(Also take a look at the Form Submission tab if you want to set a UDT for form validation)';
$lang['title_year_end_message'] = 'End year';
$lang['title_field_logic'] = 'Smarty data or logic that is meant to be sent with this field';
$lang['title_field_logic_long'] = 'Can be smarty data, javascript, or some other data you wan&#039;t to sent along with this field.<br />Goes through the Smarty compiler, so remember use {literal}{/literal} tags with <script></script>';
$lang['title_field_includelabels'] = 'Include labels';
$lang['title_field_includelabels_help'] = 'Enabling this includes labels to output. example - label: value,label2: value2';
$lang['title_field_siblings'] = 'Link this field to it&#039;s sibling';
$lang['title_field_siblings_help'] = 'Dropdown lists all siblings of this field and allows you to link this field to one of it&#039;s sibling. Makes possible controlling this field with selected sibling controls.';
$lang['title_field_hidebuttons'] = 'Hide control buttons';
$lang['title_field_hidebuttons_help'] = 'Hides frontend control buttons of this field.';
$lang['title_note'] = 'Note';
$lang['title_changing_triggers_reindex'] = 'Changing any of the above fields will trigger a reindex of *all* saved records, so it could take a while.';
$lang['illegal_file'] = 'Attempted upload of illegal file type (%s) from %s';
$lang['title_searchable'] = 'Make records accessible to Search Module';
$lang['title_searchable_help'] = 'Checking this will make all submitted data accessible to the Search Module. DO NOT use this if you encrypt your data -- the information gets exposed to search whether or not it is encrypted!';
$lang['uploaded_outside_webroot'] = '%s (outside web root)';
$lang['title_fbr_edit'] = 'Editable in FormBrowser Admin?';
$lang['error_usertag_disposition'] = 'User defined tag returned an error';
$lang['error_usertag'] = 'User defined tag %s returned an error.';
$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 Response Error. Please make sure you copy the URL from your email correctly!';
$lang['validation_no_field_error'] = 'Validation Response 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 (+). If you use Number evaluation you have basic, very simple math (, +, -, *, /, ). If you use Computed/PHP evaluation, you can
use any function you want, but you need to quote things (substitution occurs before evaluation), e.g., substr(&#039;$fld_22&#039;,0,2).&#039;$fld_23&#039;.';
$lang['help_module_interface'] = 'Using Module Interface';
$lang['help_module_interface_long'] = '<b>This field is used as a gateway to other modules!</b>
Use it by creating your form elements in the templates of the other module(s) you wish to incorporate, and using the <strong>{$FBid}</strong> to tie it back to FormBuilder. For example, to include form options based on the Products module, create the following template in Products:<br/>
<pre>
{foreach from=$items item=entry}
	{assign var=MData value=&#039;&#039;}
	{assign var=Cd value=&#039;&#039;}
		{foreach from=$FBvalue item=MData}
			{assign var=MData value=&#039;::&#039;|explode:$MData}
			{if $MData[1]==$entry->id}
				{assign var=Cd value=&#039; checked=&quot;checked&quot;&#039;}
			{/if}
		{/foreach}
	<div class=&quot;ProductDirectoryItem&quot;>
		<input type=&quot;checkbox&quot; value=&quot;{$entry->price}::{$entry->id}&quot; name=&quot;{$FBid}[]&quot; {$Cd} />{$entry->product_name} ({$entry->weight}{$weight_units}) &pound;{$entry->price}    
	</div>
{/foreach}
</pre>
<br/>
where in the input below you put something like <strong>{Products category=&quot;cat&quot; summarytemplate=&quot;Your_FB_template&quot;}</strong>';
$lang['title_add_tag'] = 'Add your tag';
$lang['date_january'] = 'Ocak';
$lang['date_february'] = 'Şubat';
$lang['date_march'] = 'Mart';
$lang['date_april'] = 'Nisan';
$lang['date_may'] = 'Mayıs';
$lang['date_june'] = 'Haziran';
$lang['date_july'] = 'Temmuz';
$lang['date_august'] = 'Ağustos';
$lang['date_september'] = 'Eyl&uuml;l';
$lang['date_october'] = 'Ekim';
$lang['date_november'] = 'Kasım';
$lang['date_december'] = 'Aralık';
$lang['AF'] = 'Afghanistan';
$lang['AX'] = 'Aland Islands';
$lang['AL'] = 'Albania';
$lang['DZ'] = 'Algeria';
$lang['AS'] = 'American Samoa';
$lang['AD'] = 'Andorra';
$lang['AO'] = 'Angola';
$lang['AI'] = 'Anguilla';
$lang['AQ'] = 'Antarctica';
$lang['AG'] = 'Antigua and Barbuda';
$lang['AR'] = 'Argentina';
$lang['AM'] = 'Armenia';
$lang['AW'] = 'Aruba';
$lang['AU'] = 'Australia';
$lang['AT'] = 'Austria';
$lang['AZ'] = 'Azerbaijan';
$lang['BS'] = 'Bahamas';
$lang['BH'] = 'Bahrain';
$lang['BB'] = 'Barbados';
$lang['BD'] = 'Bangladesh';
$lang['BY'] = 'Belarus';
$lang['BE'] = 'Belgium';
$lang['BZ'] = 'Belize';
$lang['BJ'] = 'Benin';
$lang['BM'] = 'Bermuda';
$lang['BT'] = 'Bhutan';
$lang['BW'] = 'Botswana';
$lang['BO'] = 'Bolivia';
$lang['BA'] = 'Bosnia and Herzegovina';
$lang['BV'] = 'Bouvet Island';
$lang['BR'] = 'Brazil';
$lang['IO'] = 'British Indian Ocean Territory';
$lang['BN'] = 'Brunei Darussalam';
$lang['BG'] = 'Bulgaria';
$lang['BF'] = 'Burkina Faso';
$lang['BI'] = 'Burundi';
$lang['KH'] = 'Cambodia';
$lang['CM'] = 'Cameroon';
$lang['CA'] = 'Canada';
$lang['CV'] = 'Cape Verde';
$lang['KY'] = 'Cayman Islands';
$lang['CF'] = 'Central African Republic';
$lang['TD'] = 'Chad';
$lang['CL'] = 'Chile';
$lang['CN'] = 'China';
$lang['CX'] = 'Christmas Island';
$lang['CC'] = 'Cocos (Keeling) Islands';
$lang['CO'] = 'Colombia';
$lang['KM'] = 'Comoros';
$lang['CG'] = 'Congo';
$lang['CD'] = 'Congo,  Democratic Republic';
$lang['CK'] = 'Cook Islands';
$lang['CR'] = 'Costa Rica';
$lang['CI'] = 'Ivoire (Ivory Coast)';
$lang['HR'] = 'Croatia (Hrvatska)';
$lang['CU'] = 'Cuba';
$lang['CY'] = 'Cyprus';
$lang['CZ'] = 'Czech Republic';
$lang['DK'] = 'Denmark';
$lang['DJ'] = 'Djibouti';
$lang['DM'] = 'Dominica';
$lang['DO'] = 'Dominican Republic';
$lang['TP'] = 'East Timor';
$lang['EC'] = 'Ecuador';
$lang['EG'] = 'Egypt';
$lang['SV'] = 'El Salvador';
$lang['GQ'] = 'Equatorial Guinea';
$lang['ER'] = 'Eritrea';
$lang['EE'] = 'Estonia';
$lang['ET'] = 'Ethiopia';
$lang['FK'] = 'Falkland Islands (Malvinas)';
$lang['FO'] = 'Faroe Islands';
$lang['FJ'] = 'Fiji';
$lang['FI'] = 'Finland';
$lang['FR'] = 'France';
$lang['FX'] = 'France,  Metropolitan';
$lang['GF'] = 'Guernsey';
$lang['PF'] = 'French Polynesia';
$lang['TF'] = 'French Southern Territories';
$lang['MK'] = 'F.Y.R.O.M. (Macedonia)';
$lang['GA'] = 'Gabon';
$lang['GM'] = 'Gambia';
$lang['GE'] = 'Georgia';
$lang['DE'] = 'Germany';
$lang['GH'] = 'Ghana';
$lang['GI'] = 'Gibraltar';
$lang['GB'] = 'Great Britain (UK)';
$lang['GR'] = 'Greece';
$lang['GL'] = 'Greenland';
$lang['GD'] = 'Grenada';
$lang['GP'] = 'Guadeloupe';
$lang['GU'] = 'Guam';
$lang['GT'] = 'Guatemala';
$lang['GN'] = 'Guinea';
$lang['GW'] = 'Guinea-Bissau';
$lang['GY'] = 'Guyana';
$lang['HT'] = 'Haiti';
$lang['HM'] = 'Heard and McDonald Islands';
$lang['HN'] = 'Honduras';
$lang['HK'] = 'Hong Kong';
$lang['HU'] = 'Hungary';
$lang['IS'] = 'Iceland';
$lang['IN'] = 'India';
$lang['ID'] = 'Indonesia';
$lang['IR'] = 'Iran';
$lang['IQ'] = 'Iraq';
$lang['IE'] = 'Ireland';
$lang['IL'] = 'Israel';
$lang['IM'] = 'Isle of Man';
$lang['IT'] = 'Italy';
$lang['JE'] = 'Jersey';
$lang['JM'] = 'Jamaica';
$lang['JP'] = 'Japan';
$lang['JO'] = 'Jordan';
$lang['KZ'] = 'Kazakhstan';
$lang['KE'] = 'Kenya';
$lang['KI'] = 'Kiribati';
$lang['KP'] = 'Korea (North)';
$lang['KR'] = 'Korea (South)';
$lang['KW'] = 'Kuwait';
$lang['KG'] = 'Kyrgyzstan';
$lang['LA'] = 'Laos';
$lang['LV'] = 'Latvia';
$lang['LB'] = 'Lebanon';
$lang['LI'] = 'Liechtenstein';
$lang['LR'] = 'Liberia';
$lang['LY'] = 'Libya';
$lang['LS'] = 'Lesotho';
$lang['LT'] = 'Lithuania';
$lang['LU'] = 'Luxembourg';
$lang['MO'] = 'Macau';
$lang['MG'] = 'Madagascar';
$lang['MW'] = 'Malawi';
$lang['MY'] = 'Malaysia';
$lang['MV'] = 'Maldives';
$lang['ML'] = 'Mali';
$lang['MT'] = 'Malta';
$lang['MH'] = 'Marshall Islands';
$lang['MQ'] = 'Martinique';
$lang['MR'] = 'Mauritania';
$lang['MU'] = 'Mauritius';
$lang['YT'] = 'Mayotte';
$lang['MX'] = 'Mexico';
$lang['FM'] = 'Micronesia';
$lang['MC'] = 'Monaco';
$lang['MD'] = 'Moldova';
$lang['MA'] = 'Morocco';
$lang['MN'] = 'Mongolia';
$lang['MS'] = 'Montserrat';
$lang['MZ'] = 'Mozambique';
$lang['MM'] = 'Myanmar';
$lang['NA'] = 'Namibia';
$lang['NR'] = 'Nauru';
$lang['NP'] = 'Nepal';
$lang['NL'] = 'Netherlands';
$lang['AN'] = 'Netherlands Antilles';
$lang['NT'] = 'Neutral Zone';
$lang['NC'] = 'New Caledonia';
$lang['NZ'] = 'New Zealand (Aotearoa)';
$lang['NI'] = 'Nicaragua';
$lang['NE'] = 'Niger';
$lang['NG'] = 'Nigeria';
$lang['NU'] = 'Niue';
$lang['NF'] = 'Norfolk Island';
$lang['MP'] = 'Northern Mariana Islands';
$lang['NO'] = 'Norway';
$lang['OM'] = 'Oman';
$lang['PK'] = 'Pakistan';
$lang['PW'] = 'Palau';
$lang['PS'] = 'Palestinian Territory';
$lang['PA'] = 'Panama';
$lang['PG'] = 'Papua New Guinea';
$lang['PY'] = 'Paraguay';
$lang['PE'] = 'Peru';
$lang['PH'] = 'Philippines';
$lang['PN'] = 'Pitcairn';
$lang['PL'] = 'Poland';
$lang['PT'] = 'Portugal';
$lang['PR'] = 'Puerto Rico';
$lang['QA'] = 'Qatar';
$lang['RE'] = 'Reunion';
$lang['RO'] = 'Romania';
$lang['RU'] = 'Russian Federation';
$lang['RW'] = 'Rwanda';
$lang['GS'] = 'S. Georgia and S. Sandwich Isls.';
$lang['KN'] = 'Saint Kitts and Nevis';
$lang['LC'] = 'Saint Lucia';
$lang['VC'] = 'Saint Vincent &amp; the Grenadines';
$lang['WS'] = 'Samoa';
$lang['SM'] = 'San Marino';
$lang['ST'] = 'Sao Tome and Principe';
$lang['SA'] = 'Saudi Arabia';
$lang['SN'] = 'Senegal';
$lang['SC'] = 'Seychelles';
$lang['SL'] = 'Sierra Leone';
$lang['SG'] = 'Singapore';
$lang['SI'] = 'Slovenia';
$lang['SK'] = 'Slovak Republic';
$lang['SB'] = 'Solomon Islands';
$lang['SO'] = 'Somalia';
$lang['ZA'] = 'South Africa';
$lang['ES'] = 'Spain';
$lang['LK'] = 'Sri Lanka';
$lang['SH'] = 'St. Helena';
$lang['PM'] = 'St. Pierre and Miquelon ';
$lang['SD'] = 'Sudan';
$lang['SR'] = 'Suriname';
$lang['SJ'] = 'Svalbard &amp; Jan Mayen Islands';
$lang['SZ'] = 'Swaziland';
$lang['SE'] = 'Sweden';
$lang['CH'] = 'Switzerland';
$lang['SY'] = 'Syria';
$lang['TW'] = 'Taiwan';
$lang['TJ'] = 'Tajikistan';
$lang['TZ'] = 'Tanzania';
$lang['TH'] = 'Thailand';
$lang['TG'] = 'Togo';
$lang['TK'] = 'Tokelau';
$lang['TO'] = 'Tonga';
$lang['TT'] = 'Trinidad and Tobago';
$lang['TN'] = 'Tunisia';
$lang['TR'] = 'T&uuml;rkiye';
$lang['TM'] = 'Turkmenistan';
$lang['TC'] = 'Turks and Caicos Islands';
$lang['TV'] = 'Tuvalu';
$lang['UG'] = 'Uganda';
$lang['UA'] = 'Ukraine';
$lang['AE'] = 'United Arab Emirates';
$lang['UK'] = 'United Kingdom';
$lang['US'] = 'United States';
$lang['UM'] = 'US Minor Outlying Islands';
$lang['UY'] = 'Uruguay';
$lang['UZ'] = 'Uzbekistan';
$lang['VU'] = 'Vanuatu';
$lang['VA'] = 'Vatican City State (Holy See)';
$lang['VE'] = 'Venezuela';
$lang['VN'] = 'Viet Nam';
$lang['VG'] = 'Virgin Islands (British)';
$lang['VI'] = 'Virgin Islands (U.S.)';
$lang['WF'] = 'Wallis and Futuna Islands';
$lang['EH'] = 'Western Sahara';
$lang['YE'] = 'Yemen';
$lang['YU'] = 'Yugoslavia';
$lang['ZM'] = 'Zambia';
$lang['ZW'] = 'Zimbabwe';
$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 Adı';
$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->helptext</td><td>the field&#039;s help text</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->alias</td><td>the alias specified for this field</td></tr>
<tr><td>field->id</td><td>the internal / opaque id FormBuilder uses for this field</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 the case of a multipage form, you will also have access to the value of previous fields. They
are in the $previous array, or accessible by their names (e.g., {$myfield->value} ).
You can use this in Static Text fields as well, which is a nice way to personalize forms!</p>

<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>in_formbrowser</td><td>1 if form is being viewed from FormBrowser</td></tr>
<tr><td>in_admin</td><td>1 if form is being viewed via FormBrowser admin</td></tr>
<tr><td>fbr_id</td><td>Response ID if form is being viewed from FormBrowser</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'] = 'FormBuilder installed. Please consult the module&#039;s Help page for documentation.';
$lang['help'] = '<h3>What Does This Do?</h3>
<p>The Form Builder Module allows you to create 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 {FormBuilder 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>Button. This doens&#039;t do anything, but you can hook it into some Javascript.</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>Password. This is an asterisked-out text field, useful for passwords.</li>
<li>Password Again (verify). This is a field that must match a Password field for submission
to succeed.</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 &quot;From Address&quot; 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 &quot;From Name&quot; 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>
<li>-User Tag. This calls the specified User Defined Tag, and displays anything it returns. The UDT gets called any time the field would be visible.</li>
</ul></li>
<li>-Module Include Tag. This allows you to embed other module output into your form, e.g., a list of products from the Products module.</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 $params[&#039;field_name&#039;], and as $params[&#039;field_alias&#039;] (if defined).</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 &quot;From Address&quot; Field, and send copy. This works like the Email &quot;From Address&quot; Field described above, but it provides options for sending a copy of the results to the user.</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. <strong>Deprecated.</strong> Use Store Results for FormBrowser Module instead! 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.0.3. Stores the form results in an XML structure as a single database record. This is the only interface to Form Browser. See section below.</li>
<li>*Submit to an arbitrary form action. Craft an HTTP GET or POST, and transmit it using cURL to the specified URL. This lets you use FormBuilder as a front-end to any CGI or Form Handling script out there.</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>{FormBuilder 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 unwieldy or contain characters that don&#039;t work well with Smarty. So there is an
alternative like this:</p>
<p>{FormBuilder 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 its 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. As of version 0.5, variables also have aliases, which you can use.</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>Use with FormBrowser v3</h3>
<p>There are some special features when using FormBuilder with FormBrowser. The new approach stores the form results in XML, so that far fewer
queries are needed to retrieve records. This means you can use FormBrowser with hundreds or even thousands of records. It also means you
will have to choose up front which fields you will want to be able to sort by. You can choose up to five. Changing these after there are submitted records will result in improper sorting! A re-index function will be added to a future version.</p>
<p>In advanced options, you can tie a form to Frontend Users. That means each user gets one record for the form; they can create it
a single time, subsequent times they will be editing their record. The record will not be visible to any other users (excluding admins).
This form should be added to your page using the syntax {FormBuilder action=&#039;feuserform&#039; form=&#039;form_name&#039;}.</p>
<p>For greater data safety, you can encrypt the stored forms in the database. You can use the built-in mycrypt library or the OpenSSL module.
In either case, for the passphrase, you can either enter text in the field or a file name. If you specify a file name, the contents of that
file will be used as the passphrase for encrypting.</p>
<p>If you encrypt, be aware that the fields you use for sorting are <strong>not</strong> encrypted. You can choose to hash them; the cheat here
is that the first four letters are left intact to allow for sorting. The sorting may not be perfect, and this weakens the security since it
exposes some cleartext, but it is better than nothing.</p>
<p><strong>DISCLAIMER</strong>. The encryption offered here should be considered just one more hurdle for a hacker, not as a guarantee that
your information will be secure. A smart hacker who has found some exploit to view database records may well be smart enough to get at
the module source code, and find their way to the passphrase. This will not protect you against an enemy who has full access to your
server, some familiarity with PHP, and the time to poke around. <em><strong>Do not</strong> use this to protect high-value information such as financial data,
sensitive political information, human rights data, or anything else that might be of value to a repressive government or organized crime
cartel.</em></p>
<h3>Using with User Defined Tags (UDTs)</h3>
<p>Several options for customizing behavior via UDTs is provided (thanks to kind code contributions, see credits).</p>

<ul><li>Call User Defined Tag With the Form Results. This field type submits the human-readable form results to the User-Defined
Tag you specify. The UDT can handle the results however it wants. Values are passed as $params[&#039;field_name&#039;], and
as $params[&#039;field_alias&#039;] (if defined). As per a suggestion, it also populates all of the Smarty values that would be visible to the Submission Template too!</li>
<li>User Tag Field. This calls the specified UDT, and displays anything it returns. The UDT gets called any time the field would be visible.</li>
<li>Validation UDT. Set this for a form, and the UDT will receive all of the form\&#039;s human-readable results. The UDT should do whatever
validation it wants, and return an array with the first value being true or false (indication whether the form validates), and the second
value being error messages (if any).</li>
<li>User defined tag to call before form is displayed the first time (only called once). This
is set in the Form Admin in the UDT Integration tab. The UDT gets called on the first display
of the form.</li>
<li>User defined tag to call before form is displayed (called on every page of multipage
forms). This is set in the Form Admin in the UDT Integration tab. The UDT gets called
every time any page of the form is displayed (including when validation fails).</li>
</ul>
<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>Run in MLE Mode. This changes some queries against the content table to try to prevent ugly crashes under the MLE fork. Checking this will cause ugly crashes if you are NOT running the MLE fork.</li>
<li>Hide Errors. This is no longer set by default. Checking it will hide the more detailed errors that would 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>After a bit of nagging on the part of people who actually respect standards, FormBuilder no longer encourages tricks like embedding CSS in 
static text fields. Instead, it creates a stylesheet called &quot;FormBuilder Default&quot; that you are encouraged to attach to the page template
that you use for pages that contain your form.</p>  
<p>This default CSS was graciously provided by Paul Noone.</p>


<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->helptext</td><td>the field&#039;s help text</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->alias</td><td>the alias specified for this field</td></tr>
<tr><td>field->id</td><td>the internal / opaque id FormBuilder uses for this field</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 the case of a multipage form, you will also have access to the value of previous fields. They
are in the $previous array, or accessible by their names (e.g., {$myfield->value} ).
You can use this in Static Text fields as well, which is a nice way to personalize forms!</p>

<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>in_formbrowser</td><td>1 if form is being viewed from FormBrowser</td></tr>
<tr><td>in_admin</td><td>1 if form is being viewed via FormBrowser admin</td></tr>
<tr><td>fbr_id</td><td>Response ID if form is being viewed from FormBrowser</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>Credits</h3>
<p>Many people have contributed code, bug reports, cash, and ideas to FormBuilder. Among them (alphabetically):
<ul>
<li><a href="http://www.bpti.eu">Baltic institute of advanced technology</a> - code, funding </li>
<li>Jeremy Bass - code and suggestions</li>
<li>Alberto Benati - code</li>
<li>Tyler Boespflug - funding and ideas</li>
<li>Jeff Bosch - UDT Validation</li>
<li>Robert Campbell - numerous code contributions</li>
<li>Piotras Cimmperman - code</li>
<li>Nuno Costa - suggestions</li>
<li>Ryan Foster - code</li>
<li>Marc Geldon - code</li>
<li>Kevin Grandon - code</li>
<li>Ronny Krijt - code</li>
<li>Paul Noone - CSS and ideas</li>
<li>Morten Poulsen - code</li>
<li>Prue Rowland - bug fixes</li>
<li>Simon Schaufelberger - code</li>
</ul>
<p>I apologize for any omissions - notify me, and I&#039;ll correct the omission!</p>
<h3>Miscellaneous Notes</h3>
<ul>
<li>Any fields that sends email to a specified email address will also accept a comma-separated list of email addresses.</li>
</ul>
<h3>Known Issues</h3>
<ul>
<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>FormBuilder/FormBrowser <strong>requires</strong> PHP 5 or later to function correctly.</li>
<li>First step is to check you&#039;re running CMS 1.6 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> Make sure you can successfully send email via the test in the CMSMailer Module. It&#039;s simply amazing how many problems boil down to a misconfigured CMSMailer.</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>
<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 <em>hundreds and hundreds of hours</em> 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><form action=&quot;https://www.paypal.com/cgi-bin/webscr&quot; method=&quot;post&quot;>
<input type=&quot;hidden&quot; name=&quot;cmd&quot; value=&quot;_s-xclick&quot;>
<input type=&quot;image&quot; src=&quot;https://www.paypal.com/en_US/i/btn/btn_donateCC_LG.gif&quot; border=&quot;0&quot; name=&quot;submit&quot; alt=&quot;PayPal - The safer, easier way to pay online!&quot;>
<img alt=&quot;&quot; border=&quot;0&quot; src=&quot;https://www.paypal.com/en_US/i/scr/pixel.gif&quot; width=&quot;1&quot; height=&quot;1&quot;>
<input type=&quot;hidden&quot; name=&quot;encrypted&quot; value=&quot;-----BEGIN PKCS7-----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-----END PKCS7-----
&quot;>
</form><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; 2009, 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['utma'] = '156861353.1249837180.1276218286.1297348508.1297351199.9';
$lang['utmz'] = '156861353.1297348590.8.3.utmcsr=feedburner|utmccn=Feed: cmsmadesimple/blog (CMS Made Simple)|utmcmd=feed';
$lang['qca'] = 'P0-1332436756-1295403130439';
$lang['utmc'] = '156861353';
$lang['utmb'] = '156861353';
?>]]></data>
	</file>
	<file>
	  <filename>/lang/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/lib/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lib/class.email_validator.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
/**
* Class to wrap "is_email" function by  Dominic Sayers
* and a few other email related methods that shouldn't be in the main module class
* Added by Jo Morg
*/
/**
 * To validate an email address according to RFCs 5321, 5322 and others
 * 
 * Copyright © 2008-2011, Dominic Sayers          <br>
 * Test schema documentation Copyright © 2011, Daniel Marschall      <br>
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 * 
 *     - Redistributions of source code must retain the above copyright notice,
 *       this list of conditions and the following disclaimer.
 *     - Redistributions in binary form must reproduce the above copyright notice,
 *       this list of conditions and the following disclaimer in the documentation
 *       and/or other materials provided with the distribution.
 *     - Neither the name of Dominic Sayers nor the names of its contributors may be
 *       used to endorse or promote products derived from this software without
 *       specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 * @package  is_email
 * @author  Dominic Sayers <dominic@sayers.cc>
 * @copyright  2008-2011 Dominic Sayers
 * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
 * @link  http://www.dominicsayers.com/isemail
 * @version  3.01.1 - Fixed examples and readme.txt
 */

// The quality of this code has been improved greatly by using PHPLint
// Copyright (c) 2010 Umberto Salsi
// This is free software; see the license for copying conditions.
// More info: http://www.icosaedro.it/phplint/
/*.
  require_module 'standard';
  require_module 'pcre';
.*/

if (!defined('ISEMAIL_VALID')) 
{
  /*:diagnostic constants start:*/
  
  // This part of the code is generated using data from test/meta.xml. Beware of making manual alterations
  // Categories
  define('ISEMAIL_VALID_CATEGORY', 1);
  define('ISEMAIL_DNSWARN', 7);
  define('ISEMAIL_RFC5321', 15);
  define('ISEMAIL_CFWS', 31);
  define('ISEMAIL_DEPREC', 63);
  define('ISEMAIL_RFC5322', 127);
  define('ISEMAIL_ERR', 255);

  // Diagnoses
  // Address is valid
  define('ISEMAIL_VALID', 0);
  // Address is valid but a DNS check was not successful
  define('ISEMAIL_DNSWARN_NO_MX_RECORD', 5);
  define('ISEMAIL_DNSWARN_NO_RECORD', 6);
  // Address is valid for SMTP but has unusual elements
  define('ISEMAIL_RFC5321_TLD', 9);
  define('ISEMAIL_RFC5321_TLDNUMERIC', 10);
  define('ISEMAIL_RFC5321_QUOTEDSTRING', 11);
  define('ISEMAIL_RFC5321_ADDRESSLITERAL', 12);
  define('ISEMAIL_RFC5321_IPV6DEPRECATED', 13);
  // Address is valid within the message but cannot be used unmodified for the envelope
  define('ISEMAIL_CFWS_COMMENT', 17);
  define('ISEMAIL_CFWS_FWS', 18);
  // Address contains deprecated elements but may still be valid in restricted contexts
  define('ISEMAIL_DEPREC_LOCALPART', 33);
  define('ISEMAIL_DEPREC_FWS', 34);
  define('ISEMAIL_DEPREC_QTEXT', 35);
  define('ISEMAIL_DEPREC_QP', 36);
  define('ISEMAIL_DEPREC_COMMENT', 37);
  define('ISEMAIL_DEPREC_CTEXT', 38);
  define('ISEMAIL_DEPREC_CFWS_NEAR_AT', 49);
  // The address is only valid according to the broad definition of RFC 5322. It is otherwise invalid.
  define('ISEMAIL_RFC5322_DOMAIN', 65);
  define('ISEMAIL_RFC5322_TOOLONG', 66);
  define('ISEMAIL_RFC5322_LOCAL_TOOLONG', 67);
  define('ISEMAIL_RFC5322_DOMAIN_TOOLONG', 68);
  define('ISEMAIL_RFC5322_LABEL_TOOLONG', 69);
  define('ISEMAIL_RFC5322_DOMAINLITERAL', 70);
  define('ISEMAIL_RFC5322_DOMLIT_OBSDTEXT', 71);
  define('ISEMAIL_RFC5322_IPV6_GRPCOUNT', 72);
  define('ISEMAIL_RFC5322_IPV6_2X2XCOLON', 73);
  define('ISEMAIL_RFC5322_IPV6_BADCHAR', 74);
  define('ISEMAIL_RFC5322_IPV6_MAXGRPS', 75);
  define('ISEMAIL_RFC5322_IPV6_COLONSTRT', 76);
  define('ISEMAIL_RFC5322_IPV6_COLONEND', 77);
  // Address is invalid for any purpose
  define('ISEMAIL_ERR_EXPECTING_DTEXT', 129);
  define('ISEMAIL_ERR_NOLOCALPART', 130);
  define('ISEMAIL_ERR_NODOMAIN', 131);
  define('ISEMAIL_ERR_CONSECUTIVEDOTS', 132);
  define('ISEMAIL_ERR_ATEXT_AFTER_CFWS', 133);
  define('ISEMAIL_ERR_ATEXT_AFTER_QS', 134);
  define('ISEMAIL_ERR_ATEXT_AFTER_DOMLIT', 135);
  define('ISEMAIL_ERR_EXPECTING_QPAIR', 136);
  define('ISEMAIL_ERR_EXPECTING_ATEXT', 137);
  define('ISEMAIL_ERR_EXPECTING_QTEXT', 138);
  define('ISEMAIL_ERR_EXPECTING_CTEXT', 139);
  define('ISEMAIL_ERR_BACKSLASHEND', 140);
  define('ISEMAIL_ERR_DOT_START', 141);
  define('ISEMAIL_ERR_DOT_END', 142);
  define('ISEMAIL_ERR_DOMAINHYPHENSTART', 143);
  define('ISEMAIL_ERR_DOMAINHYPHENEND', 144);
  define('ISEMAIL_ERR_UNCLOSEDQUOTEDSTR', 145);
  define('ISEMAIL_ERR_UNCLOSEDCOMMENT', 146);
  define('ISEMAIL_ERR_UNCLOSEDDOMLIT', 147);
  define('ISEMAIL_ERR_FWS_CRLF_X2', 148);
  define('ISEMAIL_ERR_FWS_CRLF_END', 149);
  define('ISEMAIL_ERR_CR_NO_LF', 150);
// End of generated code
/*:diagnostic constants end:*/

  // function control
  define('ISEMAIL_THRESHOLD'    , 16);

  // Email parts
  define('ISEMAIL_COMPONENT_LOCALPART'  , 0);
  define('ISEMAIL_COMPONENT_DOMAIN'  , 1);
  define('ISEMAIL_COMPONENT_LITERAL'  , 2);
  define('ISEMAIL_CONTEXT_COMMENT'  , 3);
  define('ISEMAIL_CONTEXT_FWS'    , 4);
  define('ISEMAIL_CONTEXT_QUOTEDSTRING'  , 5);
  define('ISEMAIL_CONTEXT_QUOTEDPAIR'  , 6);

  // Miscellaneous string constants
  define('ISEMAIL_STRING_AT'    , '@');
  define('ISEMAIL_STRING_BACKSLASH'  , '\\');
  define('ISEMAIL_STRING_DOT'    , '.');
  define('ISEMAIL_STRING_DQUOTE'    , '"');
  define('ISEMAIL_STRING_OPENPARENTHESIS'  , '(');
  define('ISEMAIL_STRING_CLOSEPARENTHESIS', ')');
  define('ISEMAIL_STRING_OPENSQBRACKET'  , '[');
  define('ISEMAIL_STRING_CLOSESQBRACKET'  , ']');
  define('ISEMAIL_STRING_HYPHEN'    , '-');
  define('ISEMAIL_STRING_COLON'    , ':');
  define('ISEMAIL_STRING_DOUBLECOLON'  , '::');
  define('ISEMAIL_STRING_SP'    , ' ');
  define('ISEMAIL_STRING_HTAB'    , "\t");
  define('ISEMAIL_STRING_CR'    , "\r");
  define('ISEMAIL_STRING_LF'    , "\n");
  define('ISEMAIL_STRING_IPV6TAG'    , 'IPv6:');
  // US-ASCII visible characters not valid for atext (http://tools.ietf.org/html/rfc5322#section-3.2.3)
  define('ISEMAIL_STRING_SPECIALS'  , '()<>[]:;@\\,."');
}

class email_validator
{
    /**
   * Check that an email address conforms to RFCs 5321, 5322 and others
   *
   * As of Version 3.0, we are now distinguishing clearly between a Mailbox
   * as defined by RFC 5321 and an addr-spec as defined by RFC 5322. Depending
   * on the context, either can be regarded as a valid email address. The
   * RFC 5321 Mailbox specification is more restrictive (comments, white space
   * and obsolete forms are not allowed)
   *
   * @param string  $email    The email address to check
   * @param boolean  $checkDNS  If true then a DNS check for MX records will be made
   * @param mixed    $errorlevel  Determines the boundary between valid and invalid addresses.
   *           Status codes above this number will be returned as-is,
   *           status codes below will be returned as ISEMAIL_VALID. Thus the
   *           calling program can simply look for ISEMAIL_VALID if it is
   *           only interested in whether an address is valid or not. The
   *           errorlevel will determine how "picky" is_email() is about
   *           the address.
   *
   *           If omitted or passed as false then is_email() will return
   *           true or false rather than an integer error or warning.
   *
   *           NB Note the difference between $errorlevel = false and
   *           $errorlevel = 0
   * @param array    $parsedata  If passed, returns the parsed address components
   */
  /*.mixed.*/ 
  public static function is_email($email, $checkDNS = false, $errorlevel = false, &$parsedata = array()) 
  {
    // Check that $email is a valid address. Read the following RFCs to understand the constraints:
    //   (http://tools.ietf.org/html/rfc5321)
    //   (http://tools.ietf.org/html/rfc5322)
    //   (http://tools.ietf.org/html/rfc4291#section-2.2)
    //   (http://tools.ietf.org/html/rfc1123#section-2.1)
    //   (http://tools.ietf.org/html/rfc3696) (guidance only)
    
    // version 2.0: Enhance $diagnose parameter to $errorlevel
    // version 3.0: Introduced status categories
    // revision 3.1: BUG: $parsedata was passed by value instead of by reference

    if (is_bool($errorlevel)) {
      $threshold  = ISEMAIL_VALID;
      $diagnose  = (bool) $errorlevel;
    } else {
      $diagnose  = true;

      switch ((int) $errorlevel) {
      case E_WARNING:  $threshold  = ISEMAIL_THRESHOLD;  break;  // For backward compatibility
      case E_ERROR:  $threshold  = ISEMAIL_VALID;  break;  // For backward compatibility
      default:  $threshold  = (int) $errorlevel;
      }
    }

    $return_status = array(ISEMAIL_VALID);

    // Parse the address into components, character by character
    $raw_length  = strlen($email);
    $context  = ISEMAIL_COMPONENT_LOCALPART;  // Where we are
    $context_stack  = array($context);    // Where we have been
    $context_prior  = ISEMAIL_COMPONENT_LOCALPART;  // Where we just came from
    $token    = '';        // The current character
    $token_prior  = '';        // The previous character
    $parsedata  = array(
          ISEMAIL_COMPONENT_LOCALPART  => '',
          ISEMAIL_COMPONENT_DOMAIN  => ''
               );      // For the components of the address

    $atomlist  = array(
          ISEMAIL_COMPONENT_LOCALPART  => array(''),
          ISEMAIL_COMPONENT_DOMAIN  => array('')
               );      // For the dot-atom elements of the address
    $element_count  = 0;
    $element_len  = 0;
    $hyphen_flag  = false;      // Hyphen cannot occur at the end of a subdomain
    $end_or_die  = false;      // CFWS can only appear at the end of the element

  //-echo "<table style=\"clear:left;\">"; // debug
    for ($i = 0; $i < $raw_length; $i++) {
      $token = $email[$i];
  //-echo "<tr><td><strong>$context|",(($end_or_die) ? 'true' : 'false'),"|$token|" . max($return_status) . "</strong></td>"; // debug

      switch ($context) {
      //-------------------------------------------------------------
      // local-part
      //-------------------------------------------------------------
      case ISEMAIL_COMPONENT_LOCALPART:
        // http://tools.ietf.org/html/rfc5322#section-3.4.1
        //   local-part      =   dot-atom / quoted-string / obs-local-part
        //
        //   dot-atom        =   [CFWS] dot-atom-text [CFWS]
        //
        //   dot-atom-text   =   1*atext *("." 1*atext)
        //
        //   quoted-string   =   [CFWS]
        //                       DQUOTE *([FWS] qcontent) [FWS] DQUOTE
        //                       [CFWS]
        //
        //   obs-local-part  =   word *("." word)
        //
        //   word            =   atom / quoted-string
        //
        //   atom            =   [CFWS] 1*atext [CFWS]
        switch ($token) {
        // Comment
        case ISEMAIL_STRING_OPENPARENTHESIS:
          if ($element_len === 0)
            // Comments are OK at the beginning of an element
            $return_status[]  = ($element_count === 0) ? ISEMAIL_CFWS_COMMENT : ISEMAIL_DEPREC_COMMENT;
          else {
            $return_status[]  = ISEMAIL_CFWS_COMMENT;
            $end_or_die    = true;  // We can't start a comment in the middle of an element, so this better be the end
          }

          $context_stack[]  = $context;
          $context    = ISEMAIL_CONTEXT_COMMENT;
          break;
        // Next dot-atom element
        case ISEMAIL_STRING_DOT:
          if ($element_len === 0)
            // Another dot, already?
            $return_status[] = ($element_count === 0) ? ISEMAIL_ERR_DOT_START : ISEMAIL_ERR_CONSECUTIVEDOTS;  // Fatal error
          else
            // The entire local-part can be a quoted string for RFC 5321
            // If it's just one atom that is quoted then it's an RFC 5322 obsolete form
            if ($end_or_die) $return_status[] = ISEMAIL_DEPREC_LOCALPART;

            $end_or_die  = false;  // CFWS & quoted strings are OK again now we're at the beginning of an element (although they are obsolete forms)
            $element_len  = 0;
            $element_count++;
            $parsedata[ISEMAIL_COMPONENT_LOCALPART]      .= $token;
            $atomlist[ISEMAIL_COMPONENT_LOCALPART][$element_count]  = '';

          break;
        // Quoted string
        case ISEMAIL_STRING_DQUOTE:
          if ($element_len === 0) {
            // The entire local-part can be a quoted string for RFC 5321
            // If it's just one atom that is quoted then it's an RFC 5322 obsolete form
            $return_status[]  = ($element_count === 0) ? ISEMAIL_RFC5321_QUOTEDSTRING : ISEMAIL_DEPREC_LOCALPART;

            $parsedata[ISEMAIL_COMPONENT_LOCALPART]      .= $token;
            $atomlist[ISEMAIL_COMPONENT_LOCALPART][$element_count]  .= $token;
            $element_len++;
            $end_or_die    = true;  // Quoted string must be the entire element
            $context_stack[]  = $context;
            $context    = ISEMAIL_CONTEXT_QUOTEDSTRING;
          } else {
            $return_status[]  = ISEMAIL_ERR_EXPECTING_ATEXT;  // Fatal error
          }

          break;
        // Folding White Space
        case ISEMAIL_STRING_CR:
        case ISEMAIL_STRING_SP:
        case ISEMAIL_STRING_HTAB:
          if (($token === ISEMAIL_STRING_CR) && ((++$i === $raw_length) || ($email[$i] !== ISEMAIL_STRING_LF))) {$return_status[] = ISEMAIL_ERR_CR_NO_LF;  break;}  // Fatal error

          if ($element_len === 0)
            $return_status[] = ($element_count === 0) ? ISEMAIL_CFWS_FWS : ISEMAIL_DEPREC_FWS;
          else
            $end_or_die = true;  // We can't start FWS in the middle of an element, so this better be the end

          $context_stack[]  = $context;
          $context    = ISEMAIL_CONTEXT_FWS;
          $token_prior    = $token;

          break;
        // @
        case ISEMAIL_STRING_AT:
          // At this point we should have a valid local-part
          if (count($context_stack) !== 1) die('Unexpected item on context stack');

          if  ($parsedata[ISEMAIL_COMPONENT_LOCALPART] === '')
                  $return_status[]  = ISEMAIL_ERR_NOLOCALPART;  // Fatal error
          elseif  ($element_len === 0)  $return_status[]  = ISEMAIL_ERR_DOT_END;  // Fatal error
          // http://tools.ietf.org/html/rfc5321#section-4.5.3.1.1
          //   The maximum total length of a user name or other local-part is 64
          //   octets.
          elseif  (strlen($parsedata[ISEMAIL_COMPONENT_LOCALPART]) > 64)
                  $return_status[]  = ISEMAIL_RFC5322_LOCAL_TOOLONG;
          // http://tools.ietf.org/html/rfc5322#section-3.4.1
          //   Comments and folding white space
          //   SHOULD NOT be used around the "@" in the addr-spec.
          //
          // http://tools.ietf.org/html/rfc2119
          // 4. SHOULD NOT   This phrase, or the phrase "NOT RECOMMENDED" mean that
          //    there may exist valid reasons in particular circumstances when the
          //    particular behavior is acceptable or even useful, but the full
          //    implications should be understood and the case carefully weighed
          //    before implementing any behavior described with this label.
          elseif  (($context_prior === ISEMAIL_CONTEXT_COMMENT) || ($context_prior === ISEMAIL_CONTEXT_FWS))
                  $return_status[]  = ISEMAIL_DEPREC_CFWS_NEAR_AT;

          // Clear everything down for the domain parsing
          $context  = ISEMAIL_COMPONENT_DOMAIN;  // Where we are
          $context_stack  = array($context);    // Where we have been
          $element_count  = 0;
          $element_len  = 0;
          $end_or_die  = false;      // CFWS can only appear at the end of the element

          break;
        // atext
        default:
          // http://tools.ietf.org/html/rfc5322#section-3.2.3
          //    atext           =   ALPHA / DIGIT /    ; Printable US-ASCII
          //                        "!" / "#" /        ;  characters not including
          //                        "$" / "%" /        ;  specials.  Used for atoms.
          //                        "&" / "'" /
          //                        "*" / "+" /
          //                        "-" / "/" /
          //                        "=" / "?" /
          //                        "^" / "_" /
          //                        "`" / "{" /
          //                        "|" / "}" /
          //                        "~"
          if ($end_or_die) {
            // We have encountered atext where it is no longer valid
            switch ($context_prior) {
            case ISEMAIL_CONTEXT_COMMENT:
            case ISEMAIL_CONTEXT_FWS:
              $return_status[]  = ISEMAIL_ERR_ATEXT_AFTER_CFWS;
              break;
            case ISEMAIL_CONTEXT_QUOTEDSTRING:
              $return_status[]  = ISEMAIL_ERR_ATEXT_AFTER_QS;
              break;
            default:
              die ("More atext found where none is allowed, but unrecognised prior context: $context_prior");
            }
          } else {
            $context_prior  = $context;
            $ord    = ord($token);

            if (($ord < 33) || ($ord > 126) || ($ord === 10) || (!is_bool(strpos(ISEMAIL_STRING_SPECIALS, $token))))
              $return_status[]  = ISEMAIL_ERR_EXPECTING_ATEXT;  // Fatal error

            $parsedata[ISEMAIL_COMPONENT_LOCALPART]      .= $token;
            $atomlist[ISEMAIL_COMPONENT_LOCALPART][$element_count]  .= $token;
            $element_len++;
          }
        }

        break;
      //-------------------------------------------------------------
      // Domain
      //-------------------------------------------------------------
      case ISEMAIL_COMPONENT_DOMAIN:
        // http://tools.ietf.org/html/rfc5322#section-3.4.1
        //   domain          =   dot-atom / domain-literal / obs-domain
        //
        //   dot-atom        =   [CFWS] dot-atom-text [CFWS]
        //
        //   dot-atom-text   =   1*atext *("." 1*atext)
        //
        //   domain-literal  =   [CFWS] "[" *([FWS] dtext) [FWS] "]" [CFWS]
        //
        //   dtext           =   %d33-90 /          ; Printable US-ASCII
        //                       %d94-126 /         ;  characters not including
        //                       obs-dtext          ;  "[", "]", or "\"
        //
        //   obs-domain      =   atom *("." atom)
        //
        //   atom            =   [CFWS] 1*atext [CFWS]


        // http://tools.ietf.org/html/rfc5321#section-4.1.2
        //   Mailbox        = Local-part "@" ( Domain / address-literal )
        //
        //   Domain         = sub-domain *("." sub-domain)
        //
        //   address-literal  = "[" ( IPv4-address-literal /
        //                    IPv6-address-literal /
        //                    General-address-literal ) "]"
        //                    ; See Section 4.1.3

        // http://tools.ietf.org/html/rfc5322#section-3.4.1
        //      Note: A liberal syntax for the domain portion of addr-spec is
        //      given here.  However, the domain portion contains addressing
        //      information specified by and used in other protocols (e.g.,
        //      [RFC1034], [RFC1035], [RFC1123], [RFC5321]).  It is therefore
        //      incumbent upon implementations to conform to the syntax of
        //      addresses for the context in which they are used.
        // is_email() author's note: it's not clear how to interpret this in
        // the context of a general email address validator. The conclusion I
        // have reached is this: "addressing information" must comply with
        // RFC 5321 (and in turn RFC 1035), anything that is "semantically
        // invisible" must comply only with RFC 5322.
        switch ($token) {
        // Comment
        case ISEMAIL_STRING_OPENPARENTHESIS:
          if ($element_len === 0)
            // Comments at the start of the domain are deprecated in the text
            // Comments at the start of a subdomain are obs-domain
            // (http://tools.ietf.org/html/rfc5322#section-3.4.1)
            $return_status[]  = ($element_count === 0) ? ISEMAIL_DEPREC_CFWS_NEAR_AT : ISEMAIL_DEPREC_COMMENT;
          else {
            $return_status[]  = ISEMAIL_CFWS_COMMENT;
            $end_or_die    = true;  // We can't start a comment in the middle of an element, so this better be the end
          }

          $context_stack[]  = $context;
          $context    = ISEMAIL_CONTEXT_COMMENT;
          break;
        // Next dot-atom element
        case ISEMAIL_STRING_DOT:
          if ($element_len === 0)
            // Another dot, already?
            $return_status[]  = ($element_count === 0) ? ISEMAIL_ERR_DOT_START : ISEMAIL_ERR_CONSECUTIVEDOTS;  // Fatal error
          elseif ($hyphen_flag)
            // Previous subdomain ended in a hyphen
            $return_status[]  = ISEMAIL_ERR_DOMAINHYPHENEND;  // Fatal error
          else
            // Nowhere in RFC 5321 does it say explicitly that the
            // domain part of a Mailbox must be a valid domain according
            // to the DNS standards set out in RFC 1035, but this *is*
            // implied in several places. For instance, wherever the idea
            // of host routing is discussed the RFC says that the domain
            // must be looked up in the DNS. This would be nonsense unless
            // the domain was designed to be a valid DNS domain. Hence we
            // must conclude that the RFC 1035 restriction on label length
            // also applies to RFC 5321 domains.
            //
            // http://tools.ietf.org/html/rfc1035#section-2.3.4
            // labels          63 octets or less
            if ($element_len > 63) $return_status[]  = ISEMAIL_RFC5322_LABEL_TOOLONG;

            $end_or_die    = false;  // CFWS is OK again now we're at the beginning of an element (although it may be obsolete CFWS)
            $element_len    = 0;
            $element_count++;
            $atomlist[ISEMAIL_COMPONENT_DOMAIN][$element_count]  = '';
            $parsedata[ISEMAIL_COMPONENT_DOMAIN]      .= $token;

          break;
        // Domain literal
        case ISEMAIL_STRING_OPENSQBRACKET:
          if ($parsedata[ISEMAIL_COMPONENT_DOMAIN] === '') {
            $end_or_die    = true;  // Domain literal must be the only component
            $element_len++;
            $context_stack[]  = $context;
            $context    = ISEMAIL_COMPONENT_LITERAL;
            $parsedata[ISEMAIL_COMPONENT_DOMAIN]      .= $token;
            $atomlist[ISEMAIL_COMPONENT_DOMAIN][$element_count]  .= $token;
            $parsedata[ISEMAIL_COMPONENT_LITERAL]      = '';
          } else {
            $return_status[]  = ISEMAIL_ERR_EXPECTING_ATEXT;  // Fatal error
          }

          break;
        // Folding White Space
        case ISEMAIL_STRING_CR:
        case ISEMAIL_STRING_SP:
        case ISEMAIL_STRING_HTAB:
          if (($token === ISEMAIL_STRING_CR) && ((++$i === $raw_length) || ($email[$i] !== ISEMAIL_STRING_LF))) {$return_status[] = ISEMAIL_ERR_CR_NO_LF;  break;}  // Fatal error

          if ($element_len === 0)
            $return_status[]  = ($element_count === 0) ? ISEMAIL_DEPREC_CFWS_NEAR_AT : ISEMAIL_DEPREC_FWS;
          else {
            $return_status[]  = ISEMAIL_CFWS_FWS;
            $end_or_die  = true;  // We can't start FWS in the middle of an element, so this better be the end
          }

          $context_stack[]  = $context;
          $context    = ISEMAIL_CONTEXT_FWS;
          $token_prior    = $token;
          break;
        // atext
        default:
          // RFC 5322 allows any atext...
          // http://tools.ietf.org/html/rfc5322#section-3.2.3
          //    atext           =   ALPHA / DIGIT /    ; Printable US-ASCII
          //                        "!" / "#" /        ;  characters not including
          //                        "$" / "%" /        ;  specials.  Used for atoms.
          //                        "&" / "'" /
          //                        "*" / "+" /
          //                        "-" / "/" /
          //                        "=" / "?" /
          //                        "^" / "_" /
          //                        "`" / "{" /
          //                        "|" / "}" /
          //                        "~"

          // But RFC 5321 only allows letter-digit-hyphen to comply with DNS rules (RFCs 1034 & 1123)
          // http://tools.ietf.org/html/rfc5321#section-4.1.2
          //   sub-domain     = Let-dig [Ldh-str]
          //
          //   Let-dig        = ALPHA / DIGIT
          //
          //   Ldh-str        = *( ALPHA / DIGIT / "-" ) Let-dig
          //
          if ($end_or_die) {
            // We have encountered atext where it is no longer valid
            switch ($context_prior) {
            case ISEMAIL_CONTEXT_COMMENT:
            case ISEMAIL_CONTEXT_FWS:
              $return_status[]  = ISEMAIL_ERR_ATEXT_AFTER_CFWS;
              break;
            case ISEMAIL_COMPONENT_LITERAL:
              $return_status[]  = ISEMAIL_ERR_ATEXT_AFTER_DOMLIT;
              break;
            default:
              die ("More atext found where none is allowed, but unrecognised prior context: $context_prior");
            }
          }

          $ord    = ord($token);
          $hyphen_flag  = false;  // Assume this token isn't a hyphen unless we discover it is

          if (($ord < 33) || ($ord > 126) || (!is_bool(strpos(ISEMAIL_STRING_SPECIALS, $token)))) {
            $return_status[]  = ISEMAIL_ERR_EXPECTING_ATEXT;  // Fatal error
          } elseif ($token === ISEMAIL_STRING_HYPHEN) {
            if ($element_len === 0) {
              // Hyphens can't be at the beginning of a subdomain
              $return_status[]  = ISEMAIL_ERR_DOMAINHYPHENSTART;  // Fatal error
            }

            $hyphen_flag = true;
          } elseif (!(($ord > 47 && $ord < 58) || ($ord > 64 && $ord < 91) || ($ord > 96 && $ord < 123))) {
            // Not an RFC 5321 subdomain, but still OK by RFC 5322
            $return_status[]  = ISEMAIL_RFC5322_DOMAIN;
          }

          $parsedata[ISEMAIL_COMPONENT_DOMAIN]      .= $token;
          $atomlist[ISEMAIL_COMPONENT_DOMAIN][$element_count]  .= $token;
          $element_len++;
        }

        break;
      //-------------------------------------------------------------
      // Domain literal
      //-------------------------------------------------------------
      case ISEMAIL_COMPONENT_LITERAL:
        // http://tools.ietf.org/html/rfc5322#section-3.4.1
        //   domain-literal  =   [CFWS] "[" *([FWS] dtext) [FWS] "]" [CFWS]
        //
        //   dtext           =   %d33-90 /          ; Printable US-ASCII
        //                       %d94-126 /         ;  characters not including
        //                       obs-dtext          ;  "[", "]", or "\"
        //
        //   obs-dtext       =   obs-NO-WS-CTL / quoted-pair
        switch ($token) {
        // End of domain literal
        case ISEMAIL_STRING_CLOSESQBRACKET:
          if ((int) max($return_status) < ISEMAIL_DEPREC) {
            // Could be a valid RFC 5321 address literal, so let's check

            // http://tools.ietf.org/html/rfc5321#section-4.1.2
            //   address-literal  = "[" ( IPv4-address-literal /
            //                    IPv6-address-literal /
            //                    General-address-literal ) "]"
            //                    ; See Section 4.1.3
            //
            // http://tools.ietf.org/html/rfc5321#section-4.1.3
            //   IPv4-address-literal  = Snum 3("."  Snum)
            //
            //   IPv6-address-literal  = "IPv6:" IPv6-addr
            //
            //   General-address-literal  = Standardized-tag ":" 1*dcontent
            //
            //   Standardized-tag  = Ldh-str
            //                     ; Standardized-tag MUST be specified in a
            //                     ; Standards-Track RFC and registered with IANA
            //
            //   dcontent       = %d33-90 / ; Printable US-ASCII
            //                  %d94-126 ; excl. "[", "\", "]"
            //
            //   Snum           = 1*3DIGIT
            //                  ; representing a decimal integer
            //                  ; value in the range 0 through 255
            //
            //   IPv6-addr      = IPv6-full / IPv6-comp / IPv6v4-full / IPv6v4-comp
            //
            //   IPv6-hex       = 1*4HEXDIG
            //
            //   IPv6-full      = IPv6-hex 7(":" IPv6-hex)
            //
            //   IPv6-comp      = [IPv6-hex *5(":" IPv6-hex)] "::"
            //                  [IPv6-hex *5(":" IPv6-hex)]
            //                  ; The "::" represents at least 2 16-bit groups of
            //                  ; zeros.  No more than 6 groups in addition to the
            //                  ; "::" may be present.
            //
            //   IPv6v4-full    = IPv6-hex 5(":" IPv6-hex) ":" IPv4-address-literal
            //
            //   IPv6v4-comp    = [IPv6-hex *3(":" IPv6-hex)] "::"
            //                  [IPv6-hex *3(":" IPv6-hex) ":"]
            //                  IPv4-address-literal
            //                  ; The "::" represents at least 2 16-bit groups of
            //                  ; zeros.  No more than 4 groups in addition to the
            //                  ; "::" and IPv4-address-literal may be present.
            //
            // is_email() author's note: We can't use ip2long() to validate
            // IPv4 addresses because it accepts abbreviated addresses
            // (xxx.xxx.xxx), expanding the last group to complete the address.
            // filter_var() validates IPv6 address inconsistently (up to PHP 5.3.3
            // at least) -- see http://bugs.php.net/bug.php?id=53236 for example
            $max_groups  = 8;
            $matchesIP  = array();
        /*.mixed.*/  $index    = false;
            $addressliteral  = $parsedata[ISEMAIL_COMPONENT_LITERAL];

            // Extract IPv4 part from the end of the address-literal (if there is one)
            if (preg_match('/\\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/', $addressliteral, $matchesIP) > 0) {
              $index = strrpos($addressliteral, $matchesIP[0]);
              if ($index !== 0) $addressliteral = substr($addressliteral, 0, $index) . '0:0'; // Convert IPv4 part to IPv6 format for further testing
            }

            if ($index === 0) {
              // Nothing there except a valid IPv4 address, so...
              $return_status[]  = ISEMAIL_RFC5321_ADDRESSLITERAL;
            } elseif (strncasecmp($addressliteral, ISEMAIL_STRING_IPV6TAG, 5) !== 0) {
              $return_status[]  = ISEMAIL_RFC5322_DOMAINLITERAL;
            } else {
              $IPv6    = substr($addressliteral, 5);
              $matchesIP  = explode(ISEMAIL_STRING_COLON, $IPv6);  // Revision 2.7: Daniel Marschall's new IPv6 testing strategy
              $groupCount  = count($matchesIP);
              $index    = strpos($IPv6,ISEMAIL_STRING_DOUBLECOLON);

              if ($index === false) {
                // We need exactly the right number of groups
                if ($groupCount !== $max_groups)
                  $return_status[]  = ISEMAIL_RFC5322_IPV6_GRPCOUNT;
              } else {
                if ($index !== strrpos($IPv6,ISEMAIL_STRING_DOUBLECOLON))
                  $return_status[]  = ISEMAIL_RFC5322_IPV6_2X2XCOLON;
                else {
                  if ($index === 0 || $index === (strlen($IPv6) - 2)) $max_groups++;  // RFC 4291 allows :: at the start or end of an address with 7 other groups in addition

                  if ($groupCount > $max_groups)
                    $return_status[]  = ISEMAIL_RFC5322_IPV6_MAXGRPS;
                  elseif ($groupCount === $max_groups)
                    $return_status[]  = ISEMAIL_RFC5321_IPV6DEPRECATED;  // Eliding a single "::"
                }
              }

              // Revision 2.7: Daniel Marschall's new IPv6 testing strategy
              if ((substr($IPv6, 0,  1) === ISEMAIL_STRING_COLON) && (substr($IPv6, 1,  1) !== ISEMAIL_STRING_COLON))
                $return_status[]  = ISEMAIL_RFC5322_IPV6_COLONSTRT;  // Address starts with a single colon
              elseif ((substr($IPv6, -1) === ISEMAIL_STRING_COLON) && (substr($IPv6, -2, 1) !== ISEMAIL_STRING_COLON))
                $return_status[]  = ISEMAIL_RFC5322_IPV6_COLONEND;  // Address ends with a single colon
              elseif (count(preg_grep('/^[0-9A-Fa-f]{0,4}$/', $matchesIP, PREG_GREP_INVERT)) !== 0)
                $return_status[]  = ISEMAIL_RFC5322_IPV6_BADCHAR;  // Check for unmatched characters
              else
                $return_status[]  = ISEMAIL_RFC5321_ADDRESSLITERAL;
            }
          } else
            $return_status[]  = ISEMAIL_RFC5322_DOMAINLITERAL;


          $parsedata[ISEMAIL_COMPONENT_DOMAIN]      .= $token;
          $atomlist[ISEMAIL_COMPONENT_DOMAIN][$element_count]  .= $token;
          $element_len++;
          $context_prior    = $context;
          $context    = (int) array_pop($context_stack);
          break;
        case ISEMAIL_STRING_BACKSLASH:
          $return_status[]  = ISEMAIL_RFC5322_DOMLIT_OBSDTEXT;
          $context_stack[]  = $context;
          $context    = ISEMAIL_CONTEXT_QUOTEDPAIR;
          break;
        // Folding White Space
        case ISEMAIL_STRING_CR:
        case ISEMAIL_STRING_SP:
        case ISEMAIL_STRING_HTAB:
          if (($token === ISEMAIL_STRING_CR) && ((++$i === $raw_length) || ($email[$i] !== ISEMAIL_STRING_LF))) {$return_status[] = ISEMAIL_ERR_CR_NO_LF;  break;}  // Fatal error

          $return_status[]  = ISEMAIL_CFWS_FWS;

          $context_stack[]  = $context;
          $context    = ISEMAIL_CONTEXT_FWS;
          $token_prior    = $token;
          break;
        // dtext
        default:
          // http://tools.ietf.org/html/rfc5322#section-3.4.1
          //   dtext           =   %d33-90 /          ; Printable US-ASCII
          //                       %d94-126 /         ;  characters not including
          //                       obs-dtext          ;  "[", "]", or "\"
          //
          //   obs-dtext       =   obs-NO-WS-CTL / quoted-pair
          //
          //   obs-NO-WS-CTL   =   %d1-8 /            ; US-ASCII control
          //                       %d11 /             ;  characters that do not
          //                       %d12 /             ;  include the carriage
          //                       %d14-31 /          ;  return, line feed, and
          //                       %d127              ;  white space characters
          $ord = ord($token);

          // CR, LF, SP & HTAB have already been parsed above
          if (($ord > 127) || ($ord === 0) || ($token === ISEMAIL_STRING_OPENSQBRACKET)) {
            $return_status[]  = ISEMAIL_ERR_EXPECTING_DTEXT;  // Fatal error
            break;
          } elseif (($ord < 33) || ($ord === 127)) {
            $return_status[]  = ISEMAIL_RFC5322_DOMLIT_OBSDTEXT;
          }

          $parsedata[ISEMAIL_COMPONENT_LITERAL]      .= $token;
          $parsedata[ISEMAIL_COMPONENT_DOMAIN]      .= $token;
          $atomlist[ISEMAIL_COMPONENT_DOMAIN][$element_count]  .= $token;
          $element_len++;
        }

        break;
      //-------------------------------------------------------------
      // Quoted string
      //-------------------------------------------------------------
      case ISEMAIL_CONTEXT_QUOTEDSTRING:
        // http://tools.ietf.org/html/rfc5322#section-3.2.4
        //   quoted-string   =   [CFWS]
        //                       DQUOTE *([FWS] qcontent) [FWS] DQUOTE
        //                       [CFWS]
        //
        //   qcontent        =   qtext / quoted-pair
        switch ($token) {
        // Quoted pair
        case ISEMAIL_STRING_BACKSLASH:
          $context_stack[]  = $context;
          $context    = ISEMAIL_CONTEXT_QUOTEDPAIR;
          break;
        // Folding White Space
        // Inside a quoted string, spaces are allowed as regular characters.
        // It's only FWS if we include HTAB or CRLF
        case ISEMAIL_STRING_CR:
        case ISEMAIL_STRING_HTAB:
          if (($token === ISEMAIL_STRING_CR) && ((++$i === $raw_length) || ($email[$i] !== ISEMAIL_STRING_LF))) {$return_status[] = ISEMAIL_ERR_CR_NO_LF;  break;}  // Fatal error

          // http://tools.ietf.org/html/rfc5322#section-3.2.2
          //   Runs of FWS, comment, or CFWS that occur between lexical tokens in a
          //   structured header field are semantically interpreted as a single
          //   space character.

          // http://tools.ietf.org/html/rfc5322#section-3.2.4
          //   the CRLF in any FWS/CFWS that appears within the quoted-string [is]
          //   semantically "invisible" and therefore not part of the quoted-string
          $parsedata[ISEMAIL_COMPONENT_LOCALPART]      .= ISEMAIL_STRING_SP;
          $atomlist[ISEMAIL_COMPONENT_LOCALPART][$element_count]  .= ISEMAIL_STRING_SP;
          $element_len++;

          $return_status[]    = ISEMAIL_CFWS_FWS;
          $context_stack[]    = $context;
          $context      = ISEMAIL_CONTEXT_FWS;
          $token_prior      = $token;
          break;
        // End of quoted string
        case ISEMAIL_STRING_DQUOTE:
          $parsedata[ISEMAIL_COMPONENT_LOCALPART]      .= $token;
          $atomlist[ISEMAIL_COMPONENT_LOCALPART][$element_count]  .= $token;
          $element_len++;
          $context_prior      = $context;
          $context      = (int) array_pop($context_stack);
          break;
        // qtext
        default:
          // http://tools.ietf.org/html/rfc5322#section-3.2.4
          //   qtext           =   %d33 /             ; Printable US-ASCII
          //                       %d35-91 /          ;  characters not including
          //                       %d93-126 /         ;  "\" or the quote character
          //                       obs-qtext
          //
          //   obs-qtext       =   obs-NO-WS-CTL
          //
          //   obs-NO-WS-CTL   =   %d1-8 /            ; US-ASCII control
          //                       %d11 /             ;  characters that do not
          //                       %d12 /             ;  include the carriage
          //                       %d14-31 /          ;  return, line feed, and
          //                       %d127              ;  white space characters
          $ord = ord($token);

          if (($ord > 127) || ($ord === 0) || ($ord === 10)) {
            $return_status[]  = ISEMAIL_ERR_EXPECTING_QTEXT;  // Fatal error
          } elseif (($ord < 32) || ($ord === 127))
            $return_status[]  = ISEMAIL_DEPREC_QTEXT;

          $parsedata[ISEMAIL_COMPONENT_LOCALPART]      .= $token;
          $atomlist[ISEMAIL_COMPONENT_LOCALPART][$element_count]  .= $token;
          $element_len++;
        }

        // http://tools.ietf.org/html/rfc5322#section-3.4.1
        //   If the
        //   string can be represented as a dot-atom (that is, it contains no
        //   characters other than atext characters or "." surrounded by atext
        //   characters), then the dot-atom form SHOULD be used and the quoted-
        //   string form SHOULD NOT be used.
  // To do
        break;
      //-------------------------------------------------------------
      // Quoted pair
      //-------------------------------------------------------------
      case ISEMAIL_CONTEXT_QUOTEDPAIR:
        // http://tools.ietf.org/html/rfc5322#section-3.2.1
        //   quoted-pair     =   ("\" (VCHAR / WSP)) / obs-qp
        //
        //   VCHAR           =  %d33-126            ; visible (printing) characters
        //   WSP             =  SP / HTAB           ; white space
        //
        //   obs-qp          =   "\" (%d0 / obs-NO-WS-CTL / LF / CR)
        //
        //   obs-NO-WS-CTL   =   %d1-8 /            ; US-ASCII control
        //                       %d11 /             ;  characters that do not
        //                       %d12 /             ;  include the carriage
        //                       %d14-31 /          ;  return, line feed, and
        //                       %d127              ;  white space characters
        //
        // i.e. obs-qp       =  "\" (%d0-8, %d10-31 / %d127)
        $ord = ord($token);

        if  ($ord > 127)
            $return_status[]  = ISEMAIL_ERR_EXPECTING_QPAIR;  // Fatal error
        elseif  ((($ord < 31) && ($ord !== 9)) || ($ord === 127))  // SP & HTAB are allowed
            $return_status[]  = ISEMAIL_DEPREC_QP;

        // At this point we know where this qpair occurred so
        // we could check to see if the character actually
        // needed to be quoted at all.
        // http://tools.ietf.org/html/rfc5321#section-4.1.2
        //   the sending system SHOULD transmit the
        //   form that uses the minimum quoting possible.
  // To do: check whether the character needs to be quoted (escaped) in this context
        $context_prior  = $context;
        $context  = (int) array_pop($context_stack);  // End of qpair
        $token    = ISEMAIL_STRING_BACKSLASH . $token;

        switch ($context) {
        case ISEMAIL_CONTEXT_COMMENT:
          break;
        case ISEMAIL_CONTEXT_QUOTEDSTRING:
          $parsedata[ISEMAIL_COMPONENT_LOCALPART]      .= $token;
          $atomlist[ISEMAIL_COMPONENT_LOCALPART][$element_count]  .= $token;
          $element_len  += 2;  // The maximum sizes specified by RFC 5321 are octet counts, so we must include the backslash
          break;
        case ISEMAIL_COMPONENT_LITERAL:
          $parsedata[ISEMAIL_COMPONENT_DOMAIN]      .= $token;
          $atomlist[ISEMAIL_COMPONENT_DOMAIN][$element_count]  .= $token;
          $element_len  += 2;  // The maximum sizes specified by RFC 5321 are octet counts, so we must include the backslash
          break;
        default:
          die("Quoted pair logic invoked in an invalid context: $context");
        }

        break;
      //-------------------------------------------------------------
      // Comment
      //-------------------------------------------------------------
      case ISEMAIL_CONTEXT_COMMENT:
        // http://tools.ietf.org/html/rfc5322#section-3.2.2
        //   comment         =   "(" *([FWS] ccontent) [FWS] ")"
        //
        //   ccontent        =   ctext / quoted-pair / comment
        switch ($token) {
        // Nested comment
        case ISEMAIL_STRING_OPENPARENTHESIS:
          // Nested comments are OK
          $context_stack[]  = $context;
          $context    = ISEMAIL_CONTEXT_COMMENT;
          break;
        // End of comment
        case ISEMAIL_STRING_CLOSEPARENTHESIS:
          $context_prior    = $context;
          $context    = (int) array_pop($context_stack);

          // http://tools.ietf.org/html/rfc5322#section-3.2.2
          //   Runs of FWS, comment, or CFWS that occur between lexical tokens in a
          //   structured header field are semantically interpreted as a single
          //   space character.
          //
          // is_email() author's note: This *cannot* mean that we must add a
          // space to the address wherever CFWS appears. This would result in
          // any addr-spec that had CFWS outside a quoted string being invalid
          // for RFC 5321.
  //        if (($context === ISEMAIL_COMPONENT_LOCALPART) || ($context === ISEMAIL_COMPONENT_DOMAIN)) {
  //          $parsedata[$context]      .= ISEMAIL_STRING_SP;
  //          $atomlist[$context][$element_count]  .= ISEMAIL_STRING_SP;
  //          $element_len++;
  //        }

          break;
        // Quoted pair
        case ISEMAIL_STRING_BACKSLASH:
          $context_stack[]  = $context;
          $context    = ISEMAIL_CONTEXT_QUOTEDPAIR;
          break;
        // Folding White Space
        case ISEMAIL_STRING_CR:
        case ISEMAIL_STRING_SP:
        case ISEMAIL_STRING_HTAB:
          if (($token === ISEMAIL_STRING_CR) && ((++$i === $raw_length) || ($email[$i] !== ISEMAIL_STRING_LF))) {$return_status[] = ISEMAIL_ERR_CR_NO_LF;  break;}  // Fatal error

          $return_status[]  = ISEMAIL_CFWS_FWS;

          $context_stack[]  = $context;
          $context    = ISEMAIL_CONTEXT_FWS;
          $token_prior    = $token;
          break;
        // ctext
        default:
          // http://tools.ietf.org/html/rfc5322#section-3.2.3
          //   ctext           =   %d33-39 /          ; Printable US-ASCII
          //                       %d42-91 /          ;  characters not including
          //                       %d93-126 /         ;  "(", ")", or "\"
          //                       obs-ctext
          //
          //   obs-ctext       =   obs-NO-WS-CTL
          //
          //   obs-NO-WS-CTL   =   %d1-8 /            ; US-ASCII control
          //                       %d11 /             ;  characters that do not
          //                       %d12 /             ;  include the carriage
          //                       %d14-31 /          ;  return, line feed, and
          //                       %d127              ;  white space characters
          $ord = ord($token);

          if (($ord > 127) || ($ord === 0) || ($ord === 10)) {
            $return_status[]  = ISEMAIL_ERR_EXPECTING_CTEXT;  // Fatal error
            break;
          } elseif (($ord < 32) || ($ord === 127)) {
            $return_status[]  = ISEMAIL_DEPREC_CTEXT;
          }
        }

        break;
      //-------------------------------------------------------------
      // Folding White Space
      //-------------------------------------------------------------
      case ISEMAIL_CONTEXT_FWS:
        // http://tools.ietf.org/html/rfc5322#section-3.2.2
        //   FWS             =   ([*WSP CRLF] 1*WSP) /  obs-FWS
        //                                          ; Folding white space

        // But note the erratum:
        // http://www.rfc-editor.org/errata_search.php?rfc=5322&eid=1908:
        //   In the obsolete syntax, any amount of folding white space MAY be
        //   inserted where the obs-FWS rule is allowed.  This creates the
        //   possibility of having two consecutive "folds" in a line, and
        //   therefore the possibility that a line which makes up a folded header
        //   field could be composed entirely of white space.
        //
        //   obs-FWS         =   1*([CRLF] WSP)
        if ($token_prior === ISEMAIL_STRING_CR) {
          if ($token === ISEMAIL_STRING_CR) {
            $return_status[]  = ISEMAIL_ERR_FWS_CRLF_X2;  // Fatal error
            break;
          }

          if (isset($crlf_count)) {
            if (++$crlf_count > 1)
              $return_status[]  = ISEMAIL_DEPREC_FWS;  // Multiple folds = obsolete FWS
          } else $crlf_count = 1;
        }

        switch ($token) {
        case ISEMAIL_STRING_CR:
          if ((++$i === $raw_length) || ($email[$i] !== ISEMAIL_STRING_LF))
            $return_status[]  = ISEMAIL_ERR_CR_NO_LF;  // Fatal error

          break;
        case ISEMAIL_STRING_SP:
        case ISEMAIL_STRING_HTAB:
          break;
        default:
          if ($token_prior === ISEMAIL_STRING_CR) {
            $return_status[]  = ISEMAIL_ERR_FWS_CRLF_END;  // Fatal error
            break;
          }

          if (isset($crlf_count)) unset($crlf_count);

          $context_prior          = $context;
          $context          = (int) array_pop($context_stack);  // End of FWS

          // http://tools.ietf.org/html/rfc5322#section-3.2.2
          //   Runs of FWS, comment, or CFWS that occur between lexical tokens in a
          //   structured header field are semantically interpreted as a single
          //   space character.
          //
          // is_email() author's note: This *cannot* mean that we must add a
          // space to the address wherever CFWS appears. This would result in
          // any addr-spec that had CFWS outside a quoted string being invalid
          // for RFC 5321.
  //        if (($context === ISEMAIL_COMPONENT_LOCALPART) || ($context === ISEMAIL_COMPONENT_DOMAIN)) {
  //          $parsedata[$context]      .= ISEMAIL_STRING_SP;
  //          $atomlist[$context][$element_count]  .= ISEMAIL_STRING_SP;
  //          $element_len++;
  //        }

          $i--;  // Look at this token again in the parent context
        }

        $token_prior = $token;
        break;
      //-------------------------------------------------------------
      // A context we aren't expecting
      //-------------------------------------------------------------
      default:
        die("Unknown context: $context");
      }

  //-echo "<td>$context|",(($end_or_die) ? 'true' : 'false'),"|$token|" . max($return_status) . "</td></tr>"; // debug
      if ((int) max($return_status) > ISEMAIL_RFC5322) break;  // No point going on if we've got a fatal error
    }

    // Some simple final tests
    if ((int) max($return_status) < ISEMAIL_RFC5322) {
      if  ($context   === ISEMAIL_CONTEXT_QUOTEDSTRING)  $return_status[]  = ISEMAIL_ERR_UNCLOSEDQUOTEDSTR;  // Fatal error
      elseif  ($context   === ISEMAIL_CONTEXT_QUOTEDPAIR)    $return_status[]  = ISEMAIL_ERR_BACKSLASHEND;    // Fatal error
      elseif  ($context   === ISEMAIL_CONTEXT_COMMENT)    $return_status[]  = ISEMAIL_ERR_UNCLOSEDCOMMENT;    // Fatal error
      elseif  ($context   === ISEMAIL_COMPONENT_LITERAL)    $return_status[]  = ISEMAIL_ERR_UNCLOSEDDOMLIT;    // Fatal error
      elseif  ($token    === ISEMAIL_STRING_CR)      $return_status[]  = ISEMAIL_ERR_FWS_CRLF_END;    // Fatal error
      elseif  ($parsedata[ISEMAIL_COMPONENT_DOMAIN]  === '')    $return_status[]  = ISEMAIL_ERR_NODOMAIN;      // Fatal error
      elseif  ($element_len  === 0)          $return_status[]  = ISEMAIL_ERR_DOT_END;      // Fatal error
      elseif  ($hyphen_flag)            $return_status[]  = ISEMAIL_ERR_DOMAINHYPHENEND;    // Fatal error
      // http://tools.ietf.org/html/rfc5321#section-4.5.3.1.2
      //   The maximum total length of a domain name or number is 255 octets.
      elseif  (strlen($parsedata[ISEMAIL_COMPONENT_DOMAIN]) > 255)
                      $return_status[]  = ISEMAIL_RFC5322_DOMAIN_TOOLONG;
      // http://tools.ietf.org/html/rfc5321#section-4.1.2
      //   Forward-path   = Path
      //
      //   Path           = "<" [ A-d-l ":" ] Mailbox ">"
      //
      // http://tools.ietf.org/html/rfc5321#section-4.5.3.1.3
      //   The maximum total length of a reverse-path or forward-path is 256
      //   octets (including the punctuation and element separators).
      //
      // Thus, even without (obsolete) routing information, the Mailbox can
      // only be 254 characters long. This is confirmed by this verified
      // erratum to RFC 3696:
      //
      // http://www.rfc-editor.org/errata_search.php?rfc=3696&eid=1690
      //   However, there is a restriction in RFC 2821 on the length of an
      //   address in MAIL and RCPT commands of 254 characters.  Since addresses
      //   that do not fit in those fields are not normally useful, the upper
      //   limit on address lengths should normally be considered to be 254.
      elseif  (strlen($parsedata[ISEMAIL_COMPONENT_LOCALPART] . ISEMAIL_STRING_AT . $parsedata[ISEMAIL_COMPONENT_DOMAIN]) > 254)
                      $return_status[]  = ISEMAIL_RFC5322_TOOLONG;
      // http://tools.ietf.org/html/rfc1035#section-2.3.4
      // labels          63 octets or less
      elseif ($element_len > 63)          $return_status[]  = ISEMAIL_RFC5322_LABEL_TOOLONG;
    }

    // Check DNS?
    $dns_checked = false;

    if ($checkDNS && ((int) max($return_status) < ISEMAIL_DNSWARN) && function_exists('dns_get_record')) {
      // http://tools.ietf.org/html/rfc5321#section-2.3.5
      //   Names that can
      //   be resolved to MX RRs or address (i.e., A or AAAA) RRs (as discussed
      //   in Section 5) are permitted, as are CNAME RRs whose targets can be
      //   resolved, in turn, to MX or address RRs.
      //
      // http://tools.ietf.org/html/rfc5321#section-5.1
      //   The lookup first attempts to locate an MX record associated with the
      //   name.  If a CNAME record is found, the resulting name is processed as
      //   if it were the initial name. ... If an empty list of MXs is returned,
      //   the address is treated as if it was associated with an implicit MX
      //   RR, with a preference of 0, pointing to that host.
      //
      // is_email() author's note: We will regard the existence of a CNAME to be
      // sufficient evidence of the domain's existence. For performance reasons
      // we will not repeat the DNS lookup for the CNAME's target, but we will
      // raise a warning because we didn't immediately find an MX record.
      if ($element_count === 0) $parsedata[ISEMAIL_COMPONENT_DOMAIN] .= '.';    // Checking TLD DNS seems to work only if you explicitly check from the root

      $result = @dns_get_record($parsedata[ISEMAIL_COMPONENT_DOMAIN], DNS_MX);  // Not using checkdnsrr because of a suspected bug in PHP 5.3 (http://bugs.php.net/bug.php?id=51844)

      if ((is_bool($result) && !(bool) $result))
        $return_status[] = ISEMAIL_DNSWARN_NO_RECORD;      // Domain can't be found in DNS
      else {
        if (count($result) === 0) {
          $return_status[]  = ISEMAIL_DNSWARN_NO_MX_RECORD;    // MX-record for domain can't be found
          $result      = @dns_get_record($parsedata[ISEMAIL_COMPONENT_DOMAIN], DNS_A + DNS_CNAME);

          if (count($result) === 0)
            $return_status[] = ISEMAIL_DNSWARN_NO_RECORD;    // No usable records for the domain can be found
        } else $dns_checked = true;
      }
    }

    // Check for TLD addresses
    // -----------------------
    // TLD addresses are specifically allowed in RFC 5321 but they are
    // unusual to say the least. We will allocate a separate
    // status to these addresses on the basis that they are more likely
    // to be typos than genuine addresses (unless we've already
    // established that the domain does have an MX record)
    //
    // http://tools.ietf.org/html/rfc5321#section-2.3.5
    //   In the case
    //   of a top-level domain used by itself in an email address, a single
    //   string is used without any dots.  This makes the requirement,
    //   described in more detail below, that only fully-qualified domain
    //   names appear in SMTP transactions on the public Internet,
    //   particularly important where top-level domains are involved.
    //
    // TLD format
    // ----------
    // The format of TLDs has changed a number of times. The standards
    // used by IANA have been largely ignored by ICANN, leading to
    // confusion over the standards being followed. These are not defined
    // anywhere, except as a general component of a DNS host name (a label).
    // However, this could potentially lead to 123.123.123.123 being a
    // valid DNS name (rather than an IP address) and thereby creating
    // an ambiguity. The most authoritative statement on TLD formats that
    // the author can find is in a (rejected!) erratum to RFC 1123
    // submitted by John Klensin, the author of RFC 5321:
    //
    // http://www.rfc-editor.org/errata_search.php?rfc=1123&eid=1353
    //   However, a valid host name can never have the dotted-decimal
    //   form #.#.#.#, since this change does not permit the highest-level
    //   component label to start with a digit even if it is not all-numeric.
    if (!$dns_checked && ((int) max($return_status) < ISEMAIL_DNSWARN)) {
      if  ($element_count  === 0)  $return_status[]  = ISEMAIL_RFC5321_TLD;

      if  (is_numeric($atomlist[ISEMAIL_COMPONENT_DOMAIN][$element_count][0]))
              $return_status[]  = ISEMAIL_RFC5321_TLDNUMERIC;
    }

    $return_status    = array_unique($return_status);
    $final_status    = (int) max($return_status);

    if (count($return_status) !== 1) array_shift($return_status); // remove redundant ISEMAIL_VALID

    $parsedata['status']  = $return_status;

    if ($final_status < $threshold) $final_status = ISEMAIL_VALID;

    return ($diagnose) ? $final_status : ($final_status < ISEMAIL_THRESHOLD);
  }
}
?>]]></data>
	</file>
	<file>
	  <filename>/lib/class.fb_config.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/lib/class.formbuilder_utils.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/lib/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/method.install.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<?php
#-------------------------------------------------------------------------
# Module: FormBuilder
# Author: Samuel Goldstein, Morten Poulsen
#-------------------------------------------------------------------------
# CMS Made Simple is (c) 2004 - 2011 by Ted Kulp (wishy@cmsmadesimple.org)
# CMS Made Simple is (c) 2011 - 2014 by The CMSMS Dev Team
# This project's homepage is: http://www.cmsmadesimple.org
# The module's homepage is: http://dev.cmsmadesimple.org/projects/formbuilder
#-------------------------------------------------------------------------
# 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
#-------------------------------------------------------------------------

if (!is_object(@cmsms())) exit;

		$db = $this->GetDb();
		$dict = NewDataDictionary($db);
		$flds = "
			form_id I KEY,
			name C(255),
			alias C(255)
		";
		$taboptarray = array('mysql' => 'TYPE=MyISAM');
		$sqlarray = $dict->CreateTableSQL(cms_db_prefix().'module_fb_form', $flds, $taboptarray);
		$dict->ExecuteSQLArray($sqlarray);

		$db->CreateSequence(cms_db_prefix().'module_fb_form_seq');
		$db->Execute('CREATE UNIQUE INDEX '.cms_db_prefix().'module_fb_form_idx on '.cms_db_prefix().'module_fb_form (alias)');
		
		$flds = "
			form_attr_id I KEY,
			form_id I,
			name C(35),
			value X
		";
		$sqlarray = $dict->CreateTableSQL(cms_db_prefix().'module_fb_form_attr', $flds, $taboptarray);
		$dict->ExecuteSQLArray($sqlarray);

		$db->CreateSequence(cms_db_prefix().'module_fb_form_attr_seq');
		$db->Execute('create index '.cms_db_prefix().'module_fb_form_attr_idx on '.cms_db_prefix().'module_fb_form_attr (form_id)');

		$flds = "
			field_id I KEY,
			form_id I,
			name C(255),
			type C(50),
			validation_type C(50),
			required I1,
			hide_label I1,
			order_by I
		";
		$sqlarray = $dict->CreateTableSQL(cms_db_prefix().'module_fb_field', $flds, $taboptarray);
		$dict->ExecuteSQLArray($sqlarray);

		$db->CreateSequence(cms_db_prefix().'module_fb_field_seq');
		$db->Execute('create index '.cms_db_prefix().'module_fb_field_idx on '.cms_db_prefix().'module_fb_field (form_id)');


		$flds = "
			option_id I KEY,
			field_id I,
			form_id I,
			name C(255),
			value X
		";
		$sqlarray = $dict->CreateTableSQL(cms_db_prefix().'module_fb_field_opt', $flds, $taboptarray);
		$dict->ExecuteSQLArray($sqlarray);

		$db->CreateSequence(cms_db_prefix().'module_fb_field_opt_seq');
		$db->Execute('create index '.cms_db_prefix().'module_fb_field_opt_idx on '.cms_db_prefix().'module_fb_field_opt (field_id,form_id)');

		$flds = "
			flock_id I KEY,
			flock T
		";

		$sqlarray = $dict->CreateTableSQL(cms_db_prefix().'module_fb_flock', $flds, $taboptarray);
		$dict->ExecuteSQLArray($sqlarray);

		$flds = "
			resp_id I KEY,
			form_id I,
			feuser_id I,
			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_resp', $flds, $taboptarray);
		$dict->ExecuteSQLArray($sqlarray);

		$flds = "
			resp_attr_id I KEY,
			resp_id I,
			name C(35),
			value X
		";
		$sqlarray = $dict->CreateTableSQL(cms_db_prefix().'module_fb_resp_attr', $flds, $taboptarray);
		$dict->ExecuteSQLArray($sqlarray);

		$db->CreateSequence(cms_db_prefix().'module_fb_resp_attr_seq');


		$db->CreateSequence(cms_db_prefix().'module_fb_resp_seq');

		$flds = "
			resp_val_id I KEY,
			resp_id I,
			field_id I,
			value X
		";
		$sqlarray = $dict->CreateTableSQL(cms_db_prefix().'module_fb_resp_val', $flds, $taboptarray);
		$dict->ExecuteSQLArray($sqlarray);

		$db->CreateSequence(cms_db_prefix().'module_fb_resp_val_seq');

		$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');

		$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),
				feuid I,
				response XL,
				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_formbrowser_seq');
		$db->CreateSequence(cms_db_prefix().'module_fb_uniquefield_seq');

		$this->CreatePermission('Modify Forms', 'Modify Forms');

		$this->CreateEvent( 'OnFormBuilderFormSubmit' );
		$this->CreateEvent( 'OnFormBuilderFormDisplay' );
		$this->CreateEvent( 'OnFormBuilderFormSubmitError' );

		$css = file_get_contents(cms_join_path(dirname(__FILE__), 'includes','default.css'));
		$css_id = $db->GenID(cms_db_prefix().'css_seq');
		$db->Execute('insert into '.cms_db_prefix().'css (css_id, css_name, css_text, media_type, create_date) values (?,?,?,?,?)',
			array($css_id,'FormBuilder Default Style',$css,'screen',date('Y-m-d')));

		$path = cms_join_path(dirname(__FILE__),'includes');
		$dir=opendir($path);
   		while ($filespec=readdir($dir))
   			{
   			$params = array();
   			$aeform = '';
       		if (preg_match('/.xml$/',$filespec) > 0)
       			{
       			$params['fbrp_xml_file'] = cms_join_path($path,$filespec);
       			$aeform = new fbForm($this, $params, true);
				$res = $aeform->ImportXML($params);
       			}
       		}

#
# EOF
#
?>
]]></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
#-------------------------------------------------------------------------
# Module: FormBuilder
# Author: Samuel Goldstein, Morten Poulsen
#-------------------------------------------------------------------------
# CMS Made Simple is (c) 2004 - 2011 by Ted Kulp (wishy@cmsmadesimple.org)
# CMS Made Simple is (c) 2011 - 2014 by The CMSMS Dev Team
# This project's homepage is: http://www.cmsmadesimple.org
# The module's homepage is: http://dev.cmsmadesimple.org/projects/formbuilder
#-------------------------------------------------------------------------
# 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
#-------------------------------------------------------------------------

if (!is_object(@cmsms())) exit;

if (! $this->CheckAccess()) exit;

		$this->initialize();
		$db = $this->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)');
			}
		case "0.5.4":
		case "0.5.5":
		case "0.5.6":
			{
			$css = file_get_contents(cms_join_path(dirname(__FILE__), 'includes','default.css'));
			$css_id = $db->GenID(cms_db_prefix().'css_seq');
			$db->Execute('insert into '.cms_db_prefix().'css (css_id, css_name, css_text, media_type, create_date) values (?,?,?,?,?)',
					array($css_id,'FormBuilder Default Style',$css,'screen',date('Y-m-d')));
			
			}
		case "0.5.7":
		case "0.5.8":
		case "0.5.9":
		case "0.5.10":
		case "0.5.11":
		case "0.5.12":
		case "0.6b1":
		case "0.6b2":
        	$sqlarray = $dict->AddColumnSQL(cms_db_prefix()."module_fb_formbrowser", "feuid I");
        	$dict->ExecuteSQLArray($sqlarray);
			$sqlarray = $dict->AddColumnSQL(cms_db_prefix()."module_fb_formbrowser", "resnew XL");
        	$dict->ExecuteSQLArray($sqlarray);
			$db->Execute('update '.cms_db_prefix().'module_fb_formbrowser set resnew=response');
			$sqlarray = $dict->DropColumnSQL(cms_db_prefix()."module_fb_formbrowser", "response");
        	$dict->ExecuteSQLArray($sqlarray);
         // adodb-lite hoses column renames, so we do it the hard way
			$sqlarray = $dict->AddColumnSQL(cms_db_prefix()."module_fb_formbrowser", "response XL");
        	$dict->ExecuteSQLArray($sqlarray);
			$db->Execute('update '.cms_db_prefix().'module_fb_formbrowser set response=resnew');
			$sqlarray = $dict->DropColumnSQL(cms_db_prefix()."module_fb_formbrowser", "resnew");
        	$dict->ExecuteSQLArray($sqlarray);
        	// whew. that was lame.
			$path = cms_join_path(dirname(__FILE__),'includes');
			$params['fbrp_xml_file'] = cms_join_path($path,'Advanced_Contact_Form.xml');
			$aeform = new fbForm($this, $params, true);
			$res = $aeform->ImportXML($params);
		case "0.6":
		case "0.6.1":
		case "0.6.2":
		case "0.6.3":
		case "0.6.4":
		case "0.7":
		case "0.7.1":
		case "0.7.2":
			$this->RemovePreference('mle_version');
		case "0.8":
      $db->Execute('drop index '.cms_db_prefix().
        'module_fb_form_idx on '.cms_db_prefix().
        'module_fb_form');
           
      $db->Execute('create unique index '.cms_db_prefix().
        'module_fb_form_idx on '.cms_db_prefix().
        'module_fb_form (alias)');

		}

#
# EOF
#
?>
]]></data>
	</file>
	<file>
	  <filename>/templates/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/templates/AddEditField.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2lmIGlzc2V0KCRtZXNzYWdlKX17JG1lc3NhZ2V9ey9pZn0NCg0KeyRiYWNrdG9mb3JtX25hdn08YnIgLz4NCnskc3RhcnRfZm9ybX17JGZiX2hpZGRlbn17aWYgaXNzZXQoJG9wKX17JG9wfXsvaWZ9eyR0YWJfc3RhcnR9DQp7JG1haW50YWJfc3RhcnR9DQoJe2ZvcmVhY2ggZnJvbT0kbWFpbkxpc3QgaXRlbT1lbnRyeX0NCgkJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4NCgkJCTxwIGNsYXNzPSJwYWdldGV4dCI+eyRlbnRyeS0+dGl0bGV9OjwvcD4NCgkJCTxkaXYgY2xhc3M9InBhZ2VpbnB1dCI+eyRlbnRyeS0+aW5wdXR9PC9kaXY+DQoJCQl7aWYgJGVudHJ5LT5oZWxwICE9ICcnfTxkaXYgY2xhc3M9ImlucHV0aGVscCI+eyRlbnRyeS0+aGVscH08L2Rpdj57L2lmfQ0KCQk8L2Rpdj4NCgl7L2ZvcmVhY2h9DQp7JHRhYl9lbmR9DQp7JGFkdmFuY2VkdGFiX3N0YXJ0fQ0KCXtmb3JlYWNoIGZyb209JGFkdkxpc3QgaXRlbT1lbnRyeX0NCgkJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4NCgkJCTxwIGNsYXNzPSJwYWdldGV4dCI+eyRlbnRyeS0+dGl0bGV9OjwvcD4NCgkJCTxkaXYgY2xhc3M9InBhZ2VpbnB1dCI+eyRlbnRyeS0+aW5wdXR9PC9kaXY+DQoJCQl7aWYgJGVudHJ5LT5oZWxwICE9ICcnfTxkaXYgY2xhc3M9ImlucHV0aGVscCI+eyRlbnRyeS0+aGVscH08L2Rpdj57L2lmfQ0KCQk8L2Rpdj4NCgl7L2ZvcmVhY2h9DQp7JHRhYl9lbmR9DQp7JHRhYnNfZW5kfQ0Ke2lmICRhZGQgIT0gJycgb3IgJGRlbCAhPSAnJ30NCgk8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPg0KCQk8cCBjbGFzcz0icGFnZXRleHQiPiZuYnNwOzwvcD4NCgkJPHAgY2xhc3M9InBhZ2VpbnB1dCI+eyRhZGR9eyRkZWx9PC9wPg0KCTwvZGl2Pg0Key9pZn0NCgk8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPg0KCQk8cCBjbGFzcz0icGFnZXRleHQiPiZuYnNwOzwvcD4NCgkJPHAgY2xhc3M9InBhZ2VpbnB1dCI+e2lmIGlzc2V0KCRzdWJtaXQpfXskc3VibWl0fXsvaWZ9eyRjYW5jZWx9PC9wPg0KCTwvZGl2Pg0KeyRlbmRfZm9ybX0NCg==]]></data>
	</file>
	<file>
	  <filename>/templates/AddEditField2.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e2lmIGlzc2V0KCRtZXNzYWdlKX17JG1lc3NhZ2V9ey9pZn0NCg0KeyRiYWNrdG9mb3JtX25hdn08YnIgLz4NCnskc3RhcnRfZm9ybX17JGZiX2hpZGRlbn17aWYgaXNzZXQoJG9wKX17JG9wfXsvaWZ9DQp7dGFiX2hlYWRlciBuYW1lPSdtYWludGFiJyBsYWJlbD0kZnJtYmxkLT5sYW5nKCd0YWJfbWFpbicpfQ0Ke3RhYl9oZWFkZXIgbmFtZT0nYWR2YW5jZWR0YWInIGxhYmVsPSRmcm1ibGQtPmxhbmcoJ3RhYl9hZHZhbmNlZCcpfQ0Ke3RhYl9zdGFydCBuYW1lPSdtYWludGFiJ30NCgl7Zm9yZWFjaCBmcm9tPSRtYWluTGlzdCBpdGVtPWVudHJ5fQ0KCQk8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPg0KCQkJPHAgY2xhc3M9InBhZ2V0ZXh0Ij57JGVudHJ5LT50aXRsZX06PC9wPg0KCQkJPGRpdiBjbGFzcz0icGFnZWlucHV0Ij57JGVudHJ5LT5pbnB1dH08L2Rpdj4NCgkJCXtpZiAkZW50cnktPmhlbHAgIT0gJyd9PGRpdiBjbGFzcz0iaW5wdXRoZWxwIj57JGVudHJ5LT5oZWxwfTwvZGl2PnsvaWZ9DQoJCTwvZGl2Pg0KCXsvZm9yZWFjaH0NCnt0YWJfc3RhcnQgbmFtZT0nYWR2YW5jZWR0YWInfQ0KCXtmb3JlYWNoIGZyb209JGFkdkxpc3QgaXRlbT1lbnRyeX0NCgkJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4NCgkJCTxwIGNsYXNzPSJwYWdldGV4dCI+eyRlbnRyeS0+dGl0bGV9OjwvcD4NCgkJCTxkaXYgY2xhc3M9InBhZ2VpbnB1dCI+eyRlbnRyeS0+aW5wdXR9PC9kaXY+DQoJCQl7aWYgJGVudHJ5LT5oZWxwICE9ICcnfTxkaXYgY2xhc3M9ImlucHV0aGVscCI+eyRlbnRyeS0+aGVscH08L2Rpdj57L2lmfQ0KCQk8L2Rpdj4NCgl7L2ZvcmVhY2h9DQp7dGFiX2VuZH0NCntpZiAkYWRkICE9ICcnIG9yICRkZWwgIT0gJyd9DQoJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4NCgkJPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+DQoJCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskYWRkfXskZGVsfTwvcD4NCgk8L2Rpdj4NCnsvaWZ9DQoJPGRpdiBjbGFzcz0icGFnZW92ZXJmbG93Ij4NCgkJPHAgY2xhc3M9InBhZ2V0ZXh0Ij4mbmJzcDs8L3A+DQoJCTxwIGNsYXNzPSJwYWdlaW5wdXQiPntpZiBpc3NldCgkc3VibWl0KX17JHN1Ym1pdH17L2lmfXskY2FuY2VsfTwvcD4NCgk8L2Rpdj4NCnskZW5kX2Zvcm19DQo=]]></data>
	</file>
	<file>
	  <filename>/templates/AddEditForm.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[{if isset($message)}{$message}{/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 pagetable" cellpadding="0" cellspacing="0">
				<thead><tr>
	       	{if isset($title_field_id)}
                <th width="20">{$title_field_id}</th>
		{/if}
    				<th width="120">{$title_field_name}</th>
        {if isset($title_field_alias)}
    				<th width="60">{$title_field_alias}</th>
		{/if}
                	<th width="150">{$title_field_type}</th>
                	{*<th width="20">{$title_field_required_abbrev}</th>*}
                	<th>{$title_information}</th>
 					<th width="20" class="updown">&nbsp;</th>
					<th width="20" class="updown">&nbsp;</th>
					<th class="pageicon">&nbsp;</th>
					<th class="pageicon">&nbsp;</th>
                    <th class="pageicon">&nbsp;</th>
					</tr>
				</thead>
				<tbody>
				{foreach from=$fields item=entry}
					<tr id="fbrp_{$entry->id}" class="{$entry->rowclass}">
				{if isset($title_field_id)}
					<td>{$entry->id}</td>
				{/if}
					<td>{$entry->name}</td>
					{if isset($title_field_alias)}
						<td>{$entry->alias}</td>
					{/if}
					<td>{$entry->type}</td>
					<td>{$entry->field_status}</td>						
					<td class="updown">{$entry->up}</td>
					<td class="updown">{$entry->down}</td>				
					<td>{$entry->disposition}</td>					
					<td>{$entry->editlink}</td>
					<td>{$entry->deletelink}</td>
					</tr>
				{/foreach}
				</tbody>
            </table>
			{*<div class="reordermessage pagemcontainer" style="display:none"><p class="pagemessage">{$title_must_save_order}</p></div>*}	
			<br />
			{$add_field_link}
        </div>
     </div>
</fieldset>
{/if}
{$tab_end}

{$submittab_start}

<div class="information">{$title_submit_help}</div>

<fieldset class="module_fb_fieldset"><legend>{$title_submit_actions}</legend>
	<div class="pageoverflow">
		<p class="pagetext">{$title_form_validate_udt}:</p>
		<p class="pageinput">{$input_form_validate_udt}</p>
	</div>
	<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}{$udttab_start}
	<div class="pageoverflow">
		<p class="pagetext">{$title_form_predisplay_udt}:</p>
		<p class="pageinput">{$input_form_predisplay_udt}</p>
	</div>
	<div class="pageoverflow">
		<p class="pagetext">{$title_form_predisplay_each_udt}:</p>
		<p class="pageinput">{$input_form_predisplay_each_udt}</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}
	<div class="information">{$title_submit_response_help}</div>
	<div class="pageoverflow">
		<p class="pagetext">{$title_submit_response}:</p>
		<p class="pageinput">{$input_submit_response}</p>
		<div class="pageinput">{$help_submit_response}</div>
	</div>
{$tab_end}

{$tabs_end}
	<div class="pageoverflow">
		<p class="pagetext">&nbsp;</p>
		<p class="pageinput">{$save_button}{$submit_button}{$cancel_button}</p>
	</div>
{$form_end}]]></data>
	</file>
	<file>
	  <filename>/templates/AddEditForm2.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[{if isset($message)}{$message}{/if}

{$formstart}
{$formid}{$fb_hidden}

{tab_header name='maintab' label=$frmbld->lang('tab_main')}
{tab_header name='submittab' label=$frmbld->lang('tab_submit')}
{tab_header name='symboltab' label=$frmbld->lang('tab_symbol')}
{tab_header name='captchatab' label=$frmbld->lang('tab_captcha')}
{tab_header name='udttab' label=$frmbld->lang('tab_udt')}
{tab_header name='templatelayout' label=$frmbld->lang('tab_templatelayout')}
{tab_header name='submittemplate' label=$frmbld->lang('tab_submissiontemplate')}

{tab_start name='maintab'}

<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 pagetable" cellpadding="0" cellspacing="0">
				<thead><tr>
	       	{if isset($title_field_id)}
                <th width="20">{$title_field_id}</th>
		{/if}
    				<th width="120">{$title_field_name}</th>
        {if isset($title_field_alias)}
    				<th width="60">{$title_field_alias}</th>
		{/if}
                	<th width="150">{$title_field_type}</th>
                	{*<th width="20">{$title_field_required_abbrev}</th>*}
                	<th>{$title_information}</th>
 					<th width="20" class="updown">&nbsp;</th>
					<th width="20" class="updown">&nbsp;</th>
					<th class="pageicon">&nbsp;</th>
					<th class="pageicon">&nbsp;</th>
                    <th class="pageicon">&nbsp;</th>
					</tr>
				</thead>
				<tbody>
				{foreach from=$fields item=entry}
					<tr id="fbrp_{$entry->id}" class="{$entry->rowclass}">
				{if isset($title_field_id)}
					<td>{$entry->id}</td>
				{/if}
					<td>{$entry->name}</td>
					{if isset($title_field_alias)}
						<td>{$entry->alias}</td>
					{/if}
					<td>{$entry->type}</td>
					<td>{$entry->field_status}</td>						
					<td class="updown">{$entry->up}</td>
					<td class="updown">{$entry->down}</td>				
					<td>{$entry->disposition}</td>					
					<td>{$entry->editlink}</td>
					<td>{$entry->deletelink}</td>
					</tr>
				{/foreach}
				</tbody>
            </table>
			{*<div class="reordermessage pagemcontainer" style="display:none"><p class="pagemessage">{$title_must_save_order}</p></div>*}	
			<br />
			{$add_field_link}
        </div>
     </div>
</fieldset>
{/if}

{tab_start name='submittab'}
	<div class="information">{$title_submit_help}</div>
	
<fieldset class="module_fb_fieldset"><legend>{$title_submit_actions}</legend>
	<div class="pageoverflow">
		<p class="pagetext">{$title_form_validate_udt}:</p>
		<p class="pageinput">{$input_form_validate_udt}</p>
	</div>
	<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_start name='symboltab'}
	<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_start name='udttab'}
	<div class="pageoverflow">
		<p class="pagetext">{$title_form_predisplay_udt}:</p>
		<p class="pageinput">{$input_form_predisplay_udt}</p>
	</div>
	<div class="pageoverflow">
		<p class="pagetext">{$title_form_predisplay_each_udt}:</p>
		<p class="pageinput">{$input_form_predisplay_each_udt}</p>
	</div>
	
{tab_start name='captchatab'}
{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_start name='templatelayout'}
	<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_start name='submittemplate'}
	<div class="information">{$title_submit_response_help}</div>
	<div class="pageoverflow">
		<p class="pagetext">{$title_submit_response}:</p>
		<p class="pageinput">{$input_submit_response}</p>
		<div class="pageinput">{$help_submit_response}</div>
	</div>
{tab_end}
	<div class="pageoverflow">
		<p class="pagetext">&nbsp;</p>
		<p class="pageinput">{$save_button}{$submit_button}{$cancel_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/AdminMain2.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/templates/help_text.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[<div id="page_tabs">
    <div id="general">General</div>
	<div id="forms">Forms</div>
	<div id="fields">Fields</div>
	<div id="template_variable">Templates and Variables</div>
	<div id="advanced">Advanced</div>
	<div id="styling">Styling</div>
	<div id="configuration">Configuration</div>
	<div id="about">About</div>
</div>

<div class="clearb"></div>

<div id="page_content">
	<div id="general_c">
		<h3>What Does This Do?</h3>
		<p>The Form Builder Module allows you to create 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 {ldelim}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>
	</div>
	
	<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
	
	<div id="forms_c">
		<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>
	</div>
	
	<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
	
	<div id="fields_c">
		<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>

		<h4>Standard Inputs</h4>
		<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>Button. This doens't do anything, but you can hook it into some Javascript.</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>Password. This is an asterisked-out text field, useful for passwords.</li>
		<li>Password Again (verify). This is a field that must match a Password field for submission
		to succeed.</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>

		<h4>Email-specific Inputs</h4>
		<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>

		<h4>Display Control Fields</h4>
		<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>
		<li>User Tag. This calls the specified User Defined Tag, and displays anything it returns. The UDT gets called any time the field would be visible.</li>
		</ul>

		<h4>Form Handling Inputs (Dispositions)</h4>
		<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 \$params['field_name'], and as \$params['field_alias'] (if defined).</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 "From Address" Field, and send copy. This works like the Email "From Address" Field described above, but it provides options for sending a copy of the results to the user.</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 results based on frontend fields. This field is an email disposition that allows form fields' user input to specify the Email Subject, "From Name", "From Address", and Destination Email Address.</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>*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>*Write Results to a Unique Flat File for each submission. This takes the form results and writes them to a unique text file for each form submission.
		You can specify a filename pattern using values from form fields, set its format, and set the directory where the files will be stored.</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.0.3. Stores the form results in an XML structure as a single database record. This is the only interface to Form Browser.</li>
		<li>*Store Results for ListItExtended. Stores the form results into ListItExtended object and saves it into database.</li>
		<li>*Submit to an arbitrary form action. Craft an HTTP GET or POST, and transmit it using cURL to the specified URL. This lets you use FormBuilder as a front-end to any CGI or Form Handling script out there.</li>
		</ul>
	</div>
	
	<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
	
	<div id="template_variable_c">
		{$mod->Lang('template_variable_help')}
	</div>
	
	<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
	
	<div id="advanced_c">
		<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>{ldelim}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 unwieldy or contain characters that don't work well with Smarty. So there is an
		alternative like this:</p>
		<p>{ldelim}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 its 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. As of version 0.5, variables also have aliases, which you can use.</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>Use with FormBrowser v3</h3>
		<p>There are some special features when using FormBuilder with FormBrowser. The new approach stores the form results in XML, so that far fewer
		queries are needed to retrieve records. This means you can use FormBrowser with hundreds or even thousands of records. It also means you
		will have to choose up front which fields you will want to be able to sort by. You can choose up to five. Changing these after there are submitted records will result in improper sorting! A re-index function will be added to a future version.</p>
		<p>In advanced options, you can tie a form to Frontend Users. That means each user gets one record for the form; they can create it
		a single time, subsequent times they will be editing their record. The record will not be visible to any other users (excluding admins).
		This form should be added to your page using the syntax {ldelim}FormBuilder action='feuserform' form='form_name'}.</p>
		<p>For greater data safety, you can encrypt the stored forms in the database. You can use the built-in mycrypt library or the OpenSSL module.
		In either case, for the passphrase, you can either enter text in the field or a file name. If you specify a file name, the contents of that
		file will be used as the passphrase for encrypting.</p>
		<p>If you encrypt, be aware that the fields you use for sorting are <strong>not</strong> encrypted. You can choose to hash them; the cheat here
		is that the first four letters are left intact to allow for sorting. The sorting may not be perfect, and this weakens the security since it
		exposes some cleartext, but it is better than nothing.</p>
		<p><strong>DISCLAIMER</strong>. The encryption offered here should be considered just one more hurdle for a hacker, not as a guarantee that
		your information will be secure. A smart hacker who has found some exploit to view database records may well be smart enough to get at
		the module source code, and find their way to the passphrase. This will not protect you against an enemy who has full access to your
		server, some familiarity with PHP, and the time to poke around. <em><strong>Do not</strong> use this to protect high-value information such as financial data,
		sensitive political information, human rights data, or anything else that might be of value to a repressive government or organized crime
		cartel.</em></p>
		
		<h3>Using with User Defined Tags (UDTs)</h3>
		<p>Several options for customizing behavior via UDTs is provided (thanks to kind code contributions, see credits).</p>

		<ul>
		<li>Call User Defined Tag With the Form Results. This field type submits the human-readable form results to the User-Defined
		Tag you specify. The UDT can handle the results however it wants. Values are passed as $params['field_name'], and
		as $params['field_alias'] (if defined). As per a suggestion, it also populates all of the Smarty values that would be visible to the Submission Template too!</li>
		<li>User Tag Field. This calls the specified UDT, and displays anything it returns. The UDT gets called any time the field would be visible.</li>
		<li>Validation UDT. Set this for a form, and the UDT will receive all of the form's human-readable results. The UDT should do whatever
		validation it wants, and return an array with the first value being true or false (indication whether the form validates), and the second
		value being error messages (if any).</li>
		<li>User defined tag to call before form is displayed the first time (only called once). This
		is set in the Form Admin in the UDT Integration tab. The UDT gets called on the first display
		of the form.</li>
		<li>User defined tag to call before form is displayed (called on every page of multipage
		forms). This is set in the Form Admin in the UDT Integration tab. The UDT gets called
		every time any page of the form is displayed (including when validation fails).</li>
		</ul>
	</div>
	
	<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
	
	<div id="styling_c">
		<h3>Styling and CSS</h3>
		<p>After a bit of nagging on the part of people who actually respect standards, FormBuilder no longer encourages tricks like embedding CSS in 
		static text fields. Instead, it creates a stylesheet called "FormBuilder Default" that you are encouraged to attach to the page template
		that you use for pages that contain your form.</p>  
		<p>This default CSS was graciously provided by Paul Noone.</p>
	</div>
	
	<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
	
	<div id="configuration_c">
		<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 no longer set by default. Checking it will hide the more detailed errors that would 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>Miscellaneous Notes</h3>
		<ul>
      <li>Any fields that sends email to a specified email address will also accept a comma-separated list of email addresses.</li>
		  <li>The File Upload field type won't repopulate on form failure to validate. This is not a bug: it's a security limitation and it's enforced by the browsers. As such, currently and in the foreseeable HTML5 future (as it was in the past with the exception of Opera browsers), only the user can populate a file input field. It's not possible to (re)populate the file input field either with javascript or by setting a default value as it's not supported by the browsers.</li>
		</ul>
		<h3>Known Issues</h3>
		<ul>
		<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>FormBuilder/FormBrowser <strong>requires</strong> PHP 5.2.4 or later to function correctly.</li>
		<li>First step is to check you're running CMS 1.11 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>Make sure you can successfully send email via the test in the CMSMailer Module. It's simply amazing how many problems boil down to a misconfigured CMSMailer.</li>
		<li>Last resort 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>	
	</div>
	
	<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
	
	<div id="about_c">
		<h3>Copyright and License</h3>
		<p>Copyright &copy; 2006, Samuel Goldstein. All Rights Are Reserved.</p>
		<p>Copyright &copy; 2012, Tapio Löytty. All Rights Are Reserved.</p>
		<p>Copyright &copy; 2014, Morten Poulsen [morten at poulsen dot org]. All Rights Are Reserved.</p>
		<br />
		<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>
		<br />
		<p>Many people have contributed code, bug reports, cash, and ideas to FormBuilder. Among them:</p>
		<ul>
			<li>Fernando Morgado - code</li>
			<li>Rolf Tjassens - code</li>
			<li>Ryan Foster - code</li>
			<li>Jonathan Schmid - code, helptext</li>
			<li><a href="http://www.bpti.eu" target="_blank">Baltic institute of advanced technology</a> - code, funding</li>
			<li>Jeremy Bass - code and suggestions</li>
			<li>Alberto Benati - code</li>
			<li>Tyler Boespflug - funding and ideas</li>
			<li>Jeff Bosch - UDT Validation</li>
			<li>Robert Campbell - numerous code contributions</li>
			<li>Piotras Cimmperman - code</li>
			<li>Nuno Costa - suggestions</li>
			<li>Marc Geldon - code</li>
			<li>Kevin Grandon - code</li>
			<li>Ronny Krijt - code</li>
			<li>Paul Noone - CSS and ideas</li>
			<li>Prue Rowland - bug fixes</li>
			<li>Simon Schaufelberger - code</li>
			<li>Adam Shaw-Vardi - funding and ideas</li>
      <li>Jean-Claude Etiemble (jce76350): testing and suggestions;</li>
		</ul>
		<p>I apologize for any omissions - notify me, and I'll correct the omission!</p>
	</div>

	<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->]]></data>
	</file>
	<file>
	  <filename>/templates/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></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/RTF_TemplateAdvanced.rtf</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e1xydGYxXGFuc2lcYW5zaWNwZzEyNTJcZGVmZjBcZGVmbGFuZzEwMzNcZGVmbGFuZ2ZlMjA1MntcZm9udHRibHtcZjBcZnN3aXNzXGZwcnEyXGZjaGFyc2V0MCBBcmlhbDt9fQ0KXHZpZXdraW5kNFx1YzFccGFyZFxub3dpZGN0bHBhclxmMFxmczIwICUlSEVBREVSJSVccGFyDQpccGFyDQpUaGlzIGlzIGEgc2ltcGxlIEFkdmFuY2VkIFJURiBGaWxlIFRlbXBsYXRlLlxwYXINClxwYXINCkZvcm0gTmFtZTogJVskc3ViX2Zvcm1fbmFtZV0lXHBhcg0KRGF0ZSBvZiBTdWJtaXNzaW9uOiAlWyRzdWJfZGF0ZV0lXHBhcg0KWW91ciBzZXJ2ZXI6ICVbJHN1Yl9ob3N0XSVccGFyDQpJUCBhZGRyZXNzIG9mIHBlcnNvbiB1c2luZyBmb3JtOiAlWyRzdWJfc291cmNlX2lwXSVccGFyDQpVUkwgb2YgcGFnZSBjb250YWluaW5nIGZvcm06ICVbJHN1Yl91cmxdJVxwYXINCkZvcm1CdWlsZGVyIHZlcnNpb246ICVbJGZiX3ZlcnNpb25dJVxwYXINClxwYXINCkRvbid0IHdhbnQgYSBGb290ZXI/ICBEb24ndCBwdXQgdGhlIEZPT1RFUiB0YWcgaW4gdGhlIGRvY3VtZW50IVxwYXINCn0NCgA=]]></data>
	</file>
	<file>
	  <filename>/templates/RTF_TemplateAdvancedTables.rtf</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/templates/RTF_TemplateBasic.rtf</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e1xydGYxXGFuc2lcYW5zaWNwZzEyNTJcZGVmZjBcZGVmbGFuZzEwMzN7XGZvbnR0Ymx7XGYwXGZzd2lzc1xmY2hhcnNldDAgQXJpYWw7fX0NClx2aWV3a2luZDRcdWMxXHBhcmRcZjBcZnMyMCAlJUhFQURFUiUlXHBhcg0KJSVGSUVMRFMlJVxwYXINCiUlRk9PVEVSJSVccGFyDQp9DQoA]]></data>
	</file>
	<file>
	  <filename>/templates/RTF_TemplateBasicColors.rtf</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[e1xydGYxXGFuc2lcYW5zaWNwZzEyNTJcZGVmZjBcZGVmbGFuZzEwMzN7XGZvbnR0Ymx7XGYwXGZzd2lzc1xmY2hhcnNldDAgQXJpYWw7fX0NCntcY29sb3J0YmwgO1xyZWQyNTVcZ3JlZW4wXGJsdWUwO1xyZWQwXGdyZWVuMjU1XGJsdWUwO1xyZWQwXGdyZWVuMFxibHVlMjU1O30NClx2aWV3a2luZDRcdWMxXHBhcmRcY2YxXGYwXGZzMjAgJSVIRUFERVIlJVxjZjBccGFyDQpcY2YyICUlRklFTERTJSVcY2YwXHBhcg0KXGNmMyAlJUZPT1RFUiUlXGNmMFxwYXINCn0NCgA=]]></data>
	</file>
</module>
