<?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="textshared0000000005xml" indexer="include" status="PUBLISH">
<title xml-lang="en-US" id="tit">General Glossary</title>
<filename>/text/shared/00/00000005.xhp</filename>
</topic>
</meta>
<body>
  
  
  <section id="glossarallgemein">
   
   
<bookmark xml-lang="en-US" branch="index" id="bm_id3154896"><bookmark_value>common terms;glossaries</bookmark_value>
<bookmark_value>glossaries;common terms</bookmark_value>
<bookmark_value>terminology;general glossary</bookmark_value>
</bookmark>
   <comment>mw changed "terminology;glossaries" and deleted one entry</comment>
   <paragraph xml-lang="en-US" id="hd_id3154896" role="heading" level="1" l10n="U" oldref="1"><link href="text/shared/00/00000005.xhp" name="General Glossary">General Glossary</link></paragraph>
   <paragraph xml-lang="en-US" id="par_id3154788" role="paragraph" l10n="U" oldref="2">This glossary includes explanations of some of the most important terms you will come across in $[officename].</paragraph>
   
  </section>
  <paragraph xml-lang="en-US" id="par_id3154873" role="paragraph" l10n="CHG" oldref="3">Use the glossary to look up unfamiliar terms found in any $[officename] application.</paragraph>
  
<sort order="asc">
  <section id="ascii">
   
   
<bookmark xml-lang="en-US" branch="index" id="bm_id3156192"><bookmark_value>ASCII; definition</bookmark_value>
</bookmark>
   <paragraph xml-lang="en-US" id="hd_id3156192" role="heading" level="2" l10n="U" oldref="22">ASCII</paragraph>
   <paragraph xml-lang="en-US" id="par_id3155922" role="paragraph" l10n="U" oldref="23">Abbreviation for American Standard Code for Information Interchange. ASCII is a character set for displaying fonts on personal computers. It consists of 128 characters including letters, numbers, punctuation and symbols. The extended ASCII character set contains 256 characters. Each character has been assigned a unique number, also referred to as ASCII Code.</paragraph>
   <paragraph xml-lang="en-US" id="par_id3150823" role="paragraph" l10n="CHG" oldref="24">In HTML pages, only characters from the 7 Bit ASCII character set should appear. Other characters, such as German umlauts, are distinguished by way of a separate code. You can input extended ASCII code characters: the $[officename] export filter performs the necessary conversion.</paragraph>
   
  </section>
  <section id="bezierobjekt">
   
   <paragraph xml-lang="en-US" id="hd_id3151245" role="heading" level="2" l10n="U" oldref="25">Bézier Object</paragraph>
   <paragraph xml-lang="en-US" id="par_id3154924" role="paragraph" l10n="U" oldref="26">Developed by the French mathematician Pierre Bézier, a Bézier curve is a mathematically defined curve used in two-dimensional graphic applications. The curve is defined by four points: the initial position and the terminating position, and two separate middle points. Bézier objects can be modified by moving these points with the mouse.</paragraph>
   
  </section>
  <section id="ctl">
   
   
<bookmark xml-lang="en-US" branch="index" id="bm_id3146907"><bookmark_value>CTL;definition</bookmark_value>
<bookmark_value>complex text layout;definition</bookmark_value>
<bookmark_value>complex text layout, see CTL</bookmark_value>
</bookmark>
   <comment>MW added a cross reference</comment>
   <paragraph xml-lang="en-US" id="hd_id3146907" role="heading" level="2" l10n="U" oldref="169">Complex Text Layout (CTL)</paragraph>
   <paragraph xml-lang="en-US" id="par_id3156081" role="paragraph" l10n="U" oldref="166">Languages with complex text layout may have some or all of the following features:</paragraph>
   <list type="unordered">
    <listitem>
     <paragraph xml-lang="en-US" id="par_id3145116" role="listitem" l10n="U" oldref="167">The language is written with characters or glyphs that are composed of several parts</paragraph>
    </listitem>
    <listitem>
     <paragraph xml-lang="en-US" id="par_id3154630" role="listitem" l10n="U" oldref="168">The text direction is from right to left.</paragraph>
    </listitem>
   </list>
   <paragraph xml-lang="en-US" id="par_id3148677" role="paragraph" l10n="U" oldref="170">Currently, $[officename] supports Hindi, Thai, Hebrew, and Arabic as CTL languages.</paragraph>
   <paragraph xml-lang="en-US" id="par_id3151176" role="paragraph" l10n="U" oldref="171">Enable CTL support using <emph><switchinline select="sys"><caseinline select="MAC">%PRODUCTNAME - Preferences</caseinline><defaultinline>Tools - Options</defaultinline></switchinline> - Language Settings - Languages</emph>.</paragraph>
   
  </section>
  <section id="kontextmenue">
   
   <paragraph xml-lang="en-US" id="par_idN108F1" role="heading" level="2" l10n="NEW">Context Menu</paragraph>
   <embed href="text/shared/00/00000001.xhp#par_id3156553"/>
   
  </section>
  <section id="dde">
   
   
<bookmark xml-lang="en-US" branch="index" id="bm_id3147084"><bookmark_value>DDE; definition</bookmark_value>
</bookmark>
   <paragraph xml-lang="en-US" id="hd_id3147084" role="heading" level="2" l10n="U" oldref="29">DDE</paragraph>
   <paragraph xml-lang="en-US" id="par_id3145154" role="paragraph" l10n="U" oldref="30">DDE stands for "Dynamic Data Exchange," which is a predecessor of OLE, "Object Linking and Embedding". With DDE, objects are linked through file reference, but not embedded.</paragraph>
   <paragraph xml-lang="en-US" id="par_id3154820" role="paragraph" l10n="CHG" oldref="79">You can create a DDE link using the following procedure: Select cells from a Calc spreadsheet, copy them into the clipboard and switch to another spreadsheet and select the <emph>Edit - Paste Special</emph> dialog. Select <emph>the Link</emph> option to insert the contents as a DDE link. When activating a link, the inserted cell area will be read from its original file.</paragraph>
   
  </section>
  <section id="Section7">
   
   <paragraph xml-lang="en-US" id="hd_id3150439" role="heading" level="2" l10n="U" oldref="156">Direct and Style Formatting</paragraph>
   <paragraph xml-lang="en-US" id="par_id3159254" role="paragraph" l10n="U" oldref="34">If you format a document without Styles, it is referred to as "direct" formatting. This means modifying text or other objects, such as frames or tables, by applying various attributes directly. The format applies only to the selected area and all changes must be made separately. Styles, on the other hand, are not applied to the text directly, but rather are defined in the Styles and Formatting window and then applied. One advantage is that when you change a Style, all parts of the document to which that Style is assigned are modified at the same time.</paragraph>
   <paragraph xml-lang="en-US" id="par_id3147287" role="paragraph" l10n="CHG" oldref="35">You can remove direct formatting from your document by selecting the entire text with the shortcut keys <switchinline select="sys"><caseinline select="MAC">Command</caseinline><defaultinline>Ctrl</defaultinline></switchinline>+A and then choosing <emph>Format - Default Formatting</emph>.</paragraph>
   
  </section>
  <section id="andocken">
<bookmark xml-lang="en-US" branch="index" id="bm_id3155132"><bookmark_value>windows; docking definition</bookmark_value>
<bookmark_value>docking; definition</bookmark_value>
</bookmark>
   <paragraph xml-lang="en-US" id="hd_id3155132" role="heading" level="2" l10n="U" oldref="6">Docking</paragraph>
   <paragraph xml-lang="en-US" id="par_id3154638" role="paragraph" l10n="CHG" oldref="7"><variable id="andock1">Some windows in $[officename], for example the Styles and Formatting window and the Navigator, are "dockable" windows. You can move these windows, re-size them or dock them to an edge. On each edge you can dock several windows on top of, or alongside each other; then, by moving the border lines, you can change the relative proportions of the windows.
</variable></paragraph>
   <paragraph xml-lang="en-US" id="par_id3147233" role="paragraph" l10n="CHG" oldref="127"><variable id="andock2">To undock and re-dock, holding down the <switchinline select="sys"><caseinline select="MAC">Command</caseinline><defaultinline>Ctrl</defaultinline></switchinline> key, double-click a vacant area in the window. In the Styles and Formatting window, you can also double-click a gray part of the window next to the icons, while you hold down the <switchinline select="sys"><caseinline select="MAC">Command</caseinline><defaultinline>Ctrl</defaultinline></switchinline> key.
</variable></paragraph>
   
  </section>
  <section id="andock3">
   
   <paragraph xml-lang="en-US" id="hd_id3155306" role="heading" level="2" l10n="U" oldref="10">Docking (AutoHide)</paragraph>
   <paragraph xml-lang="en-US" id="par_id3155854" role="paragraph" l10n="CHG" oldref="115">On any window edge where another window is docked you will see a button which allows you to show or hide the window.<comment>UFI: fix button removed, see spec "Window Splitter"</comment></paragraph>
   <list type="unordered">
    <listitem>
     <paragraph xml-lang="en-US" id="par_id3143274" role="listitem" l10n="CHG" oldref="161">If you click the button on the window edge to show the window, the window will remain visible until you manually hide it again (with the same button).</paragraph>
    </listitem>
    <listitem>
     <paragraph xml-lang="en-US" id="par_id3153093" role="listitem" l10n="CHG" oldref="162">If you show the window by clicking the window border, but not the button, you activate the <emph>AutoHide</emph> function. The AutoHide function allows you to temporarily show a hidden window by clicking on its edge. When you click in the document, the docked window hides again.</paragraph>
    </listitem>
   </list>
   
  </section>
  <section id="formatierung">
   
   
<bookmark xml-lang="en-US" branch="index" id="bm_id3163710"><bookmark_value>formatting; definition</bookmark_value>
</bookmark>
   <paragraph xml-lang="en-US" id="hd_id3163710" role="heading" level="2" l10n="U" oldref="32">Formatting</paragraph>
   <paragraph xml-lang="en-US" id="par_id3163821" role="paragraph" l10n="U" oldref="33">Formatting refers to the visual layout of text using a word-processing or DTP program. This includes defining the paper format, page borders, fonts and font effects, as well as indents and spacing. You can format text <link href="text/shared/00/00000005.xhp#Section7">directly or with Styles</link> provided by $[officename].</paragraph>
   
  </section>
  <section id="IME">
   
   
<bookmark xml-lang="en-US" branch="index" id="bm_id3156006"><bookmark_value>IME; definition</bookmark_value>
</bookmark>
   <paragraph xml-lang="en-US" id="hd_id3156006" role="heading" level="2" l10n="U" oldref="164">IME</paragraph>
   <paragraph xml-lang="en-US" id="par_id3157874" role="paragraph" l10n="U" oldref="165">IME stands for Input Method Editor. A program that allows the user to enter complex characters from non-western character sets using a standard keyboard.</paragraph>
   
  </section>
  <section id="jdbc">
   
   
<bookmark xml-lang="en-US" branch="index" id="bm_id3151172"><bookmark_value>JDBC; definition</bookmark_value>
</bookmark>
   <paragraph xml-lang="en-US" id="hd_id3151172" role="heading" level="2" l10n="U" oldref="111">JDBC</paragraph>
   <paragraph xml-lang="en-US" id="par_id3148386" role="paragraph" l10n="U" oldref="112">You can use the Java Database Connectivity (JDBC) API to connect to a database from %PRODUCTNAME. JDBC drivers are written in the Java programming language and are platform independent.</paragraph>
   
  </section>
  <section id="kerning">
   
   
<bookmark xml-lang="en-US" branch="index" id="bm_id3151282"><bookmark_value>kerning; definition</bookmark_value>
</bookmark>
   <paragraph xml-lang="en-US" id="hd_id3151282" role="heading" level="2" l10n="U" oldref="36">Kerning</paragraph>
   <paragraph xml-lang="en-US" id="par_id3146321" role="paragraph" l10n="U" oldref="37">Kerning means increasing or decreasing the amount of space between pairs of letters to improve the overall appearance of the text.</paragraph>
   <paragraph xml-lang="en-US" id="par_id3146078" role="paragraph" l10n="U" oldref="38">The kerning tables contain information on which pairs of letters require more spacing. These tables are generally a component of a font.</paragraph>
   
  </section>
  <section id="verknuepfung">
   
   
<bookmark xml-lang="en-US" branch="index" id="bm_id3150592"><bookmark_value>links; definition</bookmark_value>
</bookmark>
   <paragraph xml-lang="en-US" id="hd_id3150592" role="heading" level="2" l10n="U" oldref="55">Link</paragraph>
   <paragraph xml-lang="en-US" id="par_id3150092" role="paragraph" l10n="CHG" oldref="56">The <emph>Links</emph> command is found in the <emph>Edit</emph> menu. The command can only be activated when at least one link is contained in the current document. When you insert a picture, for example, you can either insert the picture directly into the document or insert the picture as a link.</paragraph>
   <paragraph xml-lang="en-US" id="par_id3145730" role="paragraph" l10n="CHG" oldref="57">When an object is inserted directly into a document, the document size increases by (at least) the size in bytes of the object. You can save the document and open it on another computer, and the inserted object will still be in the same position in the document.</paragraph>
   <paragraph xml-lang="en-US" id="par_id3144765" role="paragraph" l10n="U" oldref="58">If you insert the object as a link, only a reference to the file name is inserted. The file size of the document increases only by the path and file reference. If you open your document on another computer, however, the linked file must be in exactly the same position as given by the reference in order to view the object in the document.</paragraph>
   <paragraph xml-lang="en-US" id="par_id3153334" role="paragraph" l10n="CHG" oldref="59">Use <emph>Edit - Links</emph> to see which files are inserted as links. The links can be removed if required. This will break the link and insert the object directly.</paragraph>
   
  </section>
  <section id="zahlensystem">
   
   <paragraph xml-lang="en-US" id="hd_id3154512" role="heading" level="2" l10n="U" oldref="107">Number System</paragraph>
   <paragraph xml-lang="en-US" id="par_id3157846" role="paragraph" l10n="CHG" oldref="108">A number system is determined by the number of characters available for representing numbers. The decimal system, for instance is based on the ten numbers (0..9), the binary system is based on the two numbers 0 and 1, the hexadecimal system is based on 16 characters (0...9 and A...F).</paragraph>
   
  </section>
  <section id="objekt">
   
   
<bookmark xml-lang="en-US" branch="index" id="bm_id3156358"><bookmark_value>objects; definition</bookmark_value>
</bookmark>
   <paragraph xml-lang="en-US" id="hd_id3156358" role="heading" level="2" l10n="U" oldref="41">Object</paragraph>
   <paragraph xml-lang="en-US" id="par_id3144748" role="paragraph" l10n="U" oldref="42">An object is a screen element containing data. It can refer to application data, such as text or graphics.</paragraph>
   <paragraph xml-lang="en-US" id="par_id3153839" role="paragraph" l10n="U" oldref="43">Objects are independent and do not influence each other. Any object containing data can be assigned certain commands. For example, a graphic object has commands for image editing and a spreadsheet contains calculation commands.</paragraph>
   
  </section>
  <section id="odbc">
   
   
<bookmark xml-lang="en-US" branch="index" id="bm_id3152827"><bookmark_value>ODBC; definition</bookmark_value>
</bookmark>
   <paragraph xml-lang="en-US" id="hd_id3152827" role="heading" level="2" l10n="U" oldref="44">ODBC</paragraph>
   <paragraph xml-lang="en-US" id="par_id3153530" role="paragraph" l10n="U" oldref="45">Open Database Connectivity (ODBC) is a protocol norm with which applications can access database systems. The query language used is Structured Query Language (SQL). In $[officename], you can determine for each database whether to use SQL commands to run queries. Alternatively, you can use the interactive help to define your query by mouseclick and have it automatically translated into SQL by $[officename].</paragraph>
   <paragraph xml-lang="en-US" id="par_id3153956" role="paragraph" l10n="U" oldref="75"><switchinline select="sys"><caseinline select="WIN">The 32bit ODBC functions required here can be installed on your system at any time with the help of the setup program supplied with your database. You can then amend the properties through the Control Panel. 
</caseinline></switchinline></paragraph>
   
  </section>
  <section id="ole">
   
   
<bookmark xml-lang="en-US" branch="index" id="bm_id3154479"><bookmark_value>OLE; definition</bookmark_value>
</bookmark>
   <paragraph xml-lang="en-US" id="hd_id3154479" role="heading" level="2" l10n="U" oldref="46">OLE</paragraph>
   <paragraph xml-lang="en-US" id="par_id3157840" role="paragraph" l10n="U" oldref="47">Object Linking and Embedding (OLE) objects can be linked to a target document or may also be embedded. Embedding inserts a copy of the object and details of the source program in the target document. If you want to edit the object, simply activate the source program by double-clicking on the object.</paragraph>
   
  </section>
  <section id="opengl">
   
   
<bookmark xml-lang="en-US" branch="index" id="bm_id3154507"><bookmark_value>OpenGL; definition</bookmark_value>
</bookmark>
   <paragraph xml-lang="en-US" id="hd_id3154507" role="heading" level="2" l10n="U" oldref="98">OpenGL</paragraph>
   <paragraph xml-lang="en-US" id="par_id3146879" role="paragraph" l10n="U" oldref="99">OpenGL represents a 3D graphics language, initially developed by SGI (Silicon Graphics Inc). Two dialects of this language are commonly used: Microsoft OpenGL, developed for use under Windows NT, and Cosmo OpenGL made by SGI. The latter represents an independent graphics language for all platforms and all kind of computers, even usable on machines without special 3-D graphics hardware.</paragraph>
   
  </section>
  <section id="png">
   
   <paragraph xml-lang="en-US" id="hd_id3155764" role="heading" level="2" l10n="U" oldref="91">PNG</paragraph>
   <paragraph xml-lang="en-US" id="par_id3148993" role="paragraph" l10n="CHG" oldref="92">Portable Network Graphics (PNG) is a graphic file format. The files are compressed with a selectable compression factor, and, as opposed to the JPG format, PNG files are always compressed without any information loss.</paragraph>
   
  </section>
  <section id="primaerschluessel">
   
   <paragraph xml-lang="en-US" id="hd_id3083286" role="heading" level="2" l10n="U" oldref="103">Primary key</paragraph>
   <paragraph xml-lang="en-US" id="par_id3150323" role="paragraph" l10n="U" oldref="104">A primary key serves as a unique identifier of database fields. The unique identification of database fields is used in <link href="text/shared/00/00000005.xhp#relational">relational databases</link>, to access data in other tables. If reference is made to a primary key from another table, this is termed a foreign key.</paragraph>
   <paragraph xml-lang="en-US" id="par_id3148916" role="paragraph" l10n="CHG" oldref="113">In $[officename], you define the primary key in the design view of a table, by choosing the relevant command from the context menu of a row header for the selected field.</paragraph>
   
  </section>
  <section id="relational">
   
   <paragraph xml-lang="en-US" id="hd_id3147359" role="heading" level="2" l10n="U" oldref="100">Relational Database</paragraph>
   <paragraph xml-lang="en-US" id="par_id3147585" role="paragraph" l10n="U" oldref="101">A relational database is a collection of data items organized as a set of formally described tables from which data can be accessed or reassembled in many different ways without having to reorganize the database tables. </paragraph>
   <paragraph xml-lang="en-US" id="par_id3154255" role="paragraph" l10n="U" oldref="163">A relational database management system (RDBMS) is a program that lets you create, update, and administer a relational database. An RDBMS takes Structured Query Language (SQL) statements entered by a user or contained in an application program and creates, updates, or provides access to the database.</paragraph>
   <paragraph xml-lang="en-US" id="par_id3147535" role="paragraph" l10n="CHG" oldref="102">A good example of a relational database can be given with a database containing Customer, Purchase, and Invoice tables. In the Invoice table, there is no actual customer or purchasing data; however, the table contains references through a relational link, or a relation, to the respective customer and purchasing table's fields (for example, the customer ID field from the customer table).</paragraph>
   
  </section>
  <section id="registerhaltigkeit">
   
   
<bookmark xml-lang="en-US" branch="index" id="bm_id3147315"><bookmark_value>register-true; definition</bookmark_value>
</bookmark>
   <paragraph xml-lang="en-US" id="hd_id3147315" role="heading" level="2" l10n="U" oldref="48">Register-true</paragraph>
   <paragraph xml-lang="en-US" id="par_id3154223" role="paragraph" l10n="CHG" oldref="49">Register-true is a typography term that is used in printing. This term refers to the congruent imprint of the lines within a type area on the front and the back side of book pages, newspaper pages and magazine pages. The register-true feature make these pages easier to read by preventing gray shadows from shining through between the lines of text. The register-true term also refers to lines in adjacent text columns that are of the same height.</paragraph>
   <paragraph xml-lang="en-US" id="par_id3145230" role="paragraph" l10n="CHG" oldref="50">When you define a paragraph, Paragraph Style, or a Page Style as register-true, the base lines of the affected characters are aligned to a vertical page grid, regardless of font size or of the presence of graphics. If you want, you can specify the setting for this grid as a Page Style property.</paragraph>
   
  </section>
  <section id="rtf">
   
   <paragraph xml-lang="en-US" id="hd_id3156710" role="heading" level="2" l10n="U" oldref="70">RTF</paragraph>
   <paragraph xml-lang="en-US" id="par_id3151186" role="paragraph" l10n="U" oldref="71">Rich Text Format (RTF) is a file format developed for the exchange of text files. A special feature is that the formatting is converted into directly readable text information. Unfortunately, in comparison to other file formats, this creates relatively large files.</paragraph>
   
  </section>
  <section id="speichern">
   
   <paragraph xml-lang="en-US" id="hd_id3156372" role="heading" level="2" l10n="U" oldref="117">Saving Relatively and Absolutely</paragraph>
   <paragraph xml-lang="en-US" id="par_id3146919" role="paragraph" l10n="U" oldref="67">In various dialogs (for example, <emph>Edit - AutoText</emph>) you can select whether you want to save files relatively or absolutely.</paragraph>
   <paragraph xml-lang="en-US" id="par_id3152946" role="paragraph" l10n="U" oldref="68">If you choose to save relatively, the references to embedded graphics or other objects in your document will be saved relative to the location in the file system. In this case, it does not matter where the referenced directory structure is recorded. The files will be found regardless of location, as long as the reference remains on the same drive or volume. This is important if you want to make the document available to other computers that may have a completely different directory structure, drive or volume names. It is also recommended to save relatively if you want to create a directory structure on an Internet server.</paragraph>
   <paragraph xml-lang="en-US" id="par_id3148927" role="paragraph" l10n="U" oldref="69">If you prefer absolute saving, all references to other files will also be defined as absolute, based on the respective drive, volume or root directory. The advantage is that the document containing the references can be moved to other directories or folders, and the references remain valid.</paragraph>
   
  </section>
  <section id="drehfeld">
   
   <embed href="text/shared/00/00000001.xhp#drehfeld"/>
   
  </section>
  <section id="sql">
   
   
<bookmark xml-lang="en-US" branch="index" id="bm_id3149922"><bookmark_value>SQL;definition</bookmark_value>
</bookmark>
   <paragraph xml-lang="en-US" id="hd_id3149922" role="heading" level="2" l10n="U" oldref="53">SQL</paragraph>
   <paragraph xml-lang="en-US" id="par_id3152863" role="paragraph" l10n="U" oldref="54">Structured Query Language (SQL) is a language used for database queries. In $[officename] you can formulate queries either in SQL or interactively with the mouse.</paragraph>
   
  </section>
  <section id="sqlserver">
   
   <paragraph xml-lang="en-US" id="hd_id3147552" role="heading" level="2" l10n="U" oldref="120">SQL Database / SQL Server</paragraph>
   <paragraph xml-lang="en-US" id="par_id3159239" role="paragraph" l10n="U" oldref="121">An SQL database is a database system which offers an <link href="text/shared/00/00000005.xhp#sql">SQL</link> interface. SQL databases are often used in client/server networks in which different clients access a central server (for example, an SQL server), hence they are also called SQL server databases, or SQL servers for short.</paragraph>
   <paragraph xml-lang="en-US" id="par_id3159118" role="paragraph" l10n="CHG" oldref="122">In $[officename], you can integrate external SQL databases. These may be located on your local hard disk as well as on the network. Access is achieved through <link href="text/shared/00/00000005.xhp#odbc">ODBC</link>, JDBC, or a native driver integrated into $[officename].</paragraph>
   
  </section>
  <section id="schuster">
   
   <paragraph xml-lang="en-US" id="hd_id3166423" role="heading" level="2" l10n="U" oldref="51">Widows and Orphans</paragraph>
   <paragraph xml-lang="en-US" id="par_id3149448" role="paragraph" l10n="U" oldref="52">Widows and orphans are historical typography terms, which have been in use for many years. A widow refers to a short line at the end of a paragraph, which when printed, appears alone at the top of the next page. An orphan is, in contrast, the first line of a paragraph printed alone at the bottom of the previous page. In a $[officename] text document you can automatically prevent such occurrences in the desired Paragraph Style. When doing so, you can determine the minimum amount of lines to be kept together on a page.</paragraph>
   
  </section>
  
</sort>
 </body>
</helpdocument>
