Edit

kc3-lang/freetype/docs/INSTALL

Branch :

  • Show log

    Commit

  • Author : Werner Lemberg
    Date : 2002-05-05 10:57:06
    Hash : f83ded01
    Message : FreeType 2 can now be built in an external directory with the configure script also. * builds/freetype.mk (INCLUDES): Add `OBJ_DIR'. * builds/unix/detect.mk (have_mk): New variable to test for external build. (unix-def.mk): Defined according to value of `have_mk'. * builds/unix/unix.mk (have_mk): New variable to test for external build. Select include paths for unix-def.mk and unix-cc.mk according to value of `have_mk'. * builds/unix/unix-def.in (OBJ_BUILD): New variable. (DISTCLEAN): Use it. * builds/unix/unix-cc.in (LIBTOOL): Define default value only if not yet defined. * builds/unix/install.mk (install): Use `OBJ_BUILD' for installing freetype-config. * configure: Don't depend on bash features. (ft2_dir, abs_curr_dir, abs_ft2_dir): New variables (code partially taken from Autoconf). Build a dummy Makefile if not building in source tree. * docs/INSTALL: Document it.

  • docs/INSTALL
  • In order to build the library, read the `BUILD' document in the `docs'
    directory.  This is only a quick starter.
    
    
    I. Unix systems
    ---------------
    
      If you have GNU Make installed, simply type
    
        ./configure
        make
        make install
    
      on the command line to configure, build and install FreeType on your
      system.  Note that the default installation path is "/usr/local".
    
      Please read the file  README.UNX, it contains _critical_ information
      regarding the installation of FreeType on many Unix systems.
    
    
    II. From the command line
    -------------------------
    
      If  you are  not using  Unix, there  are two  ways to  quickly build
      FreeType 2 from the command line.
    
      The first, and favorite one, is to use the "Jam" build tool.  Jam is
      a highly  portable replacement for  Make whose control files  do not
      depend on the current platform or compiler toolset.
    
      For more information, please see:
    
        http://www.freetype.org/jam/index.html
    
      The second one is to use "GNU Make" (and NO OTHER MAKE TOOL).
    
    
      1. Building FT2 with "Jam"
      --------------------------
    
        Once you've  got *our version* of  the Jam tool  installed on your
        system, simply go to the top-level FT2 directory, then type
    
          "jam"
    
        on the command line.  This will  build the library and place it in
        the "objs" directory.
    
        By default,  a static  library is built.   On Unix systems,  it is
        possible to  build a shared library through  the "libtool" script.
        You need to have libtool  installed on your system, then re-define
        a few environment variables before invoking Jam, as in
    
           export CC="libtool --mode=compile cc"
           export LINK="libtool --mode=link cc"
           jam
    
        In  later releases  of  FT2, building  shared  libraries with  Jam
        should become automatic on Unix systems.
    
    
      2. Building FT2 with "GNU Make"
      -------------------------------
    
      You need  to have  GNU Make (version  3.78.1 or newer)  installed on
      your system to compile the library from the command line.  This will
      _NOT_ work with other make tools (including BSD make)!
    
      [Well, this is not  really correct.  Recently, a perl implementation
      of make called `makepp' has appeared which can also build FreeType 2
      successfully on  Unix platforms.   See http://makepp.sourceforge.net
      for more details.]
    
      - Go to the `freetype2' directory.
    
      - Unix (any C compiler should work):
    
          - make setup (don't worry, this will invoke a configure script)
          - make
          - make install
    
        Alternatively,  you can  pass parameters  to the  configure script
        within the CFG variable, as in:
    
          - make setup CFG="--prefix=/usr"
          - make
          - make install
    
        If the  configure script isn't run,  try to add `unix' as a target
        on the command line, e.g.:
    
          - make setup unix CFG="--prefix=/opt/experimental"
    
    
      - Windows:
    
        We provide a  version of GNU Make for Win32  on the FreeType site.
        See http://www.freetype.org/download.html for details.
    
        - gcc (Mingw, _not_ CygWin):
    
            - make setup
            - make
    
    
        - Visual C++:
    
            - make setup visualc
            - make
    
    
        - other compilers:
    
            - make setup bcc32    -> Borland C++ 32 bits
            - make setup intelc   -> Intel C++
            - make setup watcom   -> Watcom C++
            - make setup lcc      -> Win32-LCC
    
    
      If you want  to build FreeType 2 in another  directory, you must set
      two environment  variables, `OJB_DIR'  and `TOP'.  The  former gives
      the  directory where  the object  files  and the  library should  be
      created (this directory must exist), the latter the top directory of
      the FreeType 2 source tree.  Example:
    
        OBJ_DIR=~/freetype2.compiled TOP=~/freetype2 \
          make -f$TOP/Makefile setup ansi
        OBJ_DIR=~/freetype2.compiled TOP=~/freetype2 \
          make -f$TOP/Makefile
    
      On  Unix boxes,  calling  `configure' from  the  build directory  is
      sufficient;  it  will  build  a  small   Makefile  which  calls  the
      FreeType 2 Makefile with the necessary parameters.
    
    
    III. In your own environment (IDE)
    ----------------------------------
    
      You need to add  the directories "freetype2/include" to your include
      path when compiling the library.
    
      FreeType  2 is  made  of several  components;  each one  of them  is
      located   in  a  subdirectory   of  "freetype2/src".   For  example,
      `freetype2/src/truetype/' contains the TrueType font driver.
    
      DO NOT COMPILE ALL C FILES!  Rather, compile the following ones:
    
        -- base components (required)
    
          src/base/ftsystem.c
          src/base/ftinit.c
          src/base/ftdebug.c
          src/base/ftbase.c
          src/base/ftglyph.c
          src/base/ftbbox.c
          src/base/ftmm.c
    
          src/base/ftmac.c        -- only on the Macintosh
    
        -- other components are optional
    
          src/autohint/autohint.c -- auto hinting module
          src/cache/ftcache.c     -- cache sub-system (in beta)
          src/sfnt/sfnt.c         -- SFNT files support
                                     (TrueType & OpenType)
          src/cff/cff.c           -- CFF/OpenType font driver
          src/psnames/psnames.c   -- Postscript glyph names support
          src/psaux/psaux.c       -- Postscript Type 1 parsing
          src/truetype/truetype.c -- TrueType font driver
          src/type1/type1.c       -- Type 1 font driver
          src/cid/type1cid.c      -- Type 1 CID-keyed font driver
          src/winfonts/winfonts.c -- Windows FONT / FNT font driver
    
        Note:
    
           `truetype.c' needs `sfnt.c' and `psnames.c'
           `type1.c'    needs `psaux.c' and `psnames.c'
           `type1cid.c' needs `psaux.c' and `psnames.c'
           `cff.c'      needs `sfnt.c', `psaux.c', and `psnames.c'
    
           etc.
    
    For more information, please consult "docs/BUILD".
    
    --- end of INSTALL --