<?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="textsmath0106010100xml" indexer="include" status="PUBLISH">
<title id="tit" xml-lang="en-US">Edit Symbols</title>
<filename>/text/smath/01/06010100.xhp</filename>
</topic>
<history>
<created date="2003-10-31T00:00:00">Sun Microsystems, Inc.</created>
<lastedited date="2005-04-12T13:56:55">UFI: fix to #i28380#</lastedited>
</history>
</meta>
<body>
<bookmark xml-lang="en-US" branch="hid/starmath:ModalDialog:RID_SYMDEFINEDIALOG" id="bm_id3149379" localize="false"/>
<bookmark xml-lang="en-US" branch="index" id="bm_id2123477"><bookmark_value>new symbols in %PRODUCTNAME Math</bookmark_value>
<bookmark_value>symbols; adding in %PRODUCTNAME Math</bookmark_value>
</bookmark>
<paragraph role="heading" id="hd_id3151075" xml-lang="en-US" level="1" l10n="CHG" oldref="1">Edit Symbols</paragraph>
<paragraph role="paragraph" id="par_id3154513" xml-lang="en-US" l10n="CHG" oldref="2"><ahelp hid="STARMATH_MODALDIALOG_RID_SYMDEFINEDIALOG">Use this dialog to add symbols to a symbol set, to edit symbol sets, or to modify symbol notations.</ahelp> You can also define new symbol sets, assign names to symbols, or to modify existing symbol sets.</paragraph>
<section id="howtoget">
  <embed href="text/smath/00/00000004.xhp#etssba"/>
</section>
<bookmark xml-lang="en-US" branch="hid/starmath:ComboBox:RID_SYMDEFINEDIALOG:1" id="bm_id3154253" localize="false"/>
<paragraph role="heading" id="hd_id3146066" xml-lang="en-US" level="2" l10n="CHG" oldref="3">Old Symbol</paragraph>
<paragraph role="paragraph" id="par_id3153965" xml-lang="en-US" l10n="CHG" oldref="4"><ahelp hid="STARMATH_COMBOBOX_RID_SYMDEFINEDIALOG_1">Select the name of the current symbol.</ahelp> The symbol, the name of the symbol, and the set that the symbol belongs to are displayed in the left preview pane at the bottom of the dialog box.</paragraph>
<bookmark xml-lang="en-US" branch="hid/starmath:ComboBox:RID_SYMDEFINEDIALOG:2" id="bm_id3145791" localize="false"/>
<paragraph role="heading" id="hd_id3154020" xml-lang="en-US" level="2" l10n="CHG" oldref="7">Old Symbol Set</paragraph>
<paragraph role="paragraph" id="par_id3150209" xml-lang="en-US" l10n="CHG" oldref="8"><ahelp hid="STARMATH_COMBOBOX_RID_SYMDEFINEDIALOG_2">This list box contains the name of the current symbol set. If you want, you can also select a different symbol set.</ahelp></paragraph>
<bookmark xml-lang="en-US" branch="hid/starmath:ComboBox:RID_SYMDEFINEDIALOG:4" id="bm_id3153816" localize="false"/>
<paragraph role="heading" id="hd_id3145386" xml-lang="en-US" level="2" l10n="U" oldref="23">Symbol</paragraph>
<paragraph role="paragraph" id="par_id3148870" xml-lang="en-US" l10n="CHG" oldref="25"><ahelp hid="STARMATH_COMBOBOX_RID_SYMDEFINEDIALOG_4">Lists the names for the symbols in the current symbol set. Select a name from the list or type a name for a newly added symbol.</ahelp></paragraph>
<paragraph role="heading" id="hd_id3150215" xml-lang="en-US" level="3" l10n="CHG" oldref="28">Adding a New Symbol</paragraph>
<paragraph role="paragraph" id="par_id3143233" xml-lang="en-US" l10n="CHG" oldref="6">To add a symbol to a symbol set, select a font in the <emph>Font</emph> box, and then click a symbol in symbols pane. In the <emph>Symbol</emph> box, type a name for the symbol. In the <emph>Symbol set</emph> list box, select a symbol set, or type a new name to create a new symbol set. The right preview pane displays the symbol that you selected. Click <emph>Add</emph> and then <emph>OK</emph>.</paragraph>
<paragraph role="heading" id="hd_id3151389" xml-lang="en-US" level="3" l10n="U" oldref="29">Modifying the Name of a Symbol</paragraph>
<paragraph role="paragraph" id="par_id3147296" xml-lang="en-US" l10n="CHG" oldref="21">To change the name of a symbol, select the old name in the <emph>Old symbol</emph> list box. Then enter the new name in the <emph>Symbol</emph> box. Check whether the desired character is in the preview window before you click the <emph>Modify</emph> button. Click <emph>OK</emph>.</paragraph>
<bookmark xml-lang="en-US" branch="hid/starmath:ComboBox:RID_SYMDEFINEDIALOG:5" id="bm_id3148729" localize="false"/>
<paragraph role="heading" id="hd_id3157870" xml-lang="en-US" level="2" l10n="U" oldref="24">Symbol Set</paragraph>
<paragraph role="paragraph" id="par_id3145825" xml-lang="en-US" l10n="U" oldref="26"><ahelp hid="STARMATH_COMBOBOX_RID_SYMDEFINEDIALOG_5">The <emph>Symbol set</emph> list box contains the names of all existing symbol sets. You can modify a symbol set or create a new one.</ahelp></paragraph>
<paragraph role="heading" id="hd_id3154554" xml-lang="en-US" level="3" l10n="U" oldref="30">Creating a New Symbol Set</paragraph>
<paragraph role="paragraph" id="par_id3145594" xml-lang="en-US" l10n="U" oldref="22">To create a new symbol set, type a name for it in the <emph>Symbol set</emph> list box and add at least one symbol. Click <emph>OK</emph> to close the dialog. The new symbol set is now available under the new name.</paragraph>
<bookmark xml-lang="en-US" branch="hid/starmath:ListBox:RID_SYMDEFINEDIALOG:1" id="bm_id3147367" localize="false"/>
<paragraph role="heading" id="hd_id3153736" xml-lang="en-US" level="2" l10n="U" oldref="10">Font</paragraph>
<paragraph role="paragraph" id="par_id3147374" xml-lang="en-US" l10n="U" oldref="11"><ahelp hid="STARMATH_LISTBOX_RID_SYMDEFINEDIALOG_1">Displays the name of the current font and enables you to select a different font.</ahelp></paragraph>
<bookmark xml-lang="en-US" branch="hid/starmath:ListBox:RID_SYMDEFINEDIALOG:LB_FONTS_SUBSET" id="bm_id3148769" localize="false"/>
<paragraph role="heading" id="hd_id3150564" xml-lang="en-US" level="2" l10n="U" oldref="32">Subset</paragraph>
<paragraph role="paragraph" id="par_id3145295" xml-lang="en-US" l10n="U" oldref="33"><ahelp hid="STARMATH_LISTBOX_RID_SYMDEFINEDIALOG_LB_FONTS_SUBSET">If you selected a non-symbol font in the <emph>Font</emph> list box, you can select a Unicode subset in which to place your new or edited symbol. When a subset has been selected, all symbols belonging to this subset of the current symbol set are displayed in the symbols list above.</ahelp></paragraph>
<bookmark xml-lang="en-US" branch="hid/starmath:ComboBox:RID_SYMDEFINEDIALOG:3" id="bm_id3149026" localize="false"/>
<paragraph role="heading" id="hd_id3148386" xml-lang="en-US" level="2" l10n="U" oldref="19">Typeface</paragraph>
<paragraph role="paragraph" id="par_id3155366" xml-lang="en-US" l10n="U" oldref="20"><ahelp hid="STARMATH_COMBOBOX_RID_SYMDEFINEDIALOG_3">The current typeface is displayed. You can change the typeface by selecting one from the list box.</ahelp></paragraph>
<bookmark xml-lang="en-US" branch="hid/starmath:PushButton:RID_SYMDEFINEDIALOG:1" id="bm_id3155989" localize="false"/>
<paragraph role="heading" id="hd_id3156262" xml-lang="en-US" level="2" l10n="U" oldref="12">Add</paragraph>
<paragraph role="paragraph" id="par_id3153922" xml-lang="en-US" l10n="U" oldref="13"><ahelp hid="STARMATH_PUSHBUTTON_RID_SYMDEFINEDIALOG_1">Click this button to add the symbol shown in the right preview window to the current symbol set.</ahelp> It will be saved under the name displayed in the <emph>Symbol</emph> list box. You must specify a name under <emph>Symbol</emph> or <emph>Symbol Set</emph> to be able to use this button. Names cannot be used more than once.</paragraph>
<bookmark xml-lang="en-US" branch="hid/starmath:PushButton:RID_SYMDEFINEDIALOG:2" id="bm_id3147563" localize="false"/>
<paragraph role="heading" id="hd_id3150756" xml-lang="en-US" level="2" l10n="U" oldref="14">Modify</paragraph>
<paragraph role="paragraph" id="par_id3147570" xml-lang="en-US" l10n="U" oldref="15"><ahelp hid="STARMATH_PUSHBUTTON_RID_SYMDEFINEDIALOG_2">Click this button to replace the name of the symbol shown in the left preview window (the old name is displayed in the <emph>Old symbol</emph> list box) with the new name you have entered in the <emph>Symbol</emph> list box.</ahelp></paragraph>
<paragraph role="heading" id="hd_id3154640" xml-lang="en-US" level="3" l10n="U" oldref="31">Moving a Symbol to Another Symbol Set</paragraph>
<paragraph role="tip" id="par_id3151174" xml-lang="en-US" l10n="U" oldref="27">As an example, to transfer the large ALPHA from the "Greek" set to the "Special" set, select the old set (Greek) and then the ALPHA symbol using the two top list boxes. The symbol appears in the left preview window. In the <emph>Symbol set</emph> list box, select the "Special" set. Click <emph>Modify</emph> and then <emph>OK</emph>. The ALPHA symbol is now only in the "Special" symbol set.</paragraph>
<bookmark xml-lang="en-US" branch="hid/starmath:PushButton:RID_SYMDEFINEDIALOG:3" id="bm_id3153578" localize="false"/>
<paragraph role="heading" id="hd_id3145414" xml-lang="en-US" level="2" l10n="U" oldref="16">Delete</paragraph>
<paragraph role="paragraph" id="par_id3154258" xml-lang="en-US" l10n="U" oldref="17"><ahelp hid="STARMATH_PUSHBUTTON_RID_SYMDEFINEDIALOG_3">Click to remove the symbol shown in the left preview window from the current symbol set.</ahelp> There will be no security query. Deleting the last remaining symbol of a symbol set also deletes the symbol set.</paragraph>
<paragraph role="note" id="par_id3153527" xml-lang="en-US" l10n="U" oldref="18">You can also click <emph>Cancel</emph> at any time to close the dialog without saving any of the changes.</paragraph>
</body>
</helpdocument>
