<?xml version="1.0" encoding="UTF-8"?>


<!--***********************************************************
 * 
 * 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.
 * 
 ***********************************************************-->


	
<helpdocument version="1.0">
<meta>
<topic id="textscalc0104080000xml" indexer="include" status="PUBLISH">
<title id="tit" xml-lang="en-US">Function List</title>
<filename>/text/scalc/01/04080000.xhp</filename>
</topic>
<history>
<created date="2003-10-31T00:00:00">Sun Microsystems, Inc.</created>
<lastedited date="2005-01-17T10:39:25">converted from old format - fpe</lastedited>
</history>
</meta>
<body>
<bookmark xml-lang="en-US" branch="index" id="bm_id3154126"><bookmark_value>formula list window</bookmark_value>
<bookmark_value>function list window</bookmark_value>
<bookmark_value>inserting functions; function list window</bookmark_value>
</bookmark>
<!-- removed HID HID_SC_FUNCTIONLIST -->
<bookmark xml-lang="en-US" branch="hid/.uno:FunctionBox" id="bm_id998166" localize="false"/><!-- HID added by script -->
<bookmark xml-lang="en-US" branch="hid/.uno:FunctionBox" id="bm_id7607654" localize="false"/>
<paragraph role="heading" id="hd_id3154126" xml-lang="en-US" level="1" l10n="U" oldref="1"><link href="text/scalc/01/04080000.xhp" name="Function List">Function List</link></paragraph>
<paragraph role="paragraph" id="par_id3151118" xml-lang="en-US" l10n="CHG" oldref="2"><variable id="funktionslistetext"><ahelp hid="HID_SC_FUNCTIONLIST">This command opens the <emph>Function List</emph> window, which displays all functions that can be inserted into your document.</ahelp>
</variable> The <emph>Function List</emph> window is similar to the <emph>Functions</emph> tab page of the <link href="text/scalc/01/04060000.xhp" name="Function Wizard">Function Wizard</link>. The functions are inserted with placeholders to be replaced with your own values.</paragraph>
<section id="howtoget">
  <embed href="text/scalc/00/00000404.xhp#funktionsliste"/>
</section>
<paragraph role="paragraph" id="par_id3152576" xml-lang="en-US" l10n="U" oldref="3">The <emph>Function List</emph> window is a resizable <link href="text/shared/00/00000005.xhp#andocken" name="dockable window">dockable window</link>. Use it to quickly enter functions in the spreadsheet. By double-clicking an entry in the functions list, the respective function is directly inserted with all parameters.</paragraph>
<bookmark xml-lang="en-US" branch="hid/sc:ListBox:FID_FUNCTION_BOX:CB_CAT" id="bm_id3149960" localize="false"/>
<paragraph role="heading" id="hd_id3145799" xml-lang="en-US" level="2" l10n="U" oldref="4">Category List</paragraph>
<embed href="text/scalc/01/04060000.xhp#kategorienliste"/>
<bookmark xml-lang="en-US" branch="hid/sc:ListBox:FID_FUNCTION_BOX:LB_FUNC" id="bm_id3147126" localize="false"/>
<paragraph role="heading" id="hd_id3153160" xml-lang="en-US" level="2" l10n="U" oldref="5">Function List</paragraph>
<paragraph role="paragraph" id="par_id3149412" xml-lang="en-US" l10n="U" oldref="6"><ahelp hid="SC:LISTBOX:FID_FUNCTION_BOX:LB_FUNC">Displays the available functions.</ahelp> When you select a function, the area below the list box displays a short description. To insert the selected function double-click it or click the <emph>Insert Function into calculation sheet</emph> icon.</paragraph>
<bookmark xml-lang="en-US" branch="hid/sc:ImageButton:FID_FUNCTION_BOX:IMB_INSERT" id="bm_id3150752" localize="false"/>
<paragraph role="heading" id="hd_id3146971" xml-lang="en-US" level="2" l10n="U" oldref="7">Insert Function into calculation sheet</paragraph>
<table id="tbl_id3153711">
<tablerow>
<tablecell colspan="" rowspan="">
<paragraph role="paragraph" id="par_id3150043" xml-lang="en-US" l10n="E">
<image id="img_id3159267" src="sc/res/fx.png" width="0.1945inch" height="0.1945inch"><alt id="alt_id3159267" xml-lang="en-US">Icon</alt>
	</image></paragraph>
</tablecell>
<tablecell colspan="" rowspan="">
<paragraph role="paragraph" id="par_id3147345" xml-lang="en-US" l10n="U" oldref="8"><ahelp hid="SC:IMAGEBUTTON:FID_FUNCTION_BOX:IMB_INSERT">Inserts the selected function into the document.</ahelp></paragraph>
</tablecell>
</tablerow>
</table>

</body>
</helpdocument>
