RackForms v7.8.8
Site Tag Line
Latest Release: Build 958 - Arpil 18th, 2023
Contact Us  Purchase Options Purchase Options Contact Us

Top Link
Text Calendar

In Brief: Creates a calendar object for selecting dates using a floating div 'calendar', dates are them populated into various arrangements of text and select fields.

Dependencies: none.

Hints & Tricks: The calendar supports both American and European Date Formats. Your calendars link colors are controlled by the Form Style Properties Form Link Color item.

Important note on calendar layering: Due to the way calendar item pop-ups are placed within their containing <li> elements, you may notice that when you click on the calendar icon, the date selector displays behind other calendar field items. This is especially true when using a Free Form Page Layout and you have several calendar items situated very close to one another. This behavior is by design, as every calendar item is designed to display on top of the calendar item directly below it when in sortable Page Layout mode, and thus, calendar items never show 'behind' others.

A problem arises when in Free Form mode however, in that this ordering becomes obfuscated because the sort order, while still existing, is replaced in the RackForms editor with CSS absolute positioning, and thus the calendar item no longer 'knows' what fields are below it.

The fix for this is to manipulate the sort order of your calendar items in sortable Page Layout mode. You may recall that you can switch back and forth between sortable and free form mode at will--you will never loose either layouts last settings. Thus, if you have a calendar field item that displays below anther, try swapping the sort order (position) of the offending calendars.

However, as of Build 697 we can now use the fields z-index property to set layering. This is a much quicker solution, and as the results are shown in the editor in real time, less prone to error.

Important Note on using Calendar item in a database table: We can insert calendar values into a database in two main ways:

a) via VARCHAR fields and
b) as DATETIME or TIMESTAMP values.

When we use the first method we will rarely run into issues, as VARCHAR fields, so long as they are long enough, will hold any value the calendar field provides. The advantage here is simplicity both on the INSERT and SELECT sides, That is, when we store the data value in the database as a simple text field, we can SELECT it and display it with no extra work--the items is always in the correct format. The problem with this simplistic approach is is we cannot take advantage of SQL's native date logic, such as sorting by date.

It is for this reason that most of the time when we INSERT date values into a database we do so to DATETIME or TIMESTAMP fields. The advantages are we can use default values which set the time the record was updated or inserted, as well as gain all the power SQL provides for sorting and ordering date values.

The disadvantage is the date we INSERT must be in a specific format. The good news is RackForms, as described below, will handle this logic for us. That is, we can use the calendar field and by using the meta property of field_name_ts, we will grab the proper format the database requires.

The key however, is knowing that whenever we need a DATETIME or TIMESTAMP values, not providing the properly formatted values will cause the INSERT to silently fail. You can learn more about the MySQL date formats here.

Important Note On Using Values to Prepopulate Calendar Fields: At this time only calendar types marked with the [TS, DT] label can be pre-populated.


Basic Attributes

HTML 5 Type (text input fields only)

This field, which default to text, allows us to set specific input type values for this field. At the most basic level, setting a type will enable browser based validation, and possibly create extra input controls for the field.

Browser Validation:

While we have a full validation system available to us in RackForms, in recent years browser vendors have taken steps to implement some of the most common validation steps within the browser itself. The Email field is a good example of this, when set the browser will check the validity of the input against common email patterns. If this field is found invalid the browser automatically applies a OS/Browser specific style to the invalid field.

Extra Input Controls

Generally speaking, adding extra input controls such as calendars and color pickers meant downloading and implementing a third party JavaScript solution. With the new HTML 5 controls this work is now implemented directly in the browser. A good example of this is the Date type, when set in some browsers a calendar item appears next to the field.


It's very important to note these controls and their implementations vary wildly across browsers and OS's, and even then, not consistently across the same browser over different OS's.

For a current compatibility list please see: W3 Schools.

The good news is if an input type isn't supported the browser simply renders a standard text box.


Type the text you want to appear above or to the side of the form element. This is also the value of the text displayed in the RackForms Result Browser and Email messages.

The label field supports local PHP variables if they are wrapped in PHP tags and echo'd out as: <?php echo $val; ?>

Please note that only local variables are supported, $_SESSION variables must be bound to local variables in the PHP Top Code or PHP Head Code section first.

As of Build 693 the functionality of this item has been expanded to support dynamic tokens for E-Commerce items. Please see the in-editor tooltip (located just above this field), for specifics.

As of Build 701, this field now also accepts the standard RackForms 2 token set for form field labels. Please see the in-app tooltip for exact values to use.

As of Build 705, this field now accepts the standard RackForms 2 token set for Section/Headline Text and Body Copy elements. That is, we used to only be able to use the @{value} token, as can now use F{}, S{} and so on.

The 'new' tokens will, by default, transform linebreaks into HTML br tags. This is very handy when we want to display a text area to a user where such line breaks have been added. This ensures the typed value matches, as closely as possible, the display.

Also in Build 705 is the 'raw' field token: FR{field_name}. This token was created because by default, when we use a F{} token for say, text1, we are actually creating the following code:

<?php if(isset($_SESSION['qs']["{$_SESSION['entry_key']}"]['text1'])) { echo "{$_SESSION['qs']["{$_SESSION['entry_key']}"]['text1']}"; }?>

That is, a full (but inline) PHP block. This makes it impossible to create custom logic in a Body Copy or Section Text block, as the open and close PHP blocks break any such custom code.

Thus, the raw token only places the raw field value into the text data, nothing more. The same text1 item now looks like:


That is, no PHP block, and no isset().This means we could, for example, create the following logic in a Body Copy element:

if(isset(FR{text1}) && FR{text1} != "") { ?>
I want to hide this Bodycopy if @{text1} is empty ?
<?php } ?>

Tail Text
Tail Text allows us to add text just after a text field element. Generally speaking this is useful for adding definitions to the data being entered, such as lbs, psi, and so on.

The content in this item is enclosed in a span with a class of tailtext, and is thus best used for small images and blocks of simple text.

By default the text container is defined in formpage.css with a rule of:

.tailtext { font-size: 75%; }

This means the text will usually be smaller than the label field by a small amount. However, we can certainly add our own html and inline styles to this element for a more custom look.


This element is set by RackForms automatically, though it is recommended to change this value if you decide to display Javascript validation messages, as the 'identifying' text of the error is the value of this field.

This value is displayed by default if no 'Label' attribute is assigned to the element. For technical users, this element name is in fact the same as the Name/Value html form attribute of this element.

You will also notice that if you change the name of this field, the id attribute to the immediate right of this element also updates with the same value. This is because in most cases you should keep the same value for both elements--however, you can use a different value, simply type in the id field separately.

Naming Convention Note: The only valid punctuation for the Name/Value and id fields is the underscore _. Use of any other character will cause the form to fail.

This is an incredibly important item for the Email+ and SQL+ Modules. The value you type into this box is what you will use to retrieve the dynamic value of the field at runtime. This element is often referred to as {field_id} in the documentation of those modules


By default is assigned the same value as the Name/Value element, though you can change this to a more field specific value. Not necessary for most applications. For technical users, this is the id attribute of the field item.

Wrapper Class Name

Every field element in RackForms is wrapped in either a LI or DIV element for Sortable or Free Form page types, respectively. When you place a value in this box it becomes the class="" attribute for that wrapper. Because a wrapper encompass both the input element and wrapper, you can use this value to show and hide sections of your form.

Helper Text

This text displays on the bottom of the field item. By default, the text is 7pt and light grey #888888. You can change the elements color in the RackForms editor, but the font size must be changed in the jobs formpage.css file.

Default Value
[Only used with text element such as text box and text area]
Any pre-assigned values for this element should be typed into this box. At run-time this value is automatically populated into the field item.

Please note this area can contain a mix of tokens and standard text. This means we can have:


...and any non-token characters, in this case: -entry, will be included as well. Pay special attention to spaces, as they will be rendered along with any tokens!

There are a few special considerations with using PHP variables in this field:

1. Always wrap the full variable in braces.

2. You cannot execute functions in this block, only variables.

3. $_SESSION variables must use single quotes as in {$_SESSION['variable']}, not double quotes as in {$_SESSION["variable"]}

4. All variables are passed through htmlentities($variable, ENT_COMPAT), which means any double quotes are turned into &quot;

Placeholder Text

This value appear within a text box field item.

Tail Text

This value appears just after the form field input element of a text field item.

Field Width

In pixels units, the height of the field item. Default of 140 for text boxes and 200 for text areas.

Please note that File Items do not use pixels but rather the html size="" attribute. This means we want to be careful when changing these values, as inputting a value that makes sense for text boxes, such as 200, will be massive for file items.

Field Height

The height of the field, in pixels.

Apply To All Items - Both Field Width and Field Height have this convenience shortcut that when clicked, will make all other items on that form page the same width or height as the current item. This is very handy when we want to quickly apply the same look to all elements on that page.

TinyMCE Editor
[Text area only]

Select from three TinyMCE preset configurations:
Simple Editor - Provides basic text controls.
Text Heavy - Provides ~13 text editing tools plus a slew of editing control such as undo.
FromBoss Style - Creates the same suit of text editing tools used in the RackForms Editor.

* Please be aware that at this time the Display Field Count validation property has no effect on text areas that use TinyMCE. You can still set a maximum character count, but this value will only be validated at the time of the forms submission via PHP, not JavaScript.

** You can only use 1 style of TinyMCE text editor per form page. The text area that comes first in the form will determine which TinyMCE text editor configuration is used.


When set this field can contain a value and will submit data when the user clicks the submit button, but its value cannot be changed by the user. Please note this value can still be changed by manually editing the field in a JavaScript/Web debugger, so please be sure to not place sensitive information that cannot be changed in this field.

Field Enabled

When Yes the field accepts values and input from the user. When set to No the field ignores user input, and its value is not submitted with the form data.

User Provided Value Populates Field

When Yes the field populates with values set by the user after a page load. When set to No the field never displays values set by the user accross page loads.

While a bit strange sounding at first, "why would we not want to show a value set by the user", this has very  useful benefits for more advanced forms, particularity ones that perform data lookups. Say we have a form where we ask the user to input an invoice number for an inventory lookup system. We  never actually submit the invoice number, we just care about using that field as a lookup. The problem is when we leave the lookup page and come back, this field would now be populated with  the previous query's value. Thus, setting this option so the field doesn't remember the value  can be very useful when we want to keep our UI clean. 

Extra Attribute(s), JS, Event Code, etc

Although similar to a submit button, a button has an html type of 'button', not type=submit, which means when this element is clicked on, your form will not be submitted, but rather you must supply the event to occur.

A common use of this type of element would be to attach a history command such as onclick="history.back()", and then use it on a multi-form page to make navigating back one page easier than using text links.

Add code to your field item by typing it into this box. Code can be JavaScript event code such as:

onclick="alert('Be sure to use Letters only');"

External Library dependent code as in: (Prototype/Scriptaculous example)

onclick="Effect.Fade(this, { duration:.2});"

What's important to note is that the code you create here effects the field element, not the container it sits in. To edit the field container, you need to reference the field name prefixed with 'fb_fld-', as in a text box with an ID of text1 would be referenced like:

Extra Field Style Attributes

This field allows us to define extra style attributes for our form elements such as:


It's important to consider that RackForms also applies style data, traditionally as:

font-size:12px; color:#444444; font-family:inherit; width:200px; height:70px;

In short, font properties and height/width are handled automatically via editor properties. Thus, this field is for specifying extra style attributes not handled by the RackForms UI.

This is especially useful for Bucket items, where any style data we apply will greatly enhance the look of a standard bucket, which by default has only size and position styles applied.

Conditional Processing

Conditional Processing Overview
The conditional processing capabilities of RackForms can be broken into two main categories:

Guided - In this mode we use all fields except the Custom Conditional Field Statement text area. That is to say, we use the RackForms user interface to select one element or wrapper to apply dynamic logic to. This could be considered the "easy" mode, in that we write no code to perform our dynamic logic. We simply tell RackForms the properties of the interaction we want and RackForms does the rest.

Custom Conditional Code - In this mode we use the Event Trigger property say which event calls the code we define in the Custom Conditional Field Statement box. This could be considered the more powerful but advanced mode, in that we write our own dynamic logic.

Of course with power comes flexibility, as in this mode we can apply any type of complex logic we need to get the job done. In particular though this code-centric mode is required if and when we want to apply dynamic logic to more than one field item or wrapper class item (items that have the same Wrapper Class property defined).

To be clear: if we only need to apply dynamic logic to one item or wrapper class we use the guided mode. If we need to have more than one item show or hide, we use the custom code mode.

Important Note
Starting with Build 759 we can use the Guided mode controls to apply conditional logic to items on a different page than the one the affecting form field is on.

Please note however, that this capability does not apply to Custom Conditional Code logic, only guided ones. That is, any custom conditional code we write only applies to items on the same page.

Field Initially Visible?

Determines if the form element is visible when the page first loads. Please note that this logic always resets on page load, that is, if a user goes back one page where an element was previously shown it will be invisible again .

This Form Field...

This field and the next allows us to create a condition on the visibility of the field. We enter the Name/Value of a form field in this box, and in the next, the value we check against. If the value matches, we show the field. Please note this only works as a method to show a field, not hide. That is, we still uncheck the Field initially Visible to hide the field, these options simply allow us to show the field based on a condition from another form field. Please note this logic works across pages.

Has This Value...

The value we check to determine a fields visibility. This must exactly match the value the form field will contain. This field is also dynamic, which means we can use standard RackForms tokens to check against a dynamic value at run-time.

Easy Toggle?

Checking this box means RackForms will automatically handle the logic needed to perform the opposite action you set in Then... and If This Field Is: properties. For example, if you set the action of an item to be 'Show', if the condition needed to make this show action happen is revoked, the opposite action will automatically happen for you. So, if the condition is the text '1' must be set in a text box in order to show a second text field, if this 1 is removed or changed, the second text box will be hidden again.

In general we want to keep this box checked, though if you wanted to force a field to always show after an action then leave it unchecked.

Event Trigger

This is the JavaScript event that will be scanned for and then acted upon if activated. Some events are better than others for the various tasks you have. For example, the onClick event is perfect for Checkboxes, whereas the onKeyUp event is perfect for text boxes where a user needs to enter a specific value. Experiment with these values and have fun!

Caution! You may run into a situation where you build a form that enables the event trigger on a specific field, then remove that field later on without updating the Event Trigger's 'binding' to that element.

If this happens your forms validation will break, along with other potential issues.

The solution is always make sure that when we enable an event trigger for an element, that field exists on the form.


While not always needed, if you want you can add animation using Prototype JS to your events. The upside of this is your forms may have a more professional appearance, the downside is the extra bandwidth needed to send the Prototype JS library over the wire to run the animations. However, if you are already using animation or have included the Prototype JS library for other purposes, this bandwidth cost is obviously negated, so animate away!

If This Field Is:

This is the core property of the Conditional Processing logic. In most cases you will only want to show and hide fields if a specific condition is met, this option allows us to set that condition. As with the Event Trigger property, some options only make sense in the proper context. For example, the top Value Comparison grouping is best served in combination with text and select fields, whereas the Field State options of Checked and Unchecked only make sense for checkboxes.

It is also important to note that RackForms will attempt to cast comparison values set as INT and FLOAT values to their respective native types.

This Value...

When we set the If This Field is property, with the exception of the two Field State checks of Checked and unchecked, we typically want to compare against some value. It is in this text box that we set that comparison value. RackForms will automatically attempt to detect FLOAT and INT values when testing against GREATER THAN and LESS THAN checks.


If the condition set in If This Field Is and This Value... passes, this is the action we will perform. Please note that is Easy Toggle? is enabled, we will automatically perform the opposite when the check fails.

This Field Or...

When we set an event, comparison, and action, the last step is to tell RackForms which fields to act upon. It is in this field and is close relative, This Wrapper Class, that we set this field or fields.

As you build your form RackForms will automatically track the Name/Value properties of the elements on that form page and then present them to you in list format in this field. Thus, all eligible form fields will be displayed in this select item, the one you select will become the field acted upon.

Finally, any elements that are set to hidden on page load are tagged with a [H], which makes it easy in many cases to see which items you may need to work with.

Note that items from other pages will be shown as well, they are grouped with an entry of the page name they below too.

This Wrapper Class

Similar to the This Field Or... property, with the exception that instead of single field we can act upon all elements with the same Wrapper Class attribute. This makes it very easy to show and hide large portions of content with one action, perfect for address fields and the like.

Conditional Field Statement

Although RackForms tires to automate as much of the show/hide process as possible, their will be times when you need to have more complex logic. When this is the case, we can use the simple RackForms API to create custom logic.

The bulk of this logic will be derived from a JavaScript object called fbc. This object is defined in:


This file is exported into the root of all RackForms jobs.

The basic usage of this object will depend on what action you want to perform. Their are 4 methods you need to know about:

hideField, hideWrapper, showField, showWrapper

As shown in the editor, we call these methods as:

fbc.showField(event, 'FieldName', 'animation');

With a simple example to show a text box being:

if(in_value == '1'){
  fbc.showField(event, 'text2'); // animation argument is optional, event and field name is not!

Simple enough--But it is important to understand that at the page code level RackForms creates two distinct but related items.

The first is the event trigger which is placed inline with your form element. Please be aware the event used is not created automatically, you need to select one from the Event Trigger select item.

Thus, if we select the onKeyUp event RackForms will place this code inline with your element:

onkeyup="fb_dyn_text1(event, this.value, this)"

Notice we have three arguments. This is important because the inline method call is directly tied to the second main element RackForms creates for you, which is a script tag with that methods definition.

This method looks like:

function fb_dyn_text1(event, in_value, elt){
  if(value == '1'){
     fbc.showField(event, 'text2');

As you may now see, this method body is the code you create in the Custom Conditional Field Statement text area. The reason why it is wrapped in the method is to that you do not need to worry about creating or gathering the event, in_value, and elt parameters.

Thus, the last bit of knowledge to convey is that these parameters, event, in_value, and elt, can be used in any way you need in your Custom Conditional Code. Most of the time you will only need the in_value parameter for your logic, but please notice you must pass event to the fbc functions no matter what.

Custom Code Hints and Tricks

Place hide field calls at the top of the code section.

One common trick to employ to keep your code block clean is to place all hide calls at the top of your code block. This eliminates the need for most if/else blocks, and means we only need to set conditions to show elements. The reason this works is hiding and showing elements is so fast, that even if an item is shown and will not be hidden by the code, the hide call and subsequent show happens to fast to be perceived.

Be careful with integer values.

Integer and number values in JavaScript can often cause problems, as they may be interpreted as strings, and vice versa. Thus, when working with number values always pass them through isNaN (is not a number), and parseInt/float. For example, the following code will check to make sure k is a number, and is also an int.

var k = 10;

if(!isNaN(k)){ // is this a number?
  if(parseFloat(k) <= 10) { // parse and check value
  } else {

Watch which Event Trigger we use.

Generally speaking, a text box should use blur, a drop down onchange, and radio and checkbox items onclick. Using different events is possible, but can lead to unexpected results.


New in Build 711, we now have a callback that's fired after an animation plays:


We use this callback inline with our Conditional Code block as in:

fbc.animationDone = function(elt){
  // when animation is done, call resize function for iframe

That is, we call fbc.animationDone(elt), then in that function, define the actions to take place.

The elt parameter is the object that called the animation, that is, is the object which reacted to the event.

Please note this event is fired for every animation that plays. Thus, if we've used this in the content of a Wrapper Class with say, 5 elements, this function is called 5 times.

Important RackForms Note: In RackForms 2 the in_value parameter was defined as just value. This caused code conflicts however, and was thus renamed to the present value. If importing any RackForms 2 jobs into RackForms, any custom code will need to be updated to use the new value.

Field Style Properties

Grab This Fields Style Properties
This shortcut button allows us to quickly store and then apply the current fields style properties to other fields.

When we press the button the cursor will turn into a crosshair. To apply the style settings to a new element simply mouse over the field and click.We can leave this mode at any time by pressing the Escape Key.

Element z-index

This seting allows us to set the z-index of most items. This property is reflected in the editor as well, making positioning items much more streamlines than in previous versions.

By default most items, with the exception of calendar fields, have a base index of 1. This means so long as your form fields to not overlap you will not need to set this property. However, some fields, such as images or those with popup's (like the calendar field), benefit from setting a different layering order.

Element Tab Index

This option allows us to set the tab index of the element in question. Care must be taken when we set a value however, as items like the Grid Element contain sub elements, and although a set value will tab to the first element of the Grid, if we have elements with a higher tab index after the Grid we'll immediately tab out of the Grid item.

As a general rule when we build forms the tab index is automatically decided by the browser based on document position. That is, the newest elements we create have a higher tab index. This is different than visual position, as if building a free form page the lowest element on the page may not be the newest created.

Thus, the tab index control helps us smooth out visual position and actual tab order by manually being able to set it.

Sometimes a better method however, is to switch a free form layout to sortable and position elements from top to bottom in the order we add them to form. Then we can switch back to free form and while the positions of our elements has been retained, the tab order will now reflect the proper document ordering.

That said, perhaps the most common place to set tab order manually is when we have a Layout Bucket or Survey. This is becuase In some cases a layout buckets items will be added after other sortable items have been added, which means a tab out of a bucket item places us out of the bucket and into the most recent item added.

Text Color

Click into the box to load the color selector. Drag your cursor over the saturation in the main box to select the color intensity, or drag the hue slider to change color.

Input Text Color

Set the input fields color.

Label Font Size (px/pt)

Type a number in this box to change the font size of the element. By default if no unit is specified (the field is just a number) RackForms will use px. We can use pt however, and this unit-type works much better with PDF output in some cases.

Label Font Weight

This option lets us set the font weight of the forms field label or main text block.

Option Font Size (px/pt)

Used only for Radio and Checkbox items, defined the items label font size.

Option Font Weight

Used only for Radio and Checkbox items, sets the weight of the individual radio or checkbox items label.

Field Spans Both Columns In Table Layout

New to build 704, when enabled this option lets the form element in question span both columns in a tablemode layout.

Notes: As of now the only fields to use this option are Section Text, Body Copy, Images, and Separators.

Field Width

This option sets the width of the Section Text or Body Copy elements. Please note this option is not used for any other elements.

Field Height

This option sets the height of the Section Text or Body Copy elements. Please note this option is not used for any other elements.

Border Radius

This CSS 3 feature applies rounded borders to the item. As this is CSS 3 only, IE versions lower than 9 will not be able to display them, though any recent version of Firefox, Chrome and Safari all will.

Item Text Alignment

This option sets the text alignment of the Section Text or Body Copy elements.

Enable Banner Mode

This mode is used to create banner like entities on our form page -- that is, elements that span the entire page width regardless of Page Padding settings. By banner we broadly mean a text display element that has a background color set and any type of content within.

It's key to note that this feature is only useful if we've got a full page form that uses page and form background colors. If we do not have this type of layout, it's almost always best to ignore this feature and just use the standard form padding controls.

If we do have a form that uses background colors, Banner Mode is needed because RackForms applies page padding to the form container. We can control this padding amount via the Form Style Properties > Page Padding control.

In theory we could set this value to 0 and then all text elements, if set to the proper width, would span the entire length of the form page. The issue is if we did all form elements will end up touching the edge of the form page, which of course includes all form elements.

As this is rarely what we want Banner Mode was added to selectively say "this element should span the entire form page, but leave everything else alone"

The end result from a technical standpoint is RackForms, when building the form, takes the page width and adds the page padding we've defined and makes that the new width of the element. It then take the page padding the applies that as negative margin to the element based on the Banner Mode Position setting. Thus, from a presentation standpoint the element now spans the width of the page, but our global page padding setting still holds for all other elements.

In light of this then it's important to note that enabling Banner Mode means the value we set for Field Width is ignored.

Banner Mode Position

This control, along with Enable Banner Mode, tells RackForms where our banner is on the page. If we set this to Top Banner RackForms will apply a negative left and negative top margin equal to the Page Padding value. The field height stays the same. This is of course used for banners we place at the very top of the page.

If we select Middle Banner we apply a negative left margin but not a vertical one. This means the element will span the entire page width, but not affect the items above and below it.

Finally, if we select Bottom Banner RackForms will change the field height of the element to be +21 pixels added to the page padding * 2 + half of the page's Sortable Item Bottom Margin value. In short, the field will get grow by about 69 pixels so that it touches the very bottom of the page.

All of these modes work best and are in fact designed for standard sortable page mode.

The key to this setting is to know that having a page-spanning banner in the middle of the page using the Top Banner setting will result in a banner that "smashes" into the field above it. Thus, we must make sure we set this property properly!

Banner Mode Hints & Limitations

Banner mode works well if we have just a top banner, or a top and bottom banner, but not if we have a bottom banner only. In short then, try and design your forms to not depend on a bottom banner only.

That said, this issue only becomes apparent if we've also enabled Apply Box Shadow. If we haven't we needn't worry about this issue.

Label Position (Form fields only)
Sets the position of the form field label, though the implementation depends on the form field type. Text items switch between being on top and inline, radio and checkbox items the same, only multiple items line up in a row as opposed to vertically. This is how we create survey type forms, for example.

Please note though that when using Inline, by default RackForms uses 100% width for all radio and checkbox items. This means a series of say, 5 radio options should show nicely on a sortable page. However, their will be times when we want to display radio items in columns, such as when we have many options, or when in free form layout mode.

If this is the case, we can always set a specific column width in pixels under: Select Item Options > Column Width

Input Inherits Font Size and Family

This field lets you set the input elements input font and size to match the label field.


The calendar field items lets your users select dates from a convenient display item as opposed to having to type them in manually. Select from 1 of 6 presets:

Single Field American
Creates a single text field with a date selector. Users can enter a date in any format they wish, or click the 'Date' icon to select a date from a calendar.

Multi-Field-Numeric-American [TS, DT] * see note below
Creates three text fields that populate with numeric data. That is, dates are entered in the format of: 12/22/1977. Users can click the Date icon to choose a date from the calendar.

Creates three text fields, the first two are drop-down menus, the third for year, is a text field. Users can click the Date icon to choose a date from the calendar.

Single Field European
Creates a single text field with a date selector. Users can enter a date in any format they wish, or click the 'Date' icon to select a date from a calendar. Dates are arranged as dd/mm/yyyy

Multi-Field-Numeric-European [TS, DT] * see note below
Creates three text fields that populate with numeric data. That is, dates are entered in the format of: 22/12/1977. Users can click the Date icon to choose a date from the calendar.

Creates three text fields, the first two are drop-down menus, the third for year, is a text field. Users can click the Date icon to choose a date from the calendar. Dates are entered as dd/mm/yyyy.

Pipe | Delimited Calendar Argument List

The RackForms calendar can be customized with arguments that change the way it behaves. The default calendar loads one such argument to apply a basic stylesheet.

We have many other arguments that can be used, for example:

addDisabledDates(null, dateFormat(addDays(new Date(), 5), "mmmm dd, yyyy"));

This will set "only 5 days in the future" as valid items for selection.

IMPORTANT: Note each argument must be separated with a pipe (|) to create a pipe delimited list. For example:


Another, more simple and common option is to show handy date navigation helpers:


This will create a set of drop-downs for month and year selection. If you do this, you will notice a shortcoming, in that the year range is rather limited. Thus, we could add a second argument:


Which will create a year list that span +/- 20 years. The entire argument list would then be:


Finally, it's key to note that by default RackForms will always apply the default style argument of:


This is not a required value, but without it our calendars will be unstyled. Thus, please note that in each example above we would add the setCssPrefix('FB-CAL'); value if not already present in the example text.

Calendar Callback Code

It will often be necessary to perform some type of logic after a date has been selected. For example, we may want to perform conditional logic after we've set a date that's a specific number of days in the future.

To handle these tasks we use the Calendar Callback Code section. This block allows us to write code that has direct access to the date values selected by the user from the calendar popup.

RackForms supplies several values your code can use:

d - The raw day value, not 0 padded.

m - The raw month value (1-12), not zero padded.

y - The year as yyyy

date - The native JavaScript Date object for the selected time.

s_ts - The timestamp in seconds for the selected date.

c_ts - The timestamp in seconds for the current time.

console.log("Year:", y, "Month:", m, "Day:", d, "Date:", date, "SelTS:", s_ts, "CurrTS", c_ts);

Callback Code Example

Lets assume we need to perform a conditional action if the date value selected is more than 5 days in the future. To handle this we'll first need to set a timestamp value of todays date plus 5 days.

The easiest way to do this is to use the supplied addDays() function, which takes the format of:

addDays(new Date(), 5)

To make our calculation simple, we'll wrap this in a call that creates a timestamp in seconds to match our selected timestamp value:

var future_ts = Math.round(addDays(new Date(), 5).getTime()/1000);

As s_ts contains the timestamp for the date our user selected from the calendar, we're ready to go. All we need to do is subtract the selected date from the future date. As our condition is only valid if the date is more than 5 days in the future, a negative value means this criteria has been met. We can then perform a simple if else block to show and hide our conditional field. The full block of code is below:

var future_ts =  Math.round(addDays(new Date(), 5).getTime()/1000);

var diff = future_ts - s_ts;

if(diff < 0) {


} else {



* Accessing TIMESTAMP and DATETIME Values

You may notice the [TS, DT] next to some calendar type names.

These indicators mean we can use these fields in a SQL+ module to access timestamp and valid MySQL/MSSQL DATETIME data. To get these values, we simply use the Name/Value of the calendar field id, and add to it:

_ts for a UNIX timestamp value (not to be confused with a valid MySQL TIMESTAMP value, however!)
_dt for a MySQL/MSSQL DATETIME value.

For example, if we had a calendar field with the Name/Value of date and a MySQL DATETIME column called datetime_value, we could use this SQL+ statement:

INSERT INTO fb_demo(name, datetime_value) VALUES (?,?)

Along with this variable list:

name, date_dt

In our database we would have a valid DATETIME value inserted into the datetime_value column..

As noted above, it's very important to note that the _ts value is not a valid data value for MySQL TIMESTAMP columns. To populate these columns we must use the _dt value. The rule is:

To populate a DATETIME or TIMESTMAP field in SQL we always use the _dt token shortcut.

Why do we have the _ts tokens then? Sometimes it's useful to have timestamp values for other purposes, such as counting the difference between two times in seconds, and so on.

Of course as this is a simple value it can be used in VARCHAR columns, for example, if a legacy table doesn't have and can't be updated to include a DATETIME field.

You can read more about the MySQL TIMESTAMP type here, and MySQL DATETIME type here.

Creating TIMESTMP and DATETIME From Other Fields (including single-field-calendar items)
What about the other fields? RackForms only supports automatic creation of TIMESTAMP and DATETIME data for a few calendar fields, simply because with other fields we cannot be guaranteed to get valid date values. This doesn't mean however, that we are in the dark. Creating and manipulating dates in PHP is quite simple so long as we accept that we may have some users whose data may not match exactly what we want.

To create such dates from other fields, we need only insert a sample code block shipped with every copy of RackForms 2 Build 653 and later called: Make Timestamps From Calendar Input, which can be found as a link just under the PHP Top Code area.

When we insert this code block we will need to fill in the name of our form field the date data will be coming from. With this done, the code block will take this fields run-time value and attempt to explode the data to get our 3 components, day, month, and year. It then attempts to create a timestamp using mktime(), as well as a valid SQL DATETIME field using: date('Y-m-d H:i:s', $timestamp);

If all goes well, we will have two local PHP variables, $timestamp and $datetime, with $datetime holding a valid SQL value for a DATETIME or TIMESTAMP column.

Finally, their is a sample job at: Load Sample Job > SQL+ > mysql-timestamps.xml

Validating Calendar Fields

When we need to validate a calendar field we should take a few important items into consideration.

First, only "3 field" calendar items that are set to "required" will be put through a validation routine that checks for a valid date value. Single field items (such as Calendar Type > Single Field American), are not validated with the exception of having some form of input value.

Thus, if we need to ensure a valid date value, always make the field required, and always choose a three-field variant of the date picker.

For those items that are required, the validation routine will do its best to ensure the value passed is indeed a valid date value, though as with any complex input its always best to filter on the output side as well. That is, when we pull the data back out we check the value again to make sure its valid.

if we want more front end control over a calendar field,

So many features, So little time