<?xml version="1.0" encoding="UTF-8"?>
<helpdocument version="1.0">
	
<!--***********************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 ***********************************************************-->


 
	
<meta>
<topic id="textshared0201170000xml" indexer="include">
<title id="tit" xml-lang="en-US">Form Controls</title>
<filename>/text/shared/02/01170000.xhp</filename>
</topic>
</meta>
<body>
<section id="formularfunktionen">
<bookmark xml-lang="en-US" branch="index" id="bm_id3154142"><bookmark_value>form controls;toolbars</bookmark_value>
<bookmark_value>inserting; form fields</bookmark_value>
<bookmark_value>form fields</bookmark_value>
<bookmark_value>command button creation</bookmark_value>
<bookmark_value>buttons; form functions</bookmark_value>
<bookmark_value>controls; inserting</bookmark_value>
<bookmark_value>push buttons;creating</bookmark_value>
<bookmark_value>radio button creation</bookmark_value>
<bookmark_value>check box creation</bookmark_value>
<bookmark_value>labels; form functions</bookmark_value>
<bookmark_value>fixed text; form functions</bookmark_value>
<bookmark_value>text boxes;form functions</bookmark_value>
<bookmark_value>list box creation</bookmark_value>
<bookmark_value>picklist creation</bookmark_value>
<bookmark_value>drop-down lists in form functions</bookmark_value>
<bookmark_value>combo box creation</bookmark_value>
<bookmark_value>selecting;controls</bookmark_value>
<bookmark_value>controls; select mode</bookmark_value>
</bookmark><comment>MW deleted "option field creation", changed "option button" to "push button" and "selections;" to "selecting;"</comment>
<bookmark xml-lang="en-US" branch="hid/.uno:Config" id="bm_id4029443" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:Config" id="bm_id3153252" localize="false"/>
<paragraph role="heading" id="hd_id3154142" xml-lang="en-US" level="1" l10n="CHG" oldref="1"><link href="text/shared/02/01170000.xhp" name="Form Controls">Form Controls</link></paragraph>
<paragraph role="paragraph" id="par_id3151378" xml-lang="en-US" l10n="CHG" oldref="2"><variable id="formulartext"><ahelp hid=".uno:Config">The Form Controls toolbar contains tools that you need to create an interactive form.</ahelp>
</variable> You can use the toolbar to add controls to a form in a text, spreadsheet, presentation, or HTML document, for example a button that runs a macro.</paragraph>
</section>
<section id="howtoget">
<paragraph role="paragraph" id="par_id1027200809391346" xml-lang="en-US" l10n="NEW">Choose <item type="menuitem">View - Toolbars - Form Controls</item>.</paragraph>
<paragraph role="paragraph" id="par_id3147336" xml-lang="en-US" l10n="CHG" oldref="68">Icon on the <emph>Insert</emph> toolbar (you may need to enable this initially invisible icon):</paragraph>
<section id="syformular">
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3155341" xml-lang="en-US" l10n="E">
<image id="img_id3150943" src="res/commandimagelist/sc_config.png" width="0.1665in" height="0.1665in"><alt id="alt_id3150943" xml-lang="en-US">Icon</alt></image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3149670" xml-lang="en-US" l10n="CHG" oldref="3">Form Controls</paragraph>
</tablecell>
</tablerow>
</table>
</section>
</section>
<paragraph role="note" id="par_idN10B21" xml-lang="en-US" l10n="NEW"><link href="text/shared/guide/xforms.xhp">XML Form documents</link> (XForms) use the same controls.</paragraph>
<paragraph role="paragraph" id="par_id3152771" xml-lang="en-US" l10n="CHG" oldref="45">To create a form, open a document and use the Form Controls toolbar to add and define the form controls. If you want, you can also link the form to a database, so that you can use the controls to manipulate a database.</paragraph>
<paragraph role="paragraph" id="par_id3150791" xml-lang="en-US" l10n="U" oldref="46">When you create a form in an HTML document, you can use the form to send data over the Internet.</paragraph>
<paragraph role="note" id="par_id3145171" xml-lang="en-US" l10n="U" oldref="47">%PRODUCTNAME only exports the form properties that are supported by the HTML version that you export to. To specify the HTML version, choose <emph><switchinline select="sys"><caseinline select="MAC">%PRODUCTNAME - Preferences</caseinline><defaultinline>Tools - Options</defaultinline></switchinline> - Load/Save - HTML Compatibility</emph>.</paragraph>
<paragraph role="heading" id="par_idN10C39" xml-lang="en-US" level="2" l10n="NEW">To add a control to a document</paragraph>
<list type="ordered">
<listitem>
<paragraph role="paragraph" id="par_id3154918" xml-lang="en-US" l10n="CHG" oldref="4">On the Form Controls toolbar, click the icon of the control that you want to add.</paragraph>
</listitem>
<listitem>
<paragraph role="paragraph" id="par_idN10C4D" xml-lang="en-US" l10n="NEW">In the document, drag to create the control. </paragraph>
<paragraph role="paragraph" id="par_idN10C50" xml-lang="en-US" l10n="NEW">To create a square control field, hold down the Shift key while you drag.</paragraph>
</listitem>
</list>
<paragraph role="tip" id="par_id3154127" xml-lang="en-US" l10n="U" oldref="78">To add a field from the field list of a table or query to a form, drag a cell into the form. In a text document, you can also drag a column header to add a field to a form. To include a label for the field, hold down the <switchinline select="sys"><caseinline select="MAC">Command
</caseinline><defaultinline>Ctrl</defaultinline></switchinline>+Shift key down when you drag a column head.</paragraph>
<paragraph role="heading" id="par_idN10C87" xml-lang="en-US" level="2" l10n="NEW">Modifying a Control</paragraph>
<list type="ordered">
<listitem>
<paragraph role="paragraph" id="par_id3148645" xml-lang="en-US" l10n="U" oldref="5">Right-click the control and choose <emph>Control</emph>. A dialog opens where you can define the properties of the control.</paragraph>
</listitem>
<listitem>
<paragraph role="paragraph" id="par_id3153363" xml-lang="en-US" l10n="U" oldref="163">To specify a accelerator key for a control, add a tilde (~) in front of the character in the label for the control.</paragraph>
</listitem>
<listitem>
<paragraph role="paragraph" id="par_id3152792" xml-lang="en-US" l10n="U" oldref="135">You can drag and drop controls from one document to another document. You can also copy and paste controls between documents. When you insert a control from another document, $[officename] analyzes the data source, content type, and content properties of the control so that the control fits the logical structure in the target document. For example, a control that displays contents from an address book continues to display the same contents after you copy the control to a different document. You can view these properties on the <emph>Data</emph> tab page of the <emph>Form properties</emph> dialog. </paragraph>
</listitem>
</list>
<section id="Section3">
<paragraph role="heading" id="hd_id3154411" xml-lang="en-US" level="2" l10n="CHG" oldref="24">Select<comment>controls and design bars</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3156106" xml-lang="en-US" l10n="E">
<image id="img_id3153516" src="res/commandimagelist/sc_drawselect.png" width="0.2228in" height="0.2228in"><alt id="alt_id3153516" xml-lang="en-US">Icon</alt></image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3150470" xml-lang="en-US" l10n="U" oldref="25">This icon switches the mouse pointer to the select mode, or deactivates this mode. The select mode is used to select the controls of the current form.</paragraph>
</tablecell>
</tablerow>
</table>
<embed href="text/shared/02/01170500.xhp#designmodus"/>
<embed href="text/shared/00/00040501.xhp#sydesign"/>
<embed href="text/shared/02/01170100.xhp#control"/>
<embed href="text/shared/00/00040501.xhp#sycontroleigenschaften"/>
<embed href="text/shared/02/01170200.xhp#formular"/>
<embed href="text/shared/00/00040501.xhp#syformulareigenschaften"/>
</section>
<section id="Section19">
<bookmark xml-lang="en-US" branch="hid/.uno:Checkbox" id="bm_id8176164" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:CheckBox" id="bm_id3150751" localize="false"/>
<paragraph role="heading" id="hd_id3146914" xml-lang="en-US" level="2" l10n="U" oldref="10">Check Box<comment>controls bar</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3148483" xml-lang="en-US" l10n="E">
<image id="img_id3156380" src="res/commandimagelist/sc_checkbox.png" width="0.2228in" height="0.2228in"><alt id="alt_id3156380" xml-lang="en-US">Icon</alt></image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3153927" xml-lang="en-US" l10n="U" oldref="11"><ahelp hid=".uno:CheckBox">Creates a check box.</ahelp> Check boxes allow you to activate or deactivate a function in a form.</paragraph>
</tablecell>
</tablerow>
</table>
</section>
<section id="Section16">
<bookmark xml-lang="en-US" branch="hid/.uno:Edit" id="bm_id7355178" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:Edit" id="bm_id3153785" localize="false"/>
<paragraph role="heading" id="hd_id3153794" xml-lang="en-US" level="2" l10n="U" oldref="16">Text Box<comment>controls bar</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3163665" xml-lang="en-US" l10n="E">
<image id="img_id3153266" src="res/commandimagelist/sc_edit.png" width="0.2228in" height="0.2228in"><alt id="alt_id3153266" xml-lang="en-US">Icon</alt></image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3158444" xml-lang="en-US" l10n="U" oldref="17"><ahelp hid=".uno:Edit">Creates a text box.</ahelp> Text boxes are fields in which the user can enter text. In a form, text boxes display data or allow for new data input.</paragraph>
</tablecell>
</tablerow>
</table>
</section>
<section id="Section7">
<bookmark xml-lang="en-US" branch="hid/.uno:FormattedField" id="bm_id6606960" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:FormattedField" id="bm_id3155526" localize="false"/>
<paragraph role="heading" id="hd_id3151218" xml-lang="en-US" level="2" l10n="U" oldref="124">Formatted Field<comment>controls bar</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3154836" xml-lang="en-US" l10n="E">
<image id="img_id3143277" src="res/commandimagelist/sc_formattedfield.png" width="0.2228in" height="0.2228in"><alt id="alt_id3143277" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3147547" xml-lang="en-US" l10n="U" oldref="125"><ahelp hid=".uno:FormattedField">Creates a formatted field.</ahelp> A formatted field is a text box in which you can define how the inputs and outputs are formatted, and which limiting values apply.</paragraph>
</tablecell>
</tablerow>
</table>

<paragraph role="paragraph" id="par_id3155346" xml-lang="en-US" l10n="U" oldref="126">A formatted field has <link href="text/shared/02/01170002.xhp" name="special control properties">special control properties</link> (choose <emph>Format - Control</emph>).</paragraph>
</section>
<section id="Section21">
<bookmark xml-lang="en-US" branch="hid/.uno:Pushbutton" id="bm_id6486131" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:Pushbutton" id="bm_id3153878" localize="false"/>
<paragraph role="heading" id="hd_id3148774" xml-lang="en-US" level="2" l10n="U" oldref="6">Push Button<comment>controls bar</comment></paragraph>
<table id="tbl_id3154501">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3145801" xml-lang="en-US" l10n="E">
<image id="img_id3151073" src="res/commandimagelist/sc_insertpushbutton.png" width="0.2228in" height="0.2228in"><alt id="alt_id3151073" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3147046" xml-lang="en-US" l10n="U" oldref="7"><ahelp hid=".uno:Pushbutton">Creates a push button.</ahelp> This function can be used to execute a command for a defined event, such as a mouse click.</paragraph>
<paragraph role="paragraph" id="par_id3154731" xml-lang="en-US" l10n="U" oldref="138">You can apply text and graphics to these buttons.</paragraph>
</tablecell>
</tablerow>
</table>

</section>
<section id="Section20">
<bookmark xml-lang="en-US" branch="hid/.uno:Radiobutton" id="bm_id3862451" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:RadioButton" id="bm_id3153418" localize="false"/>
<paragraph role="heading" id="hd_id3157844" xml-lang="en-US" level="2" l10n="U" oldref="8">Option Button<comment>controls bar</comment></paragraph>
<table id="tbl_id3151318">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3152971" xml-lang="en-US" l10n="E">
<image id="img_id3152999" src="res/commandimagelist/sc_radiobutton.png" width="0.2228in" height="0.2228in"><alt id="alt_id3152999" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3149123" xml-lang="en-US" l10n="U" oldref="9"><ahelp hid=".uno:RadioButton">Creates an option button.</ahelp> Option buttons enable the user to choose one of several options. Option buttons with the same functionality are given the same name (<link href="text/shared/02/01170101.xhp" name="Name"><emph>Name</emph></link>
<emph>property</emph>). Normally, they are given a <link href="text/shared/02/01170000.xhp" name="group box">group box</link>.</paragraph>
</tablecell>
</tablerow>
</table>

</section>
<section id="Section15">
<bookmark xml-lang="en-US" branch="hid/.uno:ListBox" id="bm_id7238352" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:ListBox" id="bm_id3154475" localize="false"/>
<paragraph role="heading" id="hd_id3156064" xml-lang="en-US" level="2" l10n="U" oldref="18">List Box<comment>controls bar</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3154326" xml-lang="en-US" l10n="E">
<image id="img_id3154135" src="res/commandimagelist/sc_listbox.png" width="0.2228in" height="0.2228in"><alt id="alt_id3154135" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3166428" xml-lang="en-US" l10n="U" oldref="19"><ahelp hid=".uno:ListBox">Creates a list box.</ahelp> A list box lets users select an entry from a list. If the form is linked to a database and the database connection is active, the<link href="text/shared/02/01170900.xhp" name="List Box Wizard"><emph>List Box Wizard</emph></link> will automatically appear after the list box is inserted in the document. This wizard helps you create the list box.</paragraph>
</tablecell>
</tablerow>
</table>

</section>
<section id="Section14">
<bookmark xml-lang="en-US" branch="hid/.uno:Combobox" id="bm_id5504530" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:ComboBox" id="bm_id3156169" localize="false"/>
<paragraph role="heading" id="hd_id3147171" xml-lang="en-US" level="2" l10n="U" oldref="20">Combo Box<comment>controls bar</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3149981" xml-lang="en-US" l10n="E">
<image id="img_id3148817" src="res/commandimagelist/sc_combobox.png" width="0.2228in" height="0.2228in"><alt id="alt_id3148817" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3149407" xml-lang="en-US" l10n="U" oldref="21"><ahelp hid=".uno:ComboBox">Creates a combo box.</ahelp> A combo box is a single-line list box with a drop-down list from which users choose an option. You can assign the "read-only" property to the combo box so that users cannot enter other entries than those found in the list. If the form is bound to a database and the database connection is active, the <link href="text/shared/02/01170900.xhp" name="Combo Box Wizard"><emph>Combo Box Wizard</emph></link> will automatically appear after you insert the combo box in the document.</paragraph>
</tablecell>
</tablerow>
</table>

</section>
<section id="Section18">
<bookmark xml-lang="en-US" branch="hid/.uno:Label" id="bm_id7047484" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:Label" id="bm_id3154255" localize="false"/>
<paragraph role="heading" id="hd_id3145618" xml-lang="en-US" level="2" l10n="U" oldref="12">Label Field<comment>controls bar</comment></paragraph>
<table id="tbl_id3156712">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3145295" xml-lang="en-US" l10n="E">
<image id="img_id3151017" src="res/commandimagelist/sc_insertfixedtext.png" width="0.2228in" height="0.2228in"><alt id="alt_id3151017" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3148534" xml-lang="en-US" l10n="U" oldref="13"><ahelp hid=".uno:Label">Creates a field for displaying text.</ahelp> These labels are only for displaying predefined text. Entries cannot be made in these fields.</paragraph>
</tablecell>
</tablerow>
</table>

</section>
<bookmark xml-lang="en-US" branch="hid/.uno:MoreControls" id="bm_id1433643" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:MoreControls" id="bm_id4851832" localize="false"/>
<paragraph role="heading" id="par_idN10CC6" xml-lang="en-US" level="2" l10n="NEW">More Controls<comment>Controls bar</comment></paragraph>
<paragraph role="paragraph" id="par_idN10CDC" xml-lang="en-US" l10n="CHG"><ahelp hid=".">Opens the <link href="text/shared/02/more_controls.xhp"><emph>More Controls</emph></link> toolbar.</ahelp></paragraph>
<bookmark xml-lang="en-US" branch="hid/.uno:FormDesignTools" id="bm_id6078501" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:FormDesignTools" id="bm_id3258766" localize="false"/>
<paragraph role="heading" id="par_idN10CF7" xml-lang="en-US" level="2" l10n="NEW">Form Design<comment>Controls bar</comment></paragraph>
<paragraph role="paragraph" id="par_idN10D0D" xml-lang="en-US" l10n="CHG"><ahelp hid=".">Opens the <link href="text/shared/main0226.xhp"><emph>Form Design</emph></link> toolbar.</ahelp></paragraph>
<section id="Section25">
<paragraph role="heading" id="par_idN11B57" xml-lang="en-US" level="2" l10n="NEW">Wizards On/Off<comment>Controls bar</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_idN11B65" xml-lang="en-US" l10n="NEW">
<image id="img_id6128727" src="res/commandimagelist/sc_usewizards.png" width="0.2228in" height="0.2228in"><alt id="alt_id6128727" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_idN11B76" xml-lang="en-US" l10n="CHG">Turns on and turns off the automatic form controls wizards.</paragraph>
<paragraph role="paragraph" id="par_id6403088" xml-lang="en-US" l10n="NEW">These wizards help you to enter the properties of list boxes, table controls, and other controls.</paragraph>
</tablecell>
</tablerow>
</table>

</section>
<paragraph role="heading" id="hd_id3149436" xml-lang="en-US" level="2" l10n="U" oldref="134"><link href="text/shared/02/01170001.xhp" name="Context Menu Commands">Context Menu Commands</link></paragraph><comment>end of visible part of FORM CONTROLS file</comment>
<switch select="sys">
<case select="HIDE_HERE"><comment>now the MORE CONTROLS</comment>
<section id="more_controls">
<section id="Section22">
<bookmark xml-lang="en-US" branch="hid/.uno:Spinbutton" id="bm_id8342120" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:SpinButton" id="bm_id5568102" localize="false"/>
<paragraph role="heading" id="par_idN11A56" xml-lang="en-US" level="2" l10n="NEW">Spin Button<comment>more controls bar</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_idN11A64" xml-lang="en-US" l10n="NEW">
<image id="img_id7816400" src="res/commandimagelist/sc_spinbutton.png" width="0.2228in" height="0.2228in"><alt id="alt_id7816400" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_idN11A75" xml-lang="en-US" l10n="NEW"><ahelp hid=".uno:SpinButton">Creates a spin button.</ahelp></paragraph>
</tablecell>
</tablerow>
</table>

<paragraph role="paragraph" id="par_id710776" xml-lang="en-US" l10n="NEW">If you add a spin button to a Calc spreadsheet, you can use the Data tab page to create a two-way link between the spin button and a cell. As a result, when you change the contents of a cell, the contents of the spin button are updated. Conversely, if you change the value of the spin button, the contents of the cell are updated.<comment>UFI: see spec doc spinbutton_form_control.sxw</comment></paragraph>
</section>
<section id="Section23">
<bookmark xml-lang="en-US" branch="hid/.uno:ScrollBar" id="bm_id633802" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:ScrollBar" id="bm_id8119449" localize="false"/>
<paragraph role="heading" id="par_idN11ABC" xml-lang="en-US" level="2" l10n="NEW">Scrollbar<comment>more controls bar</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_idN11ACA" xml-lang="en-US" l10n="NEW">
<image id="img_id8203985" src="res/commandimagelist/sc_scrollbar.png" width="0.2228in" height="0.2228in"><alt id="alt_id8203985" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_idN11ADB" xml-lang="en-US" l10n="NEW"><ahelp hid=".uno:ScrollBar">Creates a scrollbar.</ahelp></paragraph>
</tablecell>
</tablerow>
</table>

<paragraph role="paragraph" id="par_idN11CA3" xml-lang="en-US" l10n="NEW">You can specify the following properties for a scrollbar:</paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="tablehead" id="par_idN11CDA" xml-lang="en-US" l10n="NEW">UI name</paragraph>
</tablecell>
<tablecell>
<paragraph role="tablehead" id="par_idN11CE0" xml-lang="en-US" l10n="NEW">Semantics</paragraph>
</tablecell>
</tablerow>
<tablerow>
<tablecell>
<paragraph role="tablecontent" id="par_idN11CE7" xml-lang="en-US" l10n="NEW">Scroll value min</paragraph>
</tablecell>
<tablecell>
<paragraph role="tablecontent" id="par_idN11CED" xml-lang="en-US" l10n="NEW">Specifies the minimum height or the minimum width of a scrollbar.</paragraph>
</tablecell>
</tablerow>
<tablerow>
<tablecell>
<paragraph role="tablecontent" id="par_idN11CF4" xml-lang="en-US" l10n="NEW">Scroll value max</paragraph>
</tablecell>
<tablecell>
<paragraph role="tablecontent" id="par_idN11CFA" xml-lang="en-US" l10n="NEW">Specifies the maximum height or the maximum width of a scrollbar.</paragraph>
</tablecell>
</tablerow>
<tablerow>
<tablecell>
<paragraph role="tablecontent" id="par_idN11D01" xml-lang="en-US" l10n="NEW">Default scroll value</paragraph>
</tablecell>
<tablecell>
<paragraph role="tablecontent" id="par_idN11D07" xml-lang="en-US" l10n="CHG">Specifies the default value of a scrollbar, used when the form is reset.</paragraph>
</tablecell>
</tablerow>
<tablerow>
<tablecell>
<paragraph role="tablecontent" id="par_idN11D0E" xml-lang="en-US" l10n="NEW">Orientation</paragraph>
</tablecell>
<tablecell>
<paragraph role="tablecontent" id="par_idN11D14" xml-lang="en-US" l10n="NEW">Specifies the orientation of a scrollbar, that is, horizontal or vertical.</paragraph>
</tablecell>
</tablerow>
<tablerow>
<tablecell>
<paragraph role="tablecontent" id="par_idN11D1B" xml-lang="en-US" l10n="CHG">Small change</paragraph>
</tablecell>
<tablecell>
<paragraph role="tablecontent" id="par_idN11D21" xml-lang="en-US" l10n="NEW">Specifies the minimum amount by which you can scroll a scrollbar, for example, by clicking an arrow.</paragraph>
</tablecell>
</tablerow>
<tablerow>
<tablecell>
<paragraph role="tablecontent" id="par_idN11D28" xml-lang="en-US" l10n="CHG">Large change</paragraph>
</tablecell>
<tablecell>
<paragraph role="tablecontent" id="par_idN11D2E" xml-lang="en-US" l10n="NEW">Specifies the amount that a large step scrolls a scrollbar, for example, when you click between the scrollbar thumb and a scrollbar arrow.</paragraph>
</tablecell>
</tablerow>
<tablerow>
<tablecell>
<paragraph role="tablecontent" id="par_idN11D35" xml-lang="en-US" l10n="NEW">Delay</paragraph>
</tablecell>
<tablecell>
<paragraph role="tablecontent" id="par_idN11D3B" xml-lang="en-US" l10n="NEW">Specifies the delay in milliseconds between scrollbar trigger events. For example, the delay that occurs when you click an arrow button on the scrollbar and hold down the mouse button.</paragraph>
</tablecell>
</tablerow>
<tablerow>
<tablecell>
<paragraph role="tablecontent" id="par_idN11D42" xml-lang="en-US" l10n="NEW">Symbol color</paragraph>
</tablecell>
<tablecell>
<paragraph role="tablecontent" id="par_idN11D48" xml-lang="en-US" l10n="NEW">Specifies the color of the arrows on the scrollbar.</paragraph>
</tablecell>
</tablerow>
<tablerow>
<tablecell>
<paragraph role="tablecontent" id="par_idN11D4F" xml-lang="en-US" l10n="NEW">Visible Size</paragraph>
</tablecell>
<tablecell>
<paragraph role="tablecontent" id="par_idN11D55" xml-lang="en-US" l10n="NEW">Specifies the size of the scrollbar thumb in "value units". For example, a value of ("Scroll value max." minus "Scroll value min.") / 2 results in a scrollbar thumb that occupies half of the scrollbar.</paragraph>
<paragraph role="tablecontent" id="par_idN11D58" xml-lang="en-US" l10n="NEW">To make the width of the scrollbar equal to the height of the scrollbar, set the Visible Size to zero.</paragraph>
</tablecell>
</tablerow>
</table>

<paragraph role="paragraph" id="par_idN11D63" xml-lang="en-US" l10n="NEW">In a Calc spreadsheet, you can use the Data tab page to create a two-way link between a scrollbar and a cell.<comment>UFI: see spec doc scrollbar_form_control.sxw</comment></paragraph>
</section>
<section id="Section13">
<bookmark xml-lang="en-US" branch="hid/.uno:Imagebutton" id="bm_id2102401" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:Imagebutton" id="bm_id3151373" localize="false"/>
<paragraph role="heading" id="hd_id3153316" xml-lang="en-US" level="2" l10n="U" oldref="22">Image Button<comment>more controls bar</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3159622" xml-lang="en-US" l10n="E">
<image id="img_id3154378" src="res/commandimagelist/sc_imagebutton.png" width="0.2228in" height="0.2228in"><alt id="alt_id3154378" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3148601" xml-lang="en-US" l10n="U" oldref="23"><ahelp hid=".uno:Imagebutton">Creates a button displayed as an image.</ahelp> Aside from the graphic representation, an image button has the same properties as a "normal" button.</paragraph>
</tablecell>
</tablerow>
</table>

</section>
<section id="Section12">
<bookmark xml-lang="en-US" branch="hid/.uno:ImageControl" id="bm_id7383386" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:ImageControl" id="bm_id3150947" localize="false"/>
<paragraph role="heading" id="hd_id3159171" xml-lang="en-US" level="2" l10n="U" oldref="49">Image Control<comment>more controls bar</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3155869" xml-lang="en-US" l10n="E">
<image id="img_id3152381" src="res/commandimagelist/sc_objectcatalog.png" width="0.2228in" height="0.2228in"><alt id="alt_id3152381" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3149596" xml-lang="en-US" l10n="U" oldref="50"><ahelp hid=".uno:ImageControl">Creates an image control. It can only be used to add images from a database.</ahelp> In the form document, double-click one of these controls to open the <emph>Insert Graphic</emph> dialog to insert the image. There is also a context menu (not in design mode) with commands for inserting and deleting the image.</paragraph>
<paragraph role="paragraph" id="par_id3150318" xml-lang="en-US" l10n="U" oldref="70">Images from a database can be displayed in a form, and new images can be inserted in the database as long as the image control is not write-protected. The control must refer to a database field of the image type. Therefore, enter the data field into the properties window on the <emph>Data</emph> tab page.</paragraph>
</tablecell>
</tablerow>
</table>

</section>
<section id="Section10">
<bookmark xml-lang="en-US" branch="hid/.uno:DateField" id="bm_id4810502" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:DateField" id="bm_id3145656" localize="false"/>
<paragraph role="heading" id="hd_id3156040" xml-lang="en-US" level="2" l10n="U" oldref="29">Date Field<comment>more controls bar</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3149423" xml-lang="en-US" l10n="E">
<image id="img_id3150096" src="res/commandimagelist/sc_adddatefield.png" width="0.2228in" height="0.2228in"><alt id="alt_id3150096" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3151312" xml-lang="en-US" l10n="U" oldref="30"><ahelp hid=".uno:DateField">Creates a date field.</ahelp> If the form is linked to a database, the date values can be adopted from the database.</paragraph>
</tablecell>
</tablerow>
</table>

<paragraph role="paragraph" id="par_id3151302" xml-lang="en-US" l10n="U" oldref="131">If you assign the "Dropdown" property to the date field, the user can open a calendar to select a date under the date field. This also applies to a date field within a Table Control field.</paragraph>
<paragraph role="tip" id="par_id3154395" xml-lang="en-US" l10n="U" oldref="63">Date fields can be easily edited by the user with the up arrow and down arrow keys. Depending on the cursor position, the day, month, or the year is can be increased or decreased using the arrow keys.</paragraph>
<paragraph role="paragraph" id="par_id3153112" xml-lang="en-US" l10n="U" oldref="132"><link href="text/shared/02/01170003.xhp" name="Specific Remarks on Date Fields">Specific Remarks on Date Fields</link>.</paragraph>
</section>
<section id="Section9">
<bookmark xml-lang="en-US" branch="hid/.uno:TimeField" id="bm_id4739584" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:TimeField" id="bm_id3154541" localize="false"/>
<paragraph role="heading" id="hd_id3152369" xml-lang="en-US" level="2" l10n="U" oldref="31">Time Field<comment>more controls bar</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3153687" xml-lang="en-US" l10n="E">
<image id="img_id3155949" src="res/commandimagelist/sc_timefield.png" width="0.2228in" height="0.2228in"><alt id="alt_id3155949" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3155399" xml-lang="en-US" l10n="U" oldref="32"><ahelp hid=".uno:TimeField">Creates a time field.</ahelp> If the form is linked to a database, the time values for the form can be adopted from the database.</paragraph>
</tablecell>
</tablerow>
</table>

<paragraph role="tip" id="par_id3154764" xml-lang="en-US" l10n="U" oldref="64">Time fields can be easily edited by the user with the up and down arrow keys. Depending on the cursor position, the hours, minutes, or the seconds are increased or decreased using the arrow keys.</paragraph>
</section>
<section id="Section11">
<bookmark xml-lang="en-US" branch="hid/.uno:FileControl" id="bm_id1460134" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:FileControl" id="bm_id3154859" localize="false"/>
<paragraph role="heading" id="hd_id3156186" xml-lang="en-US" level="2" l10n="U" oldref="27">File Selection<comment>more controls bar</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3150531" xml-lang="en-US" l10n="E">
<image id="img_id3154344" src="res/commandimagelist/sc_filecontrol.png" width="0.2228in" height="0.2228in"><alt id="alt_id3154344" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3149438" xml-lang="en-US" l10n="U" oldref="28"><ahelp hid=".uno:FileControl">Creates a button that enables file selection.</ahelp></paragraph>
</tablecell>
</tablerow>
</table>

</section>
<section id="Section8">
<bookmark xml-lang="en-US" branch="hid/.uno:NumericField" id="bm_id3301501" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:NumericField" id="bm_id3154211" localize="false"/>
<paragraph role="heading" id="hd_id3154652" xml-lang="en-US" level="2" l10n="U" oldref="33">Numerical Field<comment>more controls bar</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3149396" xml-lang="en-US" l10n="E">
<image id="img_id3153012" src="res/commandimagelist/sc_insertnumericfield.png" width="0.2228in" height="0.2228in"><alt id="alt_id3153012" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3145601" xml-lang="en-US" l10n="U" oldref="34"><ahelp hid=".uno:NumericField">Creates a numerical field.</ahelp> If the form is linked to a database, the numerical values in the form can be adopted from the database.</paragraph>
</tablecell>
</tablerow>
</table>

</section>
<section id="Section6">
<bookmark xml-lang="en-US" branch="hid/.uno:CurrencyField" id="bm_id9766539" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:CurrencyField" id="bm_id3151327" localize="false"/>
<paragraph role="heading" id="hd_id3153612" xml-lang="en-US" level="2" l10n="U" oldref="35">Currency Field<comment>more controls bar</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3145324" xml-lang="en-US" l10n="E">
<image id="img_id3152866" src="res/commandimagelist/sc_currencyfield.png" width="0.2228in" height="0.2228in"><alt id="alt_id3152866" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3145115" xml-lang="en-US" l10n="U" oldref="36"><ahelp hid=".uno:CurrencyField">Creates a currency field.</ahelp> If the form is linked to a database, the currency field contents for in the form can be adopted from the database.</paragraph>
</tablecell>
</tablerow>
</table>

</section>
<section id="Section5">
<bookmark xml-lang="en-US" branch="hid/.uno:PatternField" id="bm_id1317017" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:PatternField" id="bm_id3155746" localize="false"/>
<paragraph role="heading" id="hd_id3148825" xml-lang="en-US" level="2" l10n="U" oldref="37">Pattern Field<comment>more controls bar</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3149742" xml-lang="en-US" l10n="E">
<image id="img_id3148924" src="res/commandimagelist/sc_insertpatternfield.png" width="0.2228in" height="0.2228in"><alt id="alt_id3148924" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3150122" xml-lang="en-US" l10n="U" oldref="38"><ahelp hid=".uno:PatternField">Creates a pattern field.</ahelp> Pattern fields consist of an edit mask and a literal mask. The edit mask determines which data can be entered. The literal mask determines the contents of the pattern field when loading the form.</paragraph>
</tablecell>
</tablerow>
</table>

<paragraph role="note" id="par_id3152947" xml-lang="en-US" l10n="U" oldref="67">Please note that pattern fields are not exported into HTML format.</paragraph>
</section>
<section id="Section17">
<bookmark xml-lang="en-US" branch="hid/.uno:Groupbox" id="bm_id3430892" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:GroupBox" id="bm_id3147364" localize="false"/>
<paragraph role="heading" id="hd_id3145147" xml-lang="en-US" level="2" l10n="U" oldref="14">Group Box<comment>more controls bar</comment></paragraph>
<table id="tbl_id3154020">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3159334" xml-lang="en-US" l10n="E">
<image id="img_id3153790" src="res/commandimagelist/sc_groupbox.png" width="0.2228in" height="0.2228in"><alt id="alt_id3153790" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3154572" xml-lang="en-US" l10n="U" oldref="15"><ahelp hid=".uno:GroupBox">Creates a frame to visually group several controls.</ahelp> Group boxes allow you to group option buttons in a frame.</paragraph>
<paragraph role="paragraph" id="par_id3148394" xml-lang="en-US" l10n="U" oldref="72">If you insert a group frame into the document, the <link href="text/shared/autopi/01120000.xhp" name="Group Element Wizard">Group Element Wizard</link> starts, which allows you to easily create an option group.</paragraph>
</tablecell>
</tablerow>
</table>

<paragraph role="paragraph" id="par_id3150567" xml-lang="en-US" l10n="U" oldref="65">
<emph>Note:</emph> When you drag a group box over already existing controls and then want to select a control, you have to first open the context menu of the group box and choose <emph>Arrange - Send to Back</emph>. Then select the control while pressing <switchinline select="sys"><caseinline select="MAC">Command
</caseinline><defaultinline>Ctrl</defaultinline></switchinline>.</paragraph>
<paragraph role="note" id="par_id3145615" xml-lang="en-US" l10n="U" oldref="66">Group boxes are used only for a visual effect. A functional grouping of option fields can be made through the name definition: under the <link href="text/shared/02/01170101.xhp" name="Name"><emph>Name</emph></link> properties of all option fields, enter the same name in order to group them.</paragraph>
</section>
<section id="Section4">
<bookmark xml-lang="en-US" branch="hid/.uno:Grid" id="bm_id74623" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:Grid" id="bm_id3147372" localize="false"/>
<paragraph role="heading" id="hd_id3157996" xml-lang="en-US" level="2" l10n="U" oldref="39">Table Control<comment>more controls bar</comment></paragraph>
<table id="tbl_id3153023">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3156402" xml-lang="en-US" l10n="E">
<image id="img_id3146324" src="res/commandimagelist/sc_grid.png" width="0.2228in" height="0.2228in"><alt id="alt_id3146324" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3154579" xml-lang="en-US" l10n="CHG" oldref="40"><ahelp hid=".">Creates a table control to display a database table.</ahelp> If you create a new table control, the <link href="text/shared/02/01170800.xhp" name="Table Element Wizard">Table Element Wizard</link> appears.</paragraph>
</tablecell>
</tablerow>
</table>

<paragraph role="paragraph" id="par_id3154697" xml-lang="en-US" l10n="U" oldref="133"><link href="text/shared/02/01170004.xhp" name="Special Information about Table Controls">Special information about Table Controls</link>.</paragraph>
</section>
<section id="Section24">
<bookmark xml-lang="en-US" branch="hid/.uno:NavigationBar" id="bm_id8951689" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:NavigationBar" id="bm_id9112521" localize="false"/>
<paragraph role="heading" id="par_idN11B1E" xml-lang="en-US" level="2" l10n="NEW">Navigation bar<comment>more controls bar</comment></paragraph>
<table id="">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_idN11B2C" xml-lang="en-US" l10n="NEW">
<image id="img_id5074922" src="res/commandimagelist/sc_navigationbar.png" width="0.2228in" height="0.2228in"><alt id="alt_id5074922" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_idN11B3D" xml-lang="en-US" l10n="NEW"><ahelp hid="SID_FM_NAVIGATIONBAR">Creates a navigation bar.</ahelp></paragraph>
</tablecell>
</tablerow>
</table>

<paragraph role="paragraph" id="par_idN11DB1" xml-lang="en-US" l10n="NEW">The navigation bar allows you to move through the records of a database or a database form. The controls on this navigation bar work the same way as the controls on the default <link href="text/shared/main0213.xhp">navigation bar</link> in $[officename].</paragraph>
</section>
</section><comment>end of MORE CONTROLS bar</comment>
</case>
</switch>
<switch select="sys">
<case select="HIDE_HERE"><comment>now the Form Design bar</comment>
<section id="Section1">
<bookmark xml-lang="en-US" branch="hid/.uno:AutoControlFocus" id="bm_id8170669" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:AutoControlFocus" id="bm_id3149198" localize="false"/>
<paragraph role="heading" id="hd_id3146815" xml-lang="en-US" level="2" l10n="U" oldref="136">Automatic Control Focus<comment>design bar</comment></paragraph>
<table id="tbl_id3154633">
<tablerow>
<tablecell>
<paragraph role="paragraph" id="par_id3150261" xml-lang="en-US" l10n="E">
<image id="img_id3149351" src="res/commandimagelist/sc_autocontrolfocus.png" width="0.2228in" height="0.2228in"><alt id="alt_id3149351" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell>
<paragraph role="paragraph" id="par_id3109848" xml-lang="en-US" l10n="U" oldref="137"><ahelp hid=".uno:AutoControlFocus">If<emph> Automatic Control Focus </emph>is activated, the first form control will be selected when you open the document. If the button is not activated, the text will be selected after opening. The <link href="text/shared/02/01170300.xhp" name="Tab Order">Tab Order</link> that you have specified determines which is the first form control.</ahelp></paragraph>
</tablecell>
</tablerow>
</table>

</section><comment>end of FORM DESIGN bar</comment>
</case>
</switch>
</body>
</helpdocument>
