<?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="textshared0105020700xml" indexer="include" status="PUBLISH">
<title id="tit" xml-lang="en-US">Asian Typography</title>
<filename>/text/shared/01/05020700.xhp</filename>
</topic>
</meta>
<body>
<section id="asitypo">
<bookmark xml-lang="en-US" branch="index" id="bm_id3155620"><bookmark_value>Asian typography</bookmark_value>
<bookmark_value>formatting; Asian typography</bookmark_value>
<bookmark_value>paragraphs; Asian typography</bookmark_value>
<bookmark_value>typography; Asian</bookmark_value>
</bookmark><comment>MW changed "formats;" to "formatting;"</comment><paragraph role="heading" id="hd_id3155620" xml-lang="en-US" level="1" l10n="U" oldref="1"><link href="text/shared/01/05020700.xhp" name="Asian Typography">Asian Typography</link></paragraph>
<paragraph role="paragraph" id="par_id3153124" xml-lang="en-US" l10n="CHG" oldref="2"><ahelp hid=".">Set the typographic options for cells or paragraphs in Asian language files. To enable Asian language support, choose <emph>Language Settings - Languages</emph> in the Options dialog box, and then select the <emph>Enabled</emph> box in the <emph>Asian language support</emph> area.</ahelp> The Asian typography options are ignored in HTML documents.</paragraph>
</section>
<section id="howtoget">
  <embed href="text/shared/00/00040500.xhp#asitypo"/>
</section>
<paragraph role="heading" id="hd_id3147571" xml-lang="en-US" level="2" l10n="U" oldref="3">Line change</paragraph>
<paragraph role="paragraph" id="par_id3147834" xml-lang="en-US" l10n="U" oldref="4">Set the options for line breaks in Asian language documents.</paragraph>
<bookmark xml-lang="en-US" branch="hid/cui:TriStateBox:RID_SVXPAGE_PARA_ASIAN:CB_AS_FORBIDDEN" id="bm_id3155355" localize="false"/><paragraph role="heading" id="hd_id3145072" xml-lang="en-US" level="3" l10n="U" oldref="9">Apply list of forbidden characters to the beginning and end of line</paragraph>
<paragraph role="paragraph" id="par_id3153683" xml-lang="en-US" l10n="U" oldref="10"><ahelp hid="SVX_TRISTATEBOX_RID_SVXPAGE_PARA_ASIAN_CB_AS_FORBIDDEN">Prevents the characters in the list from starting or ending a line. The characters are relocated to either the previous or the next line.</ahelp> To edit the list of restricted characters, choose <emph><switchinline select="sys"><caseinline select="MAC">%PRODUCTNAME - Preferences</caseinline><defaultinline>Tools - Options</defaultinline></switchinline> - Language Settings - <link href="text/shared/optionen/01150100.xhp" name="Asian Layout">Asian Layout</link></emph>.</paragraph>
<bookmark xml-lang="en-US" branch="hid/cui:TriStateBox:RID_SVXPAGE_PARA_ASIAN:CB_AS_HANG_PUNC" id="bm_id3156410" localize="false"/><paragraph role="heading" id="hd_id3149751" xml-lang="en-US" level="3" l10n="U" oldref="5">Allow hanging punctuation</paragraph>
<paragraph role="paragraph" id="par_id3149096" xml-lang="en-US" l10n="U" oldref="6"><ahelp hid="SVX_TRISTATEBOX_RID_SVXPAGE_PARA_ASIAN_CB_AS_HANG_PUNC">Prevents commas and periods from breaking the line. Instead, these characters are added to the end of the line, even in the page margin.</ahelp></paragraph>
<bookmark xml-lang="en-US" branch="hid/cui:TriStateBox:RID_SVXPAGE_PARA_ASIAN:CB_AS_SCRIPT_SPACE" id="bm_id3149811" localize="false"/><paragraph role="heading" id="par_id3147275" xml-lang="en-US" level="3" l10n="U" oldref="7">
<emph>Apply spacing between Asian, Latin and Complex text</emph>
</paragraph>
<paragraph role="paragraph" id="par_id3148539" xml-lang="en-US" l10n="U" oldref="8"><ahelp hid="SVX_TRISTATEBOX_RID_SVXPAGE_PARA_ASIAN_CB_AS_SCRIPT_SPACE">Inserts a space between Asian, Latin and complex characters.</ahelp></paragraph>
<section id="relatedtopics">
<paragraph role="paragraph" id="par_id3153665" xml-lang="en-US" l10n="C"><link href="text/shared/optionen/01140000.xhp" name="Enabling Asian language support">Enabling Asian language support</link></paragraph>
</section>
</body>
</helpdocument>
