<html>
<header>
<title>
  FreeType&nbsp;2 Project Files for VS.NET&nbsp;2005
</title>

<body>
<h1>
  FreeType&nbsp;2 Project Files for VS.NET&nbsp;2005
</h1>

<p>This directory contains project files for Visual C++, named
<tt>freetype.vcproj</tt>, and Visual Studio, called <tt>freetype.sln</tt>.  It
compiles the following libraries from the FreeType 2.6.2 sources:</p>

<ul>
  <pre>
    freetype262.lib     - release build; single threaded
    freetype262_D.lib   - debug build;   single threaded
    freetype262MT.lib   - release build; multi-threaded
    freetype262MT_D.lib - debug build;   multi-threaded</pre>
</ul>

<p>Be sure to extract the files with the Windows (CR+LF) line endings.  ZIP
archives are already stored this way, so no further action is required.  If
you use some <tt>.tar.*z</tt> archives, be sure to configure your extracting
tool to convert the line endings.  For example, with <a
href="http://www.winzip.com">WinZip</a>, you should activate the <em>TAR
file smart CR/LF Conversion</em> option.  Alternatively, you may consider
using the <tt>unix2dos</tt> or <tt>u2d</tt> utilities that are floating
around, which specifically deal with this particular problem.

<p>Build directories are placed in the top-level <tt>objs</tt>
directory.</p>

</body>
</html>
