<?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="textswriter0104030000xml" indexer="include" status="PUBLISH">
<title id="tit" xml-lang="en-US">Footnote/Endnote</title>
<filename>/text/swriter/01/04030000.xhp</filename>
</topic>
</meta>
<body>
<bookmark xml-lang="en-US" branch="hid/.uno:InsertFootnoteDialog" id="bm_id1360835" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:InsertFootnoteDialog" id="bm_id3148770" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:InsertFootnote" id="bm_id4793576" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:InsertFootnote" id="bm_id3148773" localize="false"/>
<paragraph role="heading" id="hd_id3145241" xml-lang="en-US" level="1" l10n="U" oldref="1"><link href="text/swriter/01/04030000.xhp" name="Insert Footnote">Footnote/Endnote</link></paragraph>
<paragraph role="paragraph" id="par_id3147167" xml-lang="en-US" l10n="U" oldref="2"><variable id="fussnoteein"><ahelp hid=".uno:InsertFootnote">Inserts a footnote or an endnote in the document. The anchor for the note is inserted at the current cursor position.</ahelp> You can choose between automatic numbering or a custom symbol. 
</variable></paragraph>
<paragraph role="paragraph" id="par_id3154645" xml-lang="en-US" l10n="U" oldref="23"><variable id="endnoten">The following applies to both footnotes and endnotes. 
</variable></paragraph>
<paragraph role="paragraph" id="par_id3151175" xml-lang="en-US" l10n="U" oldref="24"><variable id="endnotetext">Footnotes are inserted at the end of a page, and endnotes are inserted at the end of a document. 
</variable><comment>UFI: what about sections? Will endnotes be placed there?</comment></paragraph>
<section id="howtoget">
<embed href="text/swriter/00/00000404.xhp#fussnoteein"/>
</section>
<paragraph role="heading" id="hd_id3154106" xml-lang="en-US" level="2" l10n="U" oldref="7">Numbering</paragraph>
<paragraph role="paragraph" id="par_id3149812" xml-lang="en-US" l10n="U" oldref="16">Select the type of numbering that you want to use for footnotes and endnotes.</paragraph>
<bookmark xml-lang="en-US" branch="hid/sw:RadioButton:DLG_INS_FOOTNOTE:RB_NUMBER_AUTO" id="bm_id3154482" localize="false"/>
<paragraph role="heading" id="hd_id3154470" xml-lang="en-US" level="3" l10n="U" oldref="8">Automatic</paragraph>
<paragraph role="paragraph" id="par_id3153670" xml-lang="en-US" l10n="U" oldref="17"><variable id="bearbeitenautomatisch"><ahelp hid="SW:RADIOBUTTON:DLG_INS_FOOTNOTE:RB_NUMBER_AUTO">Automatically assigns consecutive numbers to the footnotes or endnotes that you insert.</ahelp> To change the settings for automatic numbering, choose <link href="text/swriter/01/06080000.xhp" name="Tools - Footnotes"><emph>Tools - Footnotes/Endnotes</emph></link>. 
</variable></paragraph>
<bookmark xml-lang="en-US" branch="hid/sw:RadioButton:DLG_INS_FOOTNOTE:RB_NUMBER_CHAR" id="bm_id3152963" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/sw:Edit:DLG_INS_FOOTNOTE:ED_NUMBER_CHAR" id="bm_id3152962" localize="false"/>
<paragraph role="heading" id="hd_id3152952" xml-lang="en-US" level="3" l10n="U" oldref="9">Character</paragraph>
<paragraph role="paragraph" id="par_id3155901" xml-lang="en-US" l10n="U" oldref="18"><variable id="bearbeitenzeichen"><ahelp hid="SW:EDIT:DLG_INS_FOOTNOTE:ED_NUMBER_CHAR">Choose this option to define a character or symbol for the current footnote.</ahelp> This can be either a letter or number. To assign a special character, click the button at the bottom. 
</variable></paragraph>
<bookmark xml-lang="en-US" branch="hid/sw:PushButton:DLG_INS_FOOTNOTE:BT_NUMBER_CHAR" id="bm_id3153519" localize="false"/>
<paragraph role="heading" id="hd_id3155185" xml-lang="en-US" level="3" l10n="U" oldref="10">...</paragraph>
<paragraph role="paragraph" id="par_id3153526" xml-lang="en-US" l10n="U" oldref="19"><variable id="bearbeitensonderzeichen"><ahelp hid="SW:PUSHBUTTON:DLG_INS_FOOTNOTE:BT_NUMBER_CHAR">Inserts a <link href="text/shared/01/04100000.xhp" name="special character ">special character </link> as a footnote or endnote anchor.</ahelp>
</variable></paragraph>
<paragraph role="heading" id="hd_id3149493" xml-lang="en-US" level="2" l10n="U" oldref="11">Type</paragraph>
<paragraph role="paragraph" id="par_id3151256" xml-lang="en-US" l10n="U" oldref="20">Select whether to insert a footnote or an endnote. Endnote numbering is separate from the footnote numbering.</paragraph>
<bookmark xml-lang="en-US" branch="hid/sw:RadioButton:DLG_INS_FOOTNOTE:RB_TYPE_FTN" id="bm_id3148974" localize="false"/>
<paragraph role="heading" id="hd_id3149104" xml-lang="en-US" level="3" l10n="U" oldref="12">Footnote</paragraph>
<paragraph role="paragraph" id="par_id3148981" xml-lang="en-US" l10n="U" oldref="21"><ahelp hid="SW:RADIOBUTTON:DLG_INS_FOOTNOTE:RB_TYPE_FTN">Inserts a footnote anchor at the current cursor position in the document, and adds a footnote to the bottom of the page.</ahelp></paragraph>
<bookmark xml-lang="en-US" branch="hid/.uno:InsertEndnote" id="bm_id5303788" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/.uno:InsertEndnote" id="bm_id3149042" localize="false"/>
<bookmark xml-lang="en-US" branch="hid/sw:RadioButton:DLG_INS_FOOTNOTE:RB_TYPE_ENDNOTE" id="bm_id3149046" localize="false"/>
<paragraph role="heading" id="hd_id3153644" xml-lang="en-US" level="3" l10n="U" oldref="13">Endnote</paragraph>
<paragraph role="paragraph" id="par_id3152770" xml-lang="en-US" l10n="U" oldref="22"><ahelp hid="SW:RADIOBUTTON:DLG_INS_FOOTNOTE:RB_TYPE_ENDNOTE">Inserts an endnote anchor at the current cursor position in the document, and adds an endnote at the end of the document.</ahelp></paragraph>
<embed href="text/shared/00/00000004.xhp#related"/>
<paragraph role="paragraph" id="par_id3155135" xml-lang="en-US" l10n="U" oldref="25"><link href="text/swriter/guide/footnote_usage.xhp" name="Tips for working with footnotes">Tips for working with footnotes</link>.</paragraph>
</body>
</helpdocument>
