<?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="textsharedguideactivexxml" indexer="include" status="PUBLISH">
<title id="tit" xml-lang="en-US">ActiveX Control to Display Documents in Internet Explorer</title>
<filename>/text/shared/guide/activex.xhp</filename>
</topic>
</meta>
<body>
<bookmark xml-lang="en-US" branch="index" id="bm_id3143267"><bookmark_value>ActiveX control</bookmark_value>
<bookmark_value>installing;ActiveX control</bookmark_value>
<bookmark_value>Internet; Internet Explorer for displaying $[officename] documents</bookmark_value>
<bookmark_value>$[officename] documents;viewing and editing in Internet Explorer</bookmark_value>
<bookmark_value>viewing;%PRODUCTNAME documents in Internet Explorer</bookmark_value>
<bookmark_value>editing;%PRODUCTNAME documents in Internet Explorer</bookmark_value>
</bookmark>
<paragraph role="heading" id="hd_id3143267" xml-lang="en-US" level="1" l10n="U" oldref="1"><variable id="activex"><link href="text/shared/guide/activex.xhp" name="ActiveX Control to Display Documents in Internet Explorer">ActiveX Control to Display Documents in Internet Explorer</link>
</variable></paragraph>
<paragraph role="paragraph" id="par_id3166410" xml-lang="en-US" l10n="U" oldref="2">Under Windows only, you can view any $[officename] document in a window of the Microsoft Internet Explorer. Install the ActiveX control in the $[officename] Setup program.</paragraph>
<paragraph role="heading" id="hd_id3156346" xml-lang="en-US" level="2" l10n="U" oldref="3">Installing the ActiveX control</paragraph>
<list type="ordered">
<listitem>
<paragraph role="listitem" id="par_id3153821" xml-lang="en-US" l10n="U" oldref="4">Close $[officename] and the Quickstarter.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3150771" xml-lang="en-US" l10n="U" oldref="5">Click the Start button on the Windows taskbar. Choose <emph>Control Panel</emph>.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_idN106E8" xml-lang="en-US" l10n="NEW">In the Control Panel, click <emph>Add or Remove Programs</emph>.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3156155" xml-lang="en-US" l10n="U" oldref="6">In the list, click %PRODUCTNAME, then click <emph>Change</emph>.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_idN10706" xml-lang="en-US" l10n="NEW">In the Installation Wizard, select <emph>Modify</emph>.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3159399" xml-lang="en-US" l10n="CHG" oldref="7">Open the <emph>Optional Components</emph> entry and find the <emph>ActiveX Control</emph> entry. Open the sub menu of the icon and select to install the feature.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3153561" xml-lang="en-US" l10n="CHG" oldref="8">Click <emph>Next</emph> and <emph>Install</emph>. </paragraph>
</listitem>
</list>
<paragraph role="heading" id="hd_id3151384" xml-lang="en-US" level="2" l10n="U" oldref="9">Viewing $[officename] documents</paragraph>
<list type="ordered">
<listitem>
<paragraph role="listitem" id="par_id3149669" xml-lang="en-US" l10n="CHG" oldref="10">In Internet Explorer, browse to a web page that contains a link to a $[officename] Writer document, for example.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3148550" xml-lang="en-US" l10n="U" oldref="11">Click the link to view the document in the Internet Explorer window.</paragraph>
<paragraph role="listitem" id="par_id3154072" xml-lang="en-US" l10n="U" oldref="12">You may still right-click the link to save the file on your harddisk.</paragraph>
</listitem>
</list>
<paragraph role="heading" id="hd_id3153361" xml-lang="en-US" level="2" l10n="U" oldref="13">Editing $[officename] documents</paragraph>
<paragraph role="paragraph" id="par_id3154367" xml-lang="en-US" l10n="U" oldref="14">The $[officename] document inside the Internet Explorer shows a set of read-only toolbar icons.</paragraph>
<list type="ordered">
<listitem>
<paragraph role="listitem" id="par_id3148451" xml-lang="en-US" l10n="U" oldref="15">Click the <emph>Edit file</emph> icon in the document's toolbar to open a copy of the document in a new $[officename] window.</paragraph>
</listitem>
<listitem>
<paragraph role="listitem" id="par_id3144760" xml-lang="en-US" l10n="U" oldref="16">Edit the copy of the document.</paragraph>
</listitem>
</list>
<section id="relatedtopics">
<embed href="text/shared/guide/ms_import_export_limitations.xhp#about"/>
<embed href="text/shared/guide/doc_open.xhp#doc_open"/>
<embed href="text/shared/guide/import_ms.xhp#import_ms"/>
<embed href="text/shared/guide/export_ms.xhp#export_ms"/>
<embed href="text/shared/guide/ms_doctypes.xhp#ms_doctypes"/>
</section>
</body>
</helpdocument>
