<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
<!-- /*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/ -->
<link rel="stylesheet" type="text/css" href="../../org.eclipse.wst.doc.user/common.css" />
<title>Fixing broken links using the Fixup link references wizard</title>
</head>
<body id="twlnkfix"><a name="twlnkfix"><!-- --></a>

<h1 class="topictitle1">Fixing broken links using the Fixup link references wizard</h1>
<div><div class="skipspace"> <p>You can fix broken links by double clicking on the broken link
entries in the Problems view and manually correcting the errors, however, to fix a large number of broken
links, you can use the Fixup Link References wizard. This wizard is especially
adept at fixing errors that occur if you move a file that is the target
of links to a different folder.</p>
<p>To fix links using the Fixup Link References
wizard, complete the following steps:</p>
</div>
<ol><li class="skipspace"><span>Right-click a resource (a project, folder, or file) from the  <a href="ccwebvw.html">Project Explorer</a> view.</span></li>
<li class="skipspace"><span>Select <span class="menucascade"><span class="uicontrol">Link Utilities</span> &gt; <span class="uicontrol">Fix
Broken Links</span></span> from the pop-up menu; the Fixup Link
References wizard opens.</span> The wizard populates the table with
the broken links, the suggested fixed link (if it can determine this information),
and the location of the broken link. Each link is designated by the wizard
to either be fixed or skipped, as indicated by the Fix icon (<img src="../images/fixit.gif" alt="Fix Icon" />) or the Skip icon (<img src="../images/skipit.gif" alt="Skip Icon" />)<p></p>
To change a designation,
highlight the link and click on the <b>Fix</b> button or the <b>Skip</b> button.
The icon in front of the link changes based on your choice. You can also designate
your choice by clicking directly on the icons. Note that there <u>must</u> be
data in the <b>Fixed Link</b> field before you can change these designations.
Each time you change a designation, the counter at the bottom keeps track
of how many link are selected to be fixed or skipped.</li>
<li class="skipspace"><span>You can change how the links are structured by selecting one of
the following styles from the pull-down menu: <span class="uicontrol">Use existing style</span>, <span class="uicontrol">Use
document relative links</span>, <span class="uicontrol">Use document root relative
links</span>. The <span class="uicontrol">Fixed Link</span> column is updated
to reflect the structure selection.</span></li>
<li class="skipspace"><span>You can check the <span class="uicontrol">Group links that go to the same destination</span> check
box to group all of the broken links that point to the same location into
one row in the table.</span>  Any change you make to a grouped row are
applied to all instances of that broken link.</li>
<li class="skipspace"><span>Ensure the link text in the <span class="uicontrol">Fixed Link</span> field
for each link is accurate.</span> <p>When deciding how to fix a broken
link, it can be useful to look at the <span class="uicontrol">Context</span> box,
which displays the source where the broken link is located. If you select
a different broken link in the table, the <span class="uicontrol">Context</span> view
is refreshed with the source surrounding the selected broken link. Note that
you cannot enter or change text in the <b>Context</b> box. box.</p>
<p>If the
wizard cannot suggest a way to fix the broken link,  you can manually enter
the text in the <b>Fixed Link</b> field by clicking in the field. You can
also locate a link by clicking the <span class="uicontrol">Suggestions</span> button
and navigating to the correct link.</p>
<ul><li>If you click on the <b>Suggestions</b> button, select one of the entries
in the <span class="uicontrol">Suggestions</span><b></b> field to populate the <span class="uicontrol">Fixed
Link</span> field. (Links to resources within the current project are
listed above suggestions to links to resources in external projects.)  Note
that all suggestions are structured with paths relative to the document root;
however, the <span class="uicontrol">Fixed Link</span> field in the Fixup Link Reference
wizard will be populated according to the structure you designate.</li>
<li>Alternately, click <b>Browse</b> to locate the location of the link
target manually. You can browse for a <span class="uicontrol">File</span>, <span class="uicontrol">Servlet</span>,
or <span class="uicontrol">Class</span>. </li>
</ul>
 <p>Click <span class="uicontrol">OK</span> when you are satisfied with the new
link. </p>
 The <b>Fixed Link</b> field is populated in the
table in the Fixup Link Reference wizard.</li>
<li class="skipspace"><span>When you are satisfied with your selections and the fixed link
values, click <span class="uicontrol">Fixup Links</span>. </span> The links
are all updated to reflect the values in the <span class="uicontrol">Fixed Link</span> column,
and the wizard closes.</li>
</ol>
<div class="skipspace"><p>Another useful feature when fixing broken links is the ability
to sort the broken links by location. Clicking the <span class="uicontrol">Found in Page</span> heading
sorts the rows by their location. This may be useful if you want to correct
broken links based on their page location.</p>
</div>
</div>
<div><p><b class="reltaskshd">Related tasks</b><br />
<a href="twlnkmgt.html" title="Managing links - overview"></a><br />
</p>
</div>
</body>
</html>