<?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="textsbasicshared01030400xml" indexer="include" status="PUBLISH">
<title id="tit" xml-lang="en-US">Organizing Libraries and Modules</title>
<filename>/text/sbasic/shared/01030400.xhp</filename>
</topic>
</meta>
<body>
<section id="anlegenverwalten">
<bookmark xml-lang="en-US" branch="index" id="bm_id3148797"><bookmark_value>libraries;organizing</bookmark_value>
<bookmark_value>modules;organizing</bookmark_value>
<bookmark_value>copying;modules</bookmark_value>
<bookmark_value>adding libraries</bookmark_value>
<bookmark_value>deleting;libraries/modules/dialogs</bookmark_value>
<bookmark_value>dialogs;organizing</bookmark_value>
<bookmark_value>moving;modules</bookmark_value>
<bookmark_value>organizing;modules/libraries/dialogs</bookmark_value>
<bookmark_value>renaming modules and dialogs</bookmark_value>
</bookmark><comment>mw changed"organizing;",  "dialogs;" and "renaming modules"</comment><paragraph role="heading" id="hd_id3148797" xml-lang="en-US" level="1" l10n="U" oldref="1"><variable id="01030400"><link href="text/sbasic/shared/01030400.xhp">Organizing Libraries and Modules</link>
</variable></paragraph>
</section>
<paragraph role="heading" id="hd_id3150868" xml-lang="en-US" level="2" l10n="U" oldref="4">Organizing Libraries</paragraph>
<paragraph role="heading" id="hd_id3125864" xml-lang="en-US" level="3" l10n="U" oldref="5">Creating a New Library</paragraph>
<list type="ordered">
<listitem>
<paragraph role="listitem" id="par_id3152576" xml-lang="en-US" l10n="CHG" oldref="6">Choose <emph>Tools - Macros - Organize Macros - %PRODUCTNAME Basic</emph> and click <emph>Organizer</emph> or click the <emph>Select Module</emph> icon in the Basic IDE to open the <emph>Macro Organizer</emph> dialog.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3153726" xml-lang="en-US" l10n="U" oldref="8">Click the <emph>Libraries</emph> tab.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3149664" xml-lang="en-US" l10n="CHG" oldref="9">Select to where you want to attach the library in the <emph>Location</emph> list. If you select %PRODUCTNAME Macros &amp; Dialogs, the library will belong to the $[officename] application and will be available for all documents. If you select a document the library will be attached to this document and only available from there.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3153365" xml-lang="en-US" l10n="U" oldref="10">Click <emph>New</emph> and insert a name to create a new library.</paragraph>
</listitem>
</list>
<paragraph role="heading" id="hd_id3147394" xml-lang="en-US" level="3" l10n="U" oldref="48">Appending a Library</paragraph>
<list type="ordered">
<listitem>
<paragraph role="listitem" id="par_id3153157" xml-lang="en-US" l10n="CHG" oldref="49">Choose <emph>Tools - Macros - Organize Macros - %PRODUCTNAME Basic</emph> and click <emph>Organizer</emph> or click the <emph>Select Module</emph> icon in the Basic IDE to open the <emph>Macro Organizer</emph> dialog.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3146972" xml-lang="en-US" l10n="U" oldref="50">Click the <emph>Libraries</emph> tab.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3145640" xml-lang="en-US" l10n="CHG" oldref="51">Select to where you want to append the library in the <emph>Location</emph> list. If you select %PRODUCTNAME Macros &amp; Dialogs, the library will belong to the $[officename] application and will be available for all documents. If you select a document the library will be appended to this document and only available from there.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3154253" xml-lang="en-US" l10n="U" oldref="52">Click <emph>Append</emph> and select an external library to append.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3154705" xml-lang="en-US" l10n="U" oldref="53">Select all libraries to be appended in the <emph>Append Libraries</emph> dialog. The dialog displays all libraries that are contained in the selected file.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3163807" xml-lang="en-US" l10n="U" oldref="54">If you want to insert the library as a reference only check the <emph>Insert as reference (read-only)</emph> box. Read-only libraries are fully functional but cannot be modified in the Basic IDE.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3145228" xml-lang="en-US" l10n="U" oldref="55">Check the <emph>Replace existing libraries</emph> box if you want existing libraries of the same name to be overwritten.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3147004" xml-lang="en-US" l10n="U" oldref="56">Click <emph>OK</emph> to append the library.</paragraph>
</listitem>
</list>
<paragraph role="heading" id="hd_id3159100" xml-lang="en-US" level="3" l10n="U" oldref="17">Deleting a Library</paragraph>
<list type="ordered">
<listitem>
<paragraph role="listitem" id="par_id3150086" xml-lang="en-US" l10n="CHG" oldref="18">Choose <emph>Tools - Macros - Organize Macros - %PRODUCTNAME Basic</emph> and click <emph>Organizer</emph> or click the <emph>Select Module</emph> icon in the Basic IDE to open the <emph>Macro Organizer</emph> dialog.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3146808" xml-lang="en-US" l10n="U" oldref="57">Click the <emph>Libraries</emph> tab.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3158212" xml-lang="en-US" l10n="CHG" oldref="58">Select the library to be deleted from the list.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3150361" xml-lang="en-US" l10n="U" oldref="20">Click <emph>Delete</emph>.</paragraph>
</listitem>
</list>
<list type="unordered">
<listitem>
<paragraph role="listitem" id="par_id3152986" xml-lang="en-US" l10n="U" oldref="19">Deleting a library permanently deletes all existing modules and corresponding procedures and functions.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3148868" xml-lang="en-US" l10n="U" oldref="59">You cannot delete the default library named "Standard".</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3146869" xml-lang="en-US" l10n="U" oldref="60">If you delete a library that was inserted as reference only the reference is deleted but not the library itself.</paragraph>
</listitem>
</list>
<paragraph role="heading" id="hd_id3147070" xml-lang="en-US" level="2" l10n="U" oldref="21">Organizing Modules and Dialogs</paragraph>
<paragraph role="heading" id="hd_id3155265" xml-lang="en-US" level="3" l10n="U" oldref="61">Creating a New Module or Dialog</paragraph>
<list type="ordered">
<listitem>
<paragraph role="listitem" id="par_id3154537" xml-lang="en-US" l10n="CHG" oldref="62">Choose <emph>Tools - Macros - Organize Macros - %PRODUCTNAME Basic</emph> and click <emph>Organizer</emph> or click the <emph>Select Module</emph> icon in the Basic IDE to open the <emph>Macro Organizer</emph> dialog.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3146781" xml-lang="en-US" l10n="CHG" oldref="63">Click the <emph>Modules</emph> tab or the <emph>Dialogs</emph> tab.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3159206" xml-lang="en-US" l10n="CHG" oldref="64">Select the library where the module will be inserted and click <emph>New</emph>.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3152389" xml-lang="en-US" l10n="U" oldref="65">Enter a name for the module or the dialog and click <emph>OK</emph>.</paragraph>
</listitem>
</list>
<paragraph role="heading" id="hd_id3152872" xml-lang="en-US" level="3" l10n="U" oldref="25">Renaming a Module or Dialog</paragraph>
<list type="ordered">
<listitem>
<paragraph role="listitem" id="par_id3159230" xml-lang="en-US" l10n="CHG" oldref="66">Choose <emph>Tools - Macros - Organize Macros - %PRODUCTNAME Basic</emph> and click <emph>Organizer</emph> or click the <emph>Select Module</emph> icon in the Basic IDE to open the <emph>Macro Organizer</emph> dialog.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3150046" xml-lang="en-US" l10n="CHG" oldref="67">Click the module to be renamed twice, with a pause between the clicks. Enter the new name.</paragraph>
<paragraph role="listitem" id="par_id3153801" xml-lang="en-US" l10n="CHG" oldref="27">In the Basic IDE, right-click the name of the module or dialog in the tabs at the bottom of the screen, choose <emph>Rename</emph> and type in the new name.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3155526" xml-lang="en-US" l10n="U" oldref="28">Press Enter to confirm your changes.</paragraph>
</listitem>
</list>
<paragraph role="heading" id="hd_id3146963" xml-lang="en-US" level="3" l10n="U" oldref="29">Deleting a Module or Dialog</paragraph>
<list type="ordered">
<listitem>
<paragraph role="listitem" id="par_id3147547" xml-lang="en-US" l10n="CHG" oldref="68">Choose <emph>Tools - Macros - Organize Macros - %PRODUCTNAME Basic</emph> and click <emph>Organizer</emph> or click the <emph>Select Module</emph> icon in the Basic IDE to open the <emph>Macro Organizer</emph> dialog.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3150958" xml-lang="en-US" l10n="CHG" oldref="69">Click the <emph>Modules</emph> tab or the <emph>Dialogs</emph> tab.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3149870" xml-lang="en-US" l10n="CHG" oldref="30">Select the module or dialog to be deleted from the list. Double-click an entry to reveal sub-entries, if required.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3147248" xml-lang="en-US" l10n="U" oldref="32">Click <emph>Delete</emph>.</paragraph>
</listitem>
</list>
<paragraph role="warning" id="par_id3151339" xml-lang="en-US" l10n="U" oldref="31">Deleting a module permanently deletes all existing procedures and functions in that module.</paragraph>
<paragraph role="heading" id="hd_id3151392" xml-lang="en-US" level="2" l10n="U" oldref="33">Organizing Projects among Documents or Templates</paragraph>
<paragraph role="heading" id="hd_id3156400" xml-lang="en-US" level="3" l10n="U" oldref="36">Moving or copying modules between documents, templates and the application.</paragraph>
<list type="ordered">
<listitem>
<paragraph role="listitem" id="par_id3146819" xml-lang="en-US" l10n="U" oldref="37">Open all documents or templates among which you want to move or copy the modules or dialogs.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3149319" xml-lang="en-US" l10n="CHG" oldref="38">Choose <emph>Tools - Macros - Organize Macros - %PRODUCTNAME Basic</emph> and click <emph>Organizer</emph> or click the <emph>Select Module</emph> icon in the Basic IDE to open the <emph>Macro Organizer</emph> dialog.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3145637" xml-lang="en-US" l10n="U" oldref="39">To move a module or dialog to another document, click the corresponding object in the list and drag it to the desired position. A horizontal line indicates the target position of the current object while dragging. Hold the <switchinline select="sys"><caseinline select="MAC">Command</caseinline><defaultinline>Ctrl</defaultinline></switchinline> key while dragging to copy the object instead of moving it.</paragraph>
</listitem>
</list>
</body>
</helpdocument>
