<?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.
 * 
 ***********************************************************-->
<tree_view version="24-Aug-2004">
	<help_section application="simpress" id="04" title="Presentations and Drawings">
		<node id="0401" title="General Information and User Interface Usage">
<topic id="simpress/text/simpress/main0000.xhp">Welcome to the %PRODUCTNAME Impress Help</topic>
<topic id="sdraw/text/sdraw/main0000.xhp">Welcome to the %PRODUCTNAME Draw Help</topic>
<topic id="simpress/text/simpress/main0503.xhp">%PRODUCTNAME Impress Features</topic>
<topic id="sdraw/text/sdraw/main0503.xhp">%PRODUCTNAME Draw Features</topic>
<topic id="simpress/text/simpress/guide/keyboard.xhp">Using Shortcut Keys in %PRODUCTNAME Impress</topic>
<topic id="sdraw/text/sdraw/guide/keyboard.xhp">Shortcut Keys for Drawing Objects</topic>
<topic id="simpress/text/simpress/04/01020000.xhp">Shortcut Keys for %PRODUCTNAME Impress</topic>
<topic id="sdraw/text/sdraw/04/01020000.xhp">Shortcut Keys for Drawings</topic>
<topic id="simpress/text/simpress/guide/main.xhp">Instructions for Using %PRODUCTNAME Impress</topic>
<topic id="sdraw/text/sdraw/guide/main.xhp">Instructions for Using %PRODUCTNAME Draw</topic>
		</node>
		<node id="0402" title="Command and Menu Reference">
			<node id="040201" title="Presentations (%PRODUCTNAME Impress)">
				<node id="04020101" title="Menus">
<topic id="simpress/text/simpress/main0100.xhp">Menus</topic>
<topic id="simpress/text/simpress/main0101.xhp">File</topic>
<topic id="simpress/text/simpress/main0102.xhp">Edit</topic>
<topic id="simpress/text/simpress/main0103.xhp">View</topic>
<topic id="simpress/text/simpress/main0104.xhp">Insert</topic>
<topic id="simpress/text/simpress/main0105.xhp">Format</topic>
<topic id="simpress/text/simpress/main0106.xhp">Tools</topic>
<topic id="simpress/text/simpress/main0107.xhp">Window</topic>
<topic id="simpress/text/simpress/main0114.xhp">Slide Show</topic>
				</node>
				<node id="04020102" title="Toolbars">
<topic id="simpress/text/simpress/main0200.xhp">Toolbars</topic>
<topic id="simpress/text/simpress/main0202.xhp">Line and Filling Bar</topic>
<topic id="simpress/text/simpress/main0203.xhp">Text Formatting Bar</topic>
<topic id="simpress/text/simpress/main0204.xhp">Slide View Bar</topic>
<topic id="simpress/text/simpress/main0206.xhp">Status Bar</topic>
<topic id="simpress/text/simpress/main0209.xhp">Rulers</topic>
<topic id="simpress/text/simpress/main0210.xhp">Drawing Bar</topic>
<topic id="simpress/text/simpress/main0211.xhp">Outline Bar</topic>
<topic id="simpress/text/simpress/main0212.xhp">Slide Sorter Bar</topic>
<topic id="simpress/text/simpress/main0213.xhp">Options Bar</topic>
<topic id="simpress/text/simpress/main0214.xhp">Picture Bar</topic>
<topic id="shared/text/shared/main0201.xhp">Standard Bar</topic>
<topic id="shared/text/shared/main0209.xhp">Hyperlink Bar</topic>
<topic id="shared/text/shared/main0213.xhp">Form Navigation Bar</topic>
<topic id="shared/text/shared/main0226.xhp">Form Design Toolbar</topic>
<topic id="shared/text/shared/main0227.xhp">Edit Points Bar</topic>
				</node>
			</node>
			<node id="040202" title="Drawings (%PRODUCTNAME Draw)">
				<node id="04020201" title="Menus">
<topic id="sdraw/text/sdraw/main0100.xhp">Menus</topic>
<topic id="sdraw/text/sdraw/main0101.xhp">File</topic>
<topic id="sdraw/text/sdraw/main0102.xhp">Edit</topic>
<topic id="sdraw/text/sdraw/main0103.xhp">View</topic>
<topic id="sdraw/text/sdraw/main0104.xhp">Insert</topic>
<topic id="sdraw/text/sdraw/main0105.xhp">Format</topic>
<topic id="sdraw/text/sdraw/main0106.xhp">Tools</topic>
<topic id="simpress/text/simpress/main0113.xhp">Modify</topic>
				</node>
				<node id="04020202" title="Toolbars">
<topic id="sdraw/text/sdraw/main0200.xhp">Toolbars</topic>
<topic id="sdraw/text/sdraw/main0210.xhp">Drawing Bar</topic>
<topic id="sdraw/text/sdraw/main0213.xhp">Options Bar</topic>
<topic id="shared/text/shared/main0201.xhp">Standard Bar</topic>
<topic id="shared/text/shared/main0209.xhp">Hyperlink Bar</topic>
<topic id="shared/text/shared/main0213.xhp">Form Navigation Bar</topic>
<topic id="shared/text/shared/main0226.xhp">Form Design Toolbar</topic>
<topic id="shared/text/shared/main0227.xhp">Edit Points Bar</topic>
				</node>
			</node>
		</node>
		<node id="0403" title="Loading, Saving, Importing, and Exporting">
<topic id="simpress/text/simpress/guide/html_export.xhp">Saving a Presentation in HTML Format</topic>
<topic id="simpress/text/simpress/guide/html_import.xhp">Importing HTML Pages Into Presentations </topic>
<topic id="simpress/text/simpress/guide/palette_files.xhp">Loading Color, Gradient, and Hatching Lists</topic>
<topic id="simpress/text/simpress/guide/animated_gif_save.xhp">Exporting Animations in GIF Format</topic>
<topic id="simpress/text/simpress/guide/table_insert.xhp">Including Spreadsheets in Slides</topic>
<topic id="sdraw/text/sdraw/guide/graphic_insert.xhp">Inserting Graphics</topic>
<topic id="simpress/text/simpress/guide/page_copy.xhp">Copying Slides From Other Presentations</topic>
		</node>
		<node id="0404" title="Formatting">
<topic id="simpress/text/simpress/guide/palette_files.xhp">Loading Color, Gradient, and Hatching Lists</topic>
<topic id="simpress/text/simpress/guide/line_arrow_styles.xhp">Loading Line and Arrow Styles</topic>
<topic id="sdraw/text/sdraw/guide/color_define.xhp">Defining Custom Colors</topic>
<topic id="sdraw/text/sdraw/guide/gradient.xhp">Creating Gradient Fills</topic>
<topic id="sdraw/text/sdraw/guide/eyedropper.xhp">Replacing Colors</topic>
<topic id="sdraw/text/sdraw/guide/align_arrange.xhp">Arranging, Aligning and Distributing Objects</topic>
<topic id="simpress/text/simpress/guide/background.xhp">Changing the Slide Background Fill</topic>
<topic id="simpress/text/simpress/guide/footer.xhp">Adding a Header or a Footer to All Slides</topic>
<topic id="simpress/text/simpress/guide/masterpage.xhp">Applying a Slide Design to a Slide Master </topic>
<topic id="simpress/text/simpress/guide/move_object.xhp">Moving Objects</topic>
		</node>
		<node id="0405" title="Printing">
<topic id="simpress/text/simpress/guide/printing.xhp">Printing Presentations</topic>
<topic id="simpress/text/simpress/guide/print_tofit.xhp">Printing a Slide to Fit a Paper Size</topic>
		</node>
		<node id="0406" title="Effects">
<topic id="simpress/text/simpress/guide/animated_gif_save.xhp">Exporting Animations in GIF Format</topic>
<topic id="simpress/text/simpress/guide/animated_objects.xhp">Animating Objects in Presentation Slides</topic>
<topic id="simpress/text/simpress/guide/animated_slidechange.xhp">Animating Slide Transitions</topic>
<topic id="sdraw/text/sdraw/guide/cross_fading.xhp">Cross-Fading Two Objects</topic>
<topic id="simpress/text/simpress/guide/animated_gif_create.xhp">Creating Animated GIF Images</topic>
		</node>
		<node id="0407" title="Objects, Graphics, and Bitmaps">
<topic id="sdraw/text/sdraw/guide/combine_etc.xhp">Combining Objects and Constructing Shapes</topic>
<topic id="sdraw/text/sdraw/guide/draw_sector.xhp">Drawing Sectors and Segments</topic>
<topic id="sdraw/text/sdraw/guide/duplicate_object.xhp">Duplicating Objects</topic>
<topic id="sdraw/text/sdraw/guide/rotate_object.xhp">Rotating Objects</topic>
<topic id="sdraw/text/sdraw/guide/join_objects3d.xhp">Assembling 3D Objects</topic>
<topic id="sdraw/text/sdraw/guide/join_objects.xhp">Connecting Lines</topic>
<topic id="simpress/text/simpress/guide/text2curve.xhp">Converting Text Characters into Drawing Objects</topic>
<topic id="simpress/text/simpress/guide/vectorize.xhp">Converting Bitmap Images into Vector Graphics</topic>
<topic id="simpress/text/simpress/guide/3d_create.xhp">Converting 2D Objects to Curves, Polygons, and 3D Objects</topic>
<topic id="simpress/text/simpress/guide/line_arrow_styles.xhp">Loading Line and Arrow Styles</topic>
<topic id="simpress/text/simpress/guide/line_draw.xhp">Drawing Curves</topic>
<topic id="simpress/text/simpress/guide/line_edit.xhp">Editing Curves</topic>
<topic id="sdraw/text/sdraw/guide/graphic_insert.xhp">Inserting Graphics</topic>
<topic id="simpress/text/simpress/guide/table_insert.xhp">Including Spreadsheets in Slides</topic>
<topic id="simpress/text/simpress/guide/move_object.xhp">Moving Objects</topic>
<topic id="simpress/text/simpress/guide/select_object.xhp">Selecting Underlying Objects</topic>
<topic id="simpress/text/simpress/guide/orgchart.xhp">Creating a Flowchart</topic>
		</node>
		<node id="0408" title="Groups and Layers">
<topic id="sdraw/text/sdraw/guide/groups.xhp">Grouping Objects</topic>
<topic id="simpress/text/simpress/guide/layers.xhp">About Layers</topic>
<topic id="simpress/text/simpress/guide/layer_new.xhp">Inserting Layers</topic>
<topic id="simpress/text/simpress/guide/layer_tipps.xhp">Working With Layers</topic>
<topic id="simpress/text/simpress/guide/layer_move.xhp">Moving Objects to a Different Layer</topic>
		</node>
		<node id="0409" title="Text in Presentations and Drawings">
<!-- removed sdraw/text/sdraw/guide/text_3d.xhp -->
<!-- removed sdraw/text/sdraw/guide/text_to_bitmap.xhp -->
<topic id="sdraw/text/sdraw/guide/text_enter.xhp">Adding Text</topic>
<topic id="simpress/text/simpress/guide/text2curve.xhp">Converting Text Characters into Drawing Objects</topic>
		</node>
		<node id="0410" title="Viewing">
<topic id="simpress/text/simpress/guide/individual.xhp">Creating a Custom Slide Show</topic>
<topic id="simpress/text/simpress/guide/arrange_slides.xhp">Changing the Slide Order</topic>
<topic id="simpress/text/simpress/guide/change_scale.xhp">Zooming With the Keypad</topic>
<!-- removed simpress/text/simpress/guide/livemode.xhp -->
<topic id="simpress/text/simpress/guide/rehearse_timings.xhp">Rehearse Timings of Slide Changes</topic>
		</node>
	</help_section>
</tree_view>
