<?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="textsimpressguidelayer_newxml" indexer="include" status="PUBLISH">
<title id="tit" xml-lang="en-US">Inserting Layers</title>
<filename>/text/simpress/guide/layer_new.xhp</filename>
</topic>
<history>
<created date="2003-10-31T00:00:00">Sun Microsystems, Inc.</created>
<lastedited date="2006-12-04T11:35:10">converted from old format - fpe</lastedited>
</history>
</meta>
<body>
<bookmark xml-lang="en-US" branch="index" id="bm_id3148797"><bookmark_value>layers; inserting and editing</bookmark_value>
<bookmark_value>inserting; layers</bookmark_value>
<bookmark_value>changing;layer properties</bookmark_value>
</bookmark><comment>MW changed "modifying;..." to "changing;..."</comment>
<paragraph role="heading" id="hd_id3148797" xml-lang="en-US" level="1" l10n="U" oldref="9"><variable id="layer_new"><link href="text/simpress/guide/layer_new.xhp" name="Inserting Layers">Inserting Layers</link>
</variable></paragraph>
<paragraph role="paragraph" id="par_idN10614" xml-lang="en-US" l10n="NEW">Drawings in %PRODUCTNAME Draw support layers.</paragraph>
<list type="ordered">
<listitem>
<paragraph role="listitem" id="par_idN10643" xml-lang="en-US" l10n="NEW">Right-click the layer tab area at the bottom.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3153418" xml-lang="en-US" l10n="CHG" oldref="11">Choose <emph>Insert Layer</emph>.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3155068" xml-lang="en-US" l10n="U" oldref="12">Type a name for the layer in the <emph>Name </emph>box.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3156382" xml-lang="en-US" l10n="U" oldref="15">In the <emph>Properties </emph>area, set the options for the layer.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3153964" xml-lang="en-US" l10n="U" oldref="13">Click <emph>OK</emph>. The new layer automatically becomes the active layer.</paragraph>
</listitem>
</list>
<paragraph role="paragraph" id="par_id3154658" xml-lang="en-US" l10n="CHG" oldref="16">To change the properties of a layer, click the name tab of the layer, and then choose <emph>Format - Layer</emph>.</paragraph>
<paragraph role="note" id="par_id3153814" xml-lang="en-US" l10n="U" oldref="17">You cannot change the name of or delete a predefined <item type="productname">%PRODUCTNAME</item> Draw layer.</paragraph>
<embed href="text/shared/00/00000004.xhp#related"/>
<embed href="text/simpress/guide/layers.xhp#layers"/>
<embed href="text/simpress/guide/layer_move.xhp#layer_move"/>
<embed href="text/simpress/guide/layer_tipps.xhp#layer_tipps"/>
</body>
</helpdocument>
