<?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="textswriter0104120212xml" indexer="include" status="PUBLISH">
<title id="tit" xml-lang="en-US">Index</title>
<filename>/text/swriter/01/04120212.xhp</filename>
</topic>
<history>
<created date="2003-10-31T00:00:00">Sun Microsystems, Inc.</created>
<lastedited date="2005-12-13T10:57:29">converted from old format - fpe
UFI: included note for asian languages into AVIS text.
DEDR: reviewed</lastedited>
</history>
</meta>
<body>
<paragraph role="heading" id="hd_id3147338" xml-lang="en-US" level="1" l10n="U" oldref="1"><link href="text/swriter/01/04120212.xhp" name="Index">Index</link></paragraph>
<paragraph role="paragraph" id="par_id3155962" xml-lang="en-US" l10n="U" oldref="2"><variable id="verzeichnis">The following options are available when you select <emph>Alphabetical Index </emph>as the <link href="text/swriter/01/04120210.xhp" name="index">index</link> type. 
</variable></paragraph>
<section id="howtoget">
  <embed href="text/swriter/00/00000404.xhp#verz22"/>
</section>
<embed href="text/swriter/01/04120211.xhp#typtitel"/>
<embed href="text/swriter/01/04120211.xhp#verzfuer"/>
<paragraph role="heading" id="hd_id3153247" xml-lang="en-US" level="2" l10n="U" oldref="3">Options</paragraph>
<bookmark xml-lang="en-US" branch="hid/sw:CheckBox:TP_TOX_SELECT:CB_COLLECTSAME" id="bm_id3146963" localize="false"/>
<paragraph role="heading" id="hd_id3154651" xml-lang="en-US" level="3" l10n="U" oldref="5">Combine identical entries</paragraph>
<paragraph role="paragraph" id="par_id3153810" xml-lang="en-US" l10n="U" oldref="6"><ahelp hid="SW_CHECKBOX_TP_TOX_SELECT_CB_COLLECTSAME">Replaces identical index entries with a single entry that lists the page numbers where the entry occurs in the document. For example, the entries "View 10, View 43" are combined as "View 10, 43".</ahelp></paragraph>
<bookmark xml-lang="en-US" branch="hid/sw:CheckBox:TP_TOX_SELECT:CB_USEFF" id="bm_id3151393" localize="false"/>
<paragraph role="heading" id="hd_id3147403" xml-lang="en-US" level="3" l10n="U" oldref="7">Combine identical entries with p or pp</paragraph>
<paragraph role="paragraph" id="par_id3083451" xml-lang="en-US" l10n="U" oldref="8"><ahelp hid="SW_CHECKBOX_TP_TOX_SELECT_CB_USEFF">Replaces identical index entries, which occur also on the directly following page or pages, with a single entry that lists the first page number and a "p" or "pp". For example, the entries "View 10, View 11, View 12" are combined as "View 10pp", and "View 10, View 11" as "View 10p".</ahelp></paragraph>
<bookmark xml-lang="en-US" branch="hid/sw:CheckBox:TP_TOX_SELECT:CB_USE_DASH" id="bm_id3149353" localize="false"/>
<paragraph role="heading" id="hd_id3157870" xml-lang="en-US" level="3" l10n="U" oldref="9">Combine with -</paragraph>
<paragraph role="paragraph" id="par_id3145825" xml-lang="en-US" l10n="U" oldref="10"><ahelp hid="SW_CHECKBOX_TP_TOX_SELECT_CB_USE_DASH">Replaces identical index entries that occur on consecutive pages with a single entry and the page range where the entry occurs. For example, the entries "View 10, View 11, View 12" are combined as "View 10-12".</ahelp></paragraph>
<bookmark xml-lang="en-US" branch="hid/sw:CheckBox:TP_TOX_SELECT:CB_CASESENSITIVE" id="bm_id3150019" localize="false"/>
<paragraph role="heading" id="hd_id3154502" xml-lang="en-US" level="3" l10n="U" oldref="11">Case sensitive</paragraph>
<paragraph role="paragraph" id="par_id3149880" xml-lang="en-US" l10n="CHG" oldref="12"><ahelp hid="SW_CHECKBOX_TP_TOX_SELECT_CB_CASESENSITIVE">Distinguishes between uppercase and lowercase letters in identical index entries. For Asian languages special handling applies.</ahelp> If you want the first occurrence of the entry in the document to determine the case of the entry, select <emph>Combine identical entries</emph>.</paragraph>
<paragraph role="note" id="par_idN10671" xml-lang="en-US" l10n="NEW">To use multi-level collation to Asian languages, select <emph>Case sensitive</emph>. In the multi-level collation, the cases and diacritics of the entries are ignored and only the primitive forms of the entries are compared. If the forms are identical, the diacritics of the forms are compared. If the forms are still identical, the cases of the forms as well as the widths of the characters, and the differences in the Japanese Kana are compared.<comment>UFI: see #112590# and #112507#</comment></paragraph>
<bookmark xml-lang="en-US" branch="hid/sw:CheckBox:TP_TOX_SELECT:CB_INITIALCAPS" id="bm_id3148393" localize="false"/>
<paragraph role="heading" id="hd_id3150569" xml-lang="en-US" level="3" l10n="U" oldref="13">AutoCapitalize entries</paragraph>
<paragraph role="paragraph" id="par_id3148772" xml-lang="en-US" l10n="U" oldref="14"><ahelp hid="SW_CHECKBOX_TP_TOX_SELECT_CB_INITIALCAPS">Automatically capitalizes the first letter of an index entry.</ahelp></paragraph>
<bookmark xml-lang="en-US" branch="hid/sw:CheckBox:TP_TOX_SELECT:CB_KEYASENTRY" id="bm_id3153924" localize="false"/>
<paragraph role="heading" id="hd_id3155986" xml-lang="en-US" level="3" l10n="U" oldref="15">Keys as separate entries</paragraph>
<paragraph role="paragraph" id="par_id3147170" xml-lang="en-US" l10n="U" oldref="16"><ahelp hid="SW_CHECKBOX_TP_TOX_SELECT_CB_KEYASENTRY">Inserts index keys as separate index entries.</ahelp> A key is inserted as a top level index entry and the entries that are assigned to the key as indented subentries.</paragraph>
<paragraph role="paragraph" id="par_id3151184" xml-lang="en-US" l10n="U" oldref="17">To define an index key, choose <link href="text/swriter/01/04120100.xhp" name="Insert Index Entry"><emph>Insert Index Entry</emph></link> dialog.</paragraph>
<bookmark xml-lang="en-US" branch="hid/sw:CheckBox:TP_TOX_SELECT:CB_FROMFILE" id="bm_id3150766" localize="false"/>
<paragraph role="heading" id="hd_id3154646" xml-lang="en-US" level="3" l10n="U" oldref="18">Concordance file</paragraph>
<paragraph role="paragraph" id="par_id3156322" xml-lang="en-US" l10n="U" oldref="19"><ahelp hid="SW_CHECKBOX_TP_TOX_SELECT_CB_FROMFILE">Automatically marks index entries using a concordance file - a list of words to include in an index.</ahelp></paragraph>
<bookmark xml-lang="en-US" branch="hid/sw:MenuButton:TP_TOX_SELECT:MB_AUTOMARK" id="bm_id3153151" localize="false"/>
<paragraph role="heading" id="hd_id3150258" xml-lang="en-US" level="3" l10n="U" oldref="24">File</paragraph>
<paragraph role="paragraph" id="par_id3149287" xml-lang="en-US" l10n="U" oldref="25"><ahelp hid="SW_MENUBUTTON_TP_TOX_SELECT_MB_AUTOMARK">Select, create, or edit a concordance file.</ahelp></paragraph>
<section id="sort">
<paragraph role="heading" id="hd_id3152950" xml-lang="en-US" level="2" l10n="U" oldref="32">Sort</paragraph>
<paragraph role="paragraph" id="par_id3149812" xml-lang="en-US" l10n="U" oldref="33">Sets the options for sorting the index entries.</paragraph>
<bookmark xml-lang="en-US" branch="hid/sw:ListBox:TP_TOX_SELECT:LB_LANGUAGE" id="bm_id3150359" localize="false"/>
<paragraph role="heading" id="hd_id3150347" xml-lang="en-US" level="3" l10n="U" oldref="34">Language</paragraph>
<paragraph role="paragraph" id="par_id3154475" xml-lang="en-US" l10n="U" oldref="35"><ahelp hid="SW_LISTBOX_TP_TOX_SELECT_LB_LANGUAGE">Select the language rules to use for sorting the index entries.</ahelp></paragraph>
<bookmark xml-lang="en-US" branch="hid/sw:ListBox:TP_TOX_SELECT:LB_SORTALG" id="bm_id3147524" localize="false"/>
<paragraph role="heading" id="hd_id3153675" xml-lang="en-US" level="3" l10n="U" oldref="36">Key type</paragraph>
<paragraph role="paragraph" id="par_id3147530" xml-lang="en-US" l10n="U" oldref="37"><ahelp hid="SW_LISTBOX_TP_TOX_SELECT_LB_SORTALG">Select numeric when you want to sort numbers by value, such as in 1, 2, 12. Select alphanumeric, when you want to sort the numbers by character code, such as in 1, 12, 2.</ahelp></paragraph>
</section>
</body>
</helpdocument>
