<?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="textscalc0102140500xml" indexer="include" status="PUBLISH">
<title xml-lang="en-US" id="tit">Fill Sheet</title>
<filename>/text/scalc/01/02140500.xhp</filename>
</topic>
</meta>
<body>


  <bookmark xml-lang="en-US" branch="hid/.uno:FillTable" id="bm_id3912388" localize="false"/><!-- HID added by script -->
<bookmark branch="hid/.uno:FillTable" xml-lang="en-US" id="bm_id3148664"/><paragraph role="heading" level="1" id="hd_id3153897" l10n="U" xml-lang="en-US" oldref="1">Fill Sheet</paragraph>
  <paragraph l10n="CHG" role="paragraph" id="par_id3150791" xml-lang="en-US" oldref="2"><variable id="tabellenfuellentext"><ahelp hid=".uno:FillTable" visibility="visible">Specifies the options for transferring sheets or ranges of a certain sheet.</ahelp></variable></paragraph>
  <section id="howtoget">
  <embed href="text/scalc/00/00000402.xhp#baustab"/>
</section>
  <paragraph xml-lang="en-US" role="paragraph" id="par_id3150767" l10n="U" oldref="3">In contrast to copying an area to the clipboard, you can filter certain information and calculate values. This command is only visible if you have selected two sheets in the document. To select multiple sheets, click each sheet tab while pressing <switchinline select="sys"> <caseinline select="MAC">Command</caseinline> <defaultinline>Ctrl</defaultinline> </switchinline> or Shift.</paragraph>
  <paragraph role="heading" level="2" id="hd_id3155131" l10n="CHG" xml-lang="en-US" oldref="4">Filling a Sheet</paragraph>
  <list type="unordered">
   <listitem>
    <paragraph role="listitem" id="par_id3146119" l10n="CHG" xml-lang="en-US" oldref="5">Select the entire sheet by clicking the empty gray box in the upper left of the sheet. You can also select an area of the sheet to be copied.</paragraph>
   </listitem>
   <listitem>
    <paragraph xml-lang="en-US" role="listitem" id="par_id3153726" l10n="U" oldref="6">Press <switchinline select="sys"> <caseinline select="MAC">Command</caseinline><defaultinline>Ctrl</defaultinline></switchinline> and click the tab of the sheet where you want to insert the contents.</paragraph>
   </listitem>
   <listitem>
    <paragraph xml-lang="en-US" oldref="7" l10n="U" role="listitem" id="par_id3147436">Select the command <emph>Edit - Fill - Sheet</emph>. In the dialog which appears, the check box <emph>Numbers</emph> must be selected (or <emph>Paste All</emph>) if you want to combine operations with the values. You can also choose the desired operation here.</paragraph>
   </listitem>
   <listitem>
    <paragraph xml-lang="en-US" role="listitem" id="par_id3154942" l10n="U" oldref="8">Click <emph>OK</emph>.</paragraph>
   </listitem>
  </list>
  <paragraph xml-lang="en-US" role="paragraph" id="par_id3156283" l10n="U" oldref="9">This dialog is similar to the <link href="text/shared/01/02070000.xhp" name="Paste Contents">Paste Contents</link> dialog, where you can find additional tips.</paragraph>
 </body>
</helpdocument>
