sgindgen.cpp

Go to the documentation of this file.

// $Id: sgindgen.cpp 1361 2006-06-25 16:43:38Z alex $
/* @@tag:xara-cn@@ DO NOT MODIFY THIS LINE
================================XARAHEADERSTART===========================
 
               Xara LX, a vector drawing and manipulation program.
                    Copyright (C) 1993-2006 Xara Group Ltd.
       Copyright on certain contributions may be held in joint with their
              respective authors. See AUTHORS file for details.

LICENSE TO USE AND MODIFY SOFTWARE
----------------------------------

This file is part of Xara LX.

Xara LX is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License version 2 as published
by the Free Software Foundation.

Xara LX and its component source files are distributed in the hope
that it will be useful, but WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with Xara LX (see the file GPL in the root directory of the
distribution); if not, write to the Free Software Foundation, Inc., 51
Franklin St, Fifth Floor, Boston, MA  02110-1301 USA


ADDITIONAL RIGHTS
-----------------

Conditional upon your continuing compliance with the GNU General Public
License described above, Xara Group Ltd grants to you certain additional
rights. 

The additional rights are to use, modify, and distribute the software
together with the wxWidgets library, the wxXtra library, and the "CDraw"
library and any other such library that any version of Xara LX relased
by Xara Group Ltd requires in order to compile and execute, including
the static linking of that library to XaraLX. In the case of the
"CDraw" library, you may satisfy obligation under the GNU General Public
License to provide source code by providing a binary copy of the library
concerned and a copy of the license accompanying it.

Nothing in this section restricts any of the rights you have under
the GNU General Public License.


SCOPE OF LICENSE
----------------

This license applies to this program (XaraLX) and its constituent source
files only, and does not necessarily apply to other Xara products which may
in part share the same code base, and are subject to their own licensing
terms.

This license does not apply to files in the wxXtra directory, which
are built into a separate library, and are subject to the wxWindows
license contained within that directory in the file "WXXTRA-LICENSE".

This license does not apply to the binary libraries (if any) within
the "libs" directory, which are subject to a separate license contained
within that directory in the file "LIBS-LICENSE".


ARRANGEMENTS FOR CONTRIBUTION OF MODIFICATIONS
----------------------------------------------

Subject to the terms of the GNU Public License (see above), you are
free to do whatever you like with your modifications. However, you may
(at your option) wish contribute them to Xara's source tree. You can
find details of how to do this at:
  http://www.xaraxtreme.org/developers/

Prior to contributing your modifications, you will need to complete our
contributor agreement. This can be found at:
  http://www.xaraxtreme.org/developers/contribute/

Please note that Xara will not accept modifications which modify any of
the text between the start and end of this header (marked
XARAHEADERSTART and XARAHEADEREND).


MARKS
-----

Xara, Xara LX, Xara X, Xara X/Xtreme, Xara Xtreme, the Xtreme and Xara
designs are registered or unregistered trademarks, design-marks, and/or
service marks of Xara Group Ltd. All rights in these marks are reserved.


      Xara Group Ltd, Gaddesden Place, Hemel Hempstead, HP2 6EX, UK.
                        http://www.xara.com/

=================================XARAHEADEREND============================
 */
// Gallery index generation classes

/*
*/

#include "camtypes.h"
#include "sgindgen.h"

/*#include "ccfile.h"
//#include "pathname.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "thumb.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "sgliboil.h"
//#include "richard.h"
#include "progress.h"
//#include "resource.h"
//#include "errors.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "fixmem.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#ifndef WEBSTER
#include "extfilts.h"
#include "imglib.h"
#include "img_err.h"
#endif  //WEBSTER
//#include "accures.h"
//#include "oilfltrs.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "resource.h"
#include "sgscanf.h"
//#include "simon.h"        // for _R(IDS_CONTINUE)
//#include "sgscan.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "richard2.h"
//#include "camfiltr.h" // BaseCamelotFilter - new version 2 native/web filter - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "cxfdefs.h"      // CXF_IDWORD1, signature of new file format - in camtypes.h [AUTOMATICALLY REMOVED]

#include "bmpexdoc.h"
#include "bmpfiltr.h"
#include "prvwflt.h"
//#include "docview.h" - in camtypes.h [AUTOMATICALLY REMOVED]
*/

extern BOOL MakeShortPath(LPTSTR lpszPath, size_t cchMaxLen);

DECLARE_SOURCE("$Revision: 1361 $");

CC_IMPLEMENT_DYNCREATE(GenerateIndexFile, CCObject)
CC_IMPLEMENT_DYNCREATE(IndGenFileBuffer, CCObject)

PORTNOTE("other", "Removed most of sgindgen.cpp" )
#ifndef EXCLUDE_FROM_XARALX

#define new CAM_DEBUG_NEW

// Static initialisation

// Preference setting saying whether thumbnail generation is required   
#ifdef _DEBUG
#ifdef _BATCHING
BOOL GenerateIndexFile::CreateFontIndexes = TRUE;
#else
BOOL GenerateIndexFile::CreateFontIndexes = FALSE;
#endif
#else
BOOL GenerateIndexFile::CreateFontIndexes = FALSE;
#endif

// Use old indexes and doc comments for index generation
BOOL GenerateIndexFile::UseOldIndexes = TRUE;
BOOL GenerateIndexFile::UseDocComments = TRUE;

// Use automatic index update technology ?
BOOL GenerateIndexFile::UseAutomaticUpdate = FALSE;

// define this to add filenames without their extensions as default descriptions
//#define FILENAME_AS_DEFAULT_DESCRIPTION

// Display warnings unless told not to
static BOOL QuietThumbnail = FALSE;

// Keep doing index until told not to
static BOOL StopIndGen = FALSE;

static FilePos LastFoundItemInIndex = 0;

// Tmp disk file for index ripping
//CCDiskFile *TmpDiskFile = NULL;

#endif

/***********************************************************************************************

>   GenerateIndexFile::GenerateIndexFile()

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    27/05/95

    Inputs:     
    Outputs:
    Returns:

    Purpose:    Variable initalising constructor
    Notes:

***********************************************************************************************/

GenerateIndexFile::GenerateIndexFile()
{
    LibType = SGLib_Blank;
    DoThumbnails = FALSE;
    Author = _T("");
    IndexFile = NULL;
    IndexCountOff = 0;
    hSearch = NULL;
    ID = 0;
    TotalFiles = 0;
    TmpIndexFile = NULL;
    OldIndexStart = 0;
    OldIndexDescriptionField = OldIndexKeywordField = OldIndexTitleField = 0;
    OldIndexOK = FALSE;
    OldIndexDescription = "";
//  TmpDiskFile = NULL;
}

#if 0

/***********************************************************************************************

>   BOOL GenerateIndexFile::CloseSearchHandle(void);

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    09/04/95

    Inputs:     
    Outputs:
    Returns:    TRUE if things went ok.

    Purpose:    Close the search handle
    Notes:

***********************************************************************************************/

BOOL GenerateIndexFile::CloseSearchHandle(void)
{
    // Close the search handle
    if(hSearch != NULL) {
        if (!FindClose(hSearch)) {
            ERROR3("Couldn't close search handle.");
            return FALSE;
        }
        else
        {
            hSearch = NULL;
        }
    }
    return TRUE;
}
    
/***********************************************************************************************

>   BOOL GenerateIndexFile::CloseIndexFileHandle(void);

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    09/04/95

    Inputs:     
    Outputs:
    Returns:    TRUE if things went ok.

    Purpose:    Close the file handle
    Notes:

***********************************************************************************************/

BOOL GenerateIndexFile::CloseIndexFileHandle(void)
{
    if(IndexFile != NULL)
    {
        IndexFile->close();
        delete IndexFile;
        IndexFile = NULL;
    }
    return TRUE;
}


/***********************************************************************************************

>   static BOOL GenerateIndexFile::IsDirectoryReadOnly(PathName *Directory);

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    07/04/95

    Inputs:     Directory   - location of directory we're interested in (without trailing \)
    Outputs:
    Returns:    TRUE if things the specified directory is read only

    Purpose:    See Returns...
    Notes:

***********************************************************************************************/

BOOL GenerateIndexFile::IsDirectoryReadOnly(PathName *Directory)
{
    ERROR3IF(Directory == NULL, "GenerateIndexFile::IsDirectoryReadOnly given a NULL dir");

    String_256 ROPathStr(Directory->GetPath(TRUE));
    ROPathStr += TEXT("XaraInf");               // Read only check - not displayed, etc...
    PathName ROPath(ROPathStr);
    Error::ClearError();

    CCDiskFile ROFile(1024, FALSE, TRUE);
    BOOL ReadOnly = TRUE;
    BOOL CreatedFile = FALSE;

    // Exceptions here mean the directory is RO (or there was some other problem)
    TRY
    {
        CreatedFile = ROFile.open(ROPath, ios::out);
    }
        
    CATCH(CFileException, e)
    {
        // The directory with the files in is READ ONLY...
        ReadOnly = TRUE;
        Error::ClearError();
    }
    END_CATCH

    // Make sure that the files are closed and the memory is reclaimed properly...
    if (ROFile.isOpen())
        ROFile.close();

    if(CreatedFile)
    {
        SGLibOil::FileDelete(&ROPath);
        return FALSE;
    }

    return TRUE;
}

/***********************************************************************************************

>   static BOOL GenerateIndexFile::CheckForRemote(PathName *FilesDirectory, String_256 *RemoteDirectory);

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    07/04/95

    Inputs:     FilesDirectory  - location of directory with files in, on read only media
    Outputs:    RemoteDirectory - location of existing indexed remote directory
    Returns:    TRUE if we found a remote index directory

    Purpose:    Given a directory on a CD (for example), check whether we've already done
                a remote index for it or not... And return its location.
    Notes:

***********************************************************************************************/

BOOL GenerateIndexFile::CheckForRemote(PathName *FilesDirectory, String_256 *RemoteDirectory)
{
    ERROR3IF(FilesDirectory == NULL || RemoteDirectory == NULL, "GenerateIndexFile::CheckForRemote given NULL args");

    *RemoteDirectory = Library::RemoteIndexLocation;
    BOOL UseTmp = FALSE;

    if(RemoteDirectory->Length()==0)
        UseTmp = TRUE;
    else
    {
        PathName RemLocPath(*RemoteDirectory);
        if(!RemLocPath.IsValid() || !SGLibOil::FileExists(&RemLocPath) || IsDirectoryReadOnly(&RemLocPath))
            UseTmp = TRUE;
    }

    if(UseTmp)
    {
        TCHAR *OSTMP = _tgetenv("TEMP");
        if(OSTMP == NULL)
        {
            //PathName RemLocPath(*RemoteDirectory);

            // Check the specified remote directory isn't read only
            //if(IsDirectoryReadOnly(&RemLocPath) || RemLocPath)
            //{
            *RemoteDirectory = TEXT("");
            return FALSE;
            //}
        }

        camStrcpy((TCHAR *)*RemoteDirectory, OSTMP);
    }

    String_256 TmpDir(FilesDirectory->GetFileName(FALSE));
    String_256 FPath(FilesDirectory->GetPath());

    if(SGLibOil::IsRootDirectory(&FPath))
    {
/*      String_256 Test("\\\\deepfried\\chicken");
        GiveMeAValidDirectoryName(&Test, &TmpDir);
        ERROR3_PF(("%s -> %s", (TCHAR *)Test, (TCHAR *)TmpDir));

        Test = "a:\\";
        GiveMeAValidDirectoryName(&Test, &TmpDir);
        ERROR3_PF(("%s -> %s", (TCHAR *)Test, (TCHAR *)TmpDir));

        Test = "\\fred\\fish";
        GiveMeAValidDirectoryName(&Test, &TmpDir);
        ERROR3_PF(("%s -> %s", (TCHAR *)Test, (TCHAR *)TmpDir));

        Test = "\\\\fred\\fish";
        GiveMeAValidDirectoryName(&Test, &TmpDir);
        ERROR3_PF(("%s -> %s", (TCHAR *)Test, (TCHAR *)TmpDir));

        Test = "\\\\fred\\fish\\fosh";
        GiveMeAValidDirectoryName(&Test, &TmpDir);
        ERROR3_PF(("%s -> %s", (TCHAR *)Test, (TCHAR *)TmpDir));

        Test = "x\\\\fred\\fish\\fosh";
        GiveMeAValidDirectoryName(&Test, &TmpDir);
        ERROR3_PF(("%s -> %s", (TCHAR *)Test, (TCHAR *)TmpDir));

        Test = "\\\\wibble";
        GiveMeAValidDirectoryName(&Test, &TmpDir);
        ERROR3_PF(("%s -> %s", (TCHAR *)Test, (TCHAR *)TmpDir));

        Test = "\\\\wibble\\";
        GiveMeAValidDirectoryName(&Test, &TmpDir);
        ERROR3_PF(("%s -> %s", (TCHAR *)Test, (TCHAR *)TmpDir));

        Test = "\\\\wibble\\\\";
        GiveMeAValidDirectoryName(&Test, &TmpDir);
        ERROR3_PF(("%s -> %s", (TCHAR *)Test, (TCHAR *)TmpDir));

        Test = "\\\\wibble\\ ";
        GiveMeAValidDirectoryName(&Test, &TmpDir);
        ERROR3_PF(("%s -> %s", (TCHAR *)Test, (TCHAR *)TmpDir));*/

        if(!GiveMeAValidDirectoryName(&FPath, &TmpDir))
            return FALSE;
    }

    // Well, we could do it, but it's a little nasty using temp\xarainfo aot temp\something\xarainfo
    if(TmpDir.Length() == 0)
        return FALSE;

    SGLibOil::AppendSlashIfNotPresent(RemoteDirectory);
    *RemoteDirectory += TmpDir;

    PathName RemLocPath(*RemoteDirectory);
    if(RemLocPath.IsValid() && SGLibOil::FileExists(&RemLocPath) && !IsDirectoryReadOnly(&RemLocPath))
        return TRUE;
    else
        return FALSE;
}


/***********************************************************************************************

>   static BOOL GenerateIndexFile::GiveMeAValidDirectoryName(String_256 *Input, String_256 *Output)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    20/02/96

    Inputs:     Input   - String of random characters -> "\\deepthought\fishcake", "a:\", "hg23~';e#y", etc
    Outputs:    Output  - String which could be used as a directory name -> "deepthou", "a", "hg23ey"
    Returns:    TRUE if things went ok, FALSE if no valid chars were found...

    Purpose:    Given a random string, construct a valid directory name from the string. This is
                smashing if we want a directory name from a root directory, etc...

***********************************************************************************************/

BOOL GenerateIndexFile::GiveMeAValidDirectoryName(String_256 *Input, String_256 *Output)
{
    ERROR3IF(Input == NULL || Output == NULL, "GenerateIndexFile::GiveMeAValidDirectoryName given NULL params");

    if(Input == NULL || Output == NULL)
        return FALSE;

    INT32 Length = Input->Length();
    Output->Empty();
    INT32 StartIndex = 0;

    if(Input->Sub(String_8("\\\\")) == 0 && Input->CountChar('\\') > 2)
    {
        String_256 Tmp;
        Input->Right(&Tmp, Length - 2);

        // Tmp now holds string minus the \\ at the start, so we can get an index to the third \ in the string
        StartIndex = Tmp.Sub(String_8("\\")) + 2;

        if((Length - StartIndex) < 2)
            StartIndex = 0;
    }

    for(INT32 i = StartIndex; i <= Length; i++)
    {
        if(Output->Length() < 8)
        {
            if(iswalnum((*Input)[i])) // != '\\' && (*Input)[i] != ':')
                *Output += TEXT((*Input)[i]); 
        }
    }

    if(Output->Length() > 0)
        return TRUE;

    return FALSE;
}

/***********************************************************************************************

>   BOOL GenerateIndexFile::RemoteIndexSetup(PathName *FilesPath);

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    07/04/95

    Inputs:     
    Outputs:
    Returns:    TRUE if things went ok and we're using a remote index.

    Purpose:    Check with the user that it's ok to use a remote index, and find a sensible
                location to put it.
    Notes:

***********************************************************************************************/

BOOL GenerateIndexFile::RemoteIndexSetup(PathName *FilesPath)
{
    ERROR3IF(FilesPath == NULL, "GenerateIndexFile::RemoteIndexSetup passed a null path");

    IndexIsRemote = FALSE;
    RemoteLocationOfIndex = "";
    RemoteLocationOfFiles = "";

    if(!Library::RemoteIndexes)
        return FALSE;

    BOOL Existing = CheckForRemote(FilesPath, &RemoteLocationOfIndex);

    if(RemoteLocationOfIndex.Length() == 0)
        return FALSE;

    // Only report this if the user hasn't already found the index for us...
    if(!SGLibOil::FileExists(&Index))
    {
        // "The chosen folder appears to be read only. Would you like to use '#1%s' for the index and thumbnail data? etc..."
        String_256 Msg;
        String_256 SmallLocation;
        RemoteLocationOfIndex.Left(&SmallLocation, 100);
        Msg.MakeMsg(_R(IDS_LIBRARY_CREATE_REMOTE), (TCHAR *)SmallLocation);
        Error::SetError(0, Msg, 0);
        INT32 ButtonPressed = InformWarning(0, _R(IDS_CREATE), _R(IDS_CANCEL));
        Error::ClearError();

        if(ButtonPressed != 1)
            return FALSE;
    }

    // Pathname for the index file -> c:\clipart\jobby\xarainfo
    PathName TmpPath(RemoteLocationOfIndex);

    if(!SGLibOil::FileExists(&TmpPath))
    {
        // Create the Xarainfo\.. directory
        if (!CreateDirectory((TCHAR *)RemoteLocationOfIndex, NULL))
        {
            DWORD err = GetLastError();     
            ERROR3("Can't create Tmp Index directory");
            return FALSE;
        }
    }

    IndexIsRemote = TRUE;
    SGLibOil::AppendSlashIfNotPresent(&RemoteLocationOfIndex);
    /*if(RemoteLocationOfIndex[RemoteLocationOfIndex.Length()-1] != '\\')
        RemoteLocationOfIndex += TEXT("\\");*/
    RemoteLocationOfIndex += String_16(_R(IDS_LIBRARIES_XARAINFO_DIRNAME));
    RemoteLocationOfFiles = FilesPath->GetPath(FALSE);

    return TRUE;
}


/***********************************************************************************************

>   BOOL GenerateIndexFile::CreateIndexFile(void);

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    09/04/95

    Inputs:     
    Outputs:
    Returns:    TRUE if things went ok.

    Purpose:    Create the index file and keywords file then add headers to them                                                       
    Notes:

***********************************************************************************************/

BOOL GenerateIndexFile::CreateIndexFile(void)
{
    if(!GenerateIndexFile::CreateFontIndexes && LibType == SGLib_Font)
        return FALSE;

    String_256 XIPathStr;

    // Check that we have write access to the directory in question...
    if(IsDirectoryReadOnly(&LibPath))
    {
        // The directory with the files in is READ ONLY...
        Error::ClearError();

        if(RemoteIndexSetup(&LibPath))
        {
            XIPathStr = RemoteLocationOfIndex;
            IndexIsRemote = TRUE;

            String_256 NewIndex(RemoteLocationOfIndex);
            SGLibOil::AppendSlashIfNotPresent(&NewIndex);
            /*if(NewIndex[NewIndex.Length()-1] != '\\')
                NewIndex += TEXT("\\");*/
            NewIndex += Index.GetFileName(TRUE);

            Index = NewIndex;
        }
        else
        {
            // Can't find a sensible temp directory, or remote indexes aren't enabled...
            // Tell the user that their media is read only...
            InformWarning(_R(IDS_READONLY_MEDIA), _R(IDS_OK));
            XIPathStr = LibPath.GetPath(TRUE);
            XIPathStr += String_16(_R(IDS_LIBRARIES_XARAINFO_DIRNAME));
            IndexIsRemote = FALSE;
        }
    }
    else
    {
        XIPathStr = LibPath.GetPath(TRUE);
        XIPathStr += String_16(_R(IDS_LIBRARIES_XARAINFO_DIRNAME));
        IndexIsRemote = FALSE;
    }

    /***********************************************************************************/

    // Pathname for the index file -> c:\clipart\jobby\xarainfo
    PathName XIPath(XIPathStr);

    if(!SGLibOil::FileExists(&XIPath))
    {
        // Create the Xarainfo directory
        if (!CreateDirectory((TCHAR *)XIPathStr, NULL))
        {
            DWORD err = GetLastError();     
            ERROR3("Can't create XaraInfo directory");
            return FALSE;
        }
    }

    // This should only be true if we've succesfully found an old index, scanned its header
    // and copied it to and index.bak file
    OldIndexOK = FALSE;

    // If there's already an index file there, make a backup...
    if(SGLibOil::FileExists(&Index) && GenerateIndexFile::UseOldIndexes)
    {
        TmpIndexFile = new PathName(Index); /*(String_256)"C:\\Xaraclip.BAK");*/
        if(TmpIndexFile != NULL)
        {
            TmpIndexFile->SetType("BAK");
            SGLibOil::FileCopy(&Index, TmpIndexFile);

            OldIndexOK = PrePassIndex(TmpIndexFile, &OldIndexStart, &OldIndexDescriptionField,
                            &OldIndexKeywordField, &OldIndexTitleField, &OldIndexDescription);
        }
    }

    IndexFile = new CCDiskFile(1024, TRUE, FALSE);
    if(IndexFile == NULL)
    {
        ERROR3("Null index file allocated");
        return FALSE;
    }

    if(!IndexFile->open(Index, ios::out))
    {
        TRACEUSER( "Richard", _T("Can't open index file"));
        delete IndexFile;
        IndexFile = NULL;
        return FALSE;
    }

    return TRUE;
}

/***********************************************************************************************

>   BOOL GenerateIndexFile::DoIndexHeader(void);

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    09/04/95

    Inputs:     
    Outputs:
    Returns:    TRUE if things went ok.

    Purpose:    Add all the header data to an index file
    Notes:

***********************************************************************************************/

BOOL GenerateIndexFile::DoIndexHeader(void)
{
    String_256 Line(_R(IDS_LIBRARIES_INDEX_FILE_FOR));
    Line += LibPath.GetFileName();
    Line += TEXT("\r\n");
    AddLineToIndex(&Line);

//  _stprintf(Line, "#\r\n# Entry count:\r\n");
//  AddLineToIndex(&Line);

    IndexCountOff = IndexFile->tell();

    ID = 0;
    wsprintf(Line, "%05d", TotalFiles);
    Line += TEXT("\r\n");
    AddLineToIndex(&Line);

//  _stprintf(Line, "# Synonym file:\r\nSynonyms.txt\r\n");
    Line = _R(IDS_LIBRARIES_SYNONYM_FILENAME);
    Line += TEXT("\r\n");
    AddLineToIndex(&Line);

//  _stprintf(Line, "# Thumbnail sizes (Small, Medium, Large):\r\n");
//  AddLineToIndex(&Line);

    // Fonts have weird thumbnail sizes
    if(LibType == SGLib_Font)
        Line = TEXT("28,16, 160,12, 180,26\r\n");
    else
        Line = TEXT("45,45, 130,64, 130,130\r\n");

//      _stprintf(Line, "32,32, 64,64, 128,128\r\n");

    AddLineToIndex(&Line);
    
    // "Filename, Description, ID, Title, Key, Size\r\n"
    Line = String_16(_R(IDS_LIBRARIES_INDEX_ITEM_FILENAME));
    Line += TEXT(", ");
    Line += String_16(_R(IDS_LIBRARIES_INDEX_ITEM_DESC));
    Line += TEXT(", ");
    Line += String_16(_R(IDS_LIBRARIES_INDEX_ITEM_ID));
    Line += TEXT(", ");
    Line += String_16(_R(IDS_LIBRARIES_INDEX_ITEM_TITLE));
    Line += TEXT(", ");
    Line += String_16(_R(IDS_LIBRARIES_INDEX_ITEM_KEY));
    Line += TEXT(", ");
    Line += String_16(_R(IDS_LIBRARIES_INDEX_ITEM_SIZE));
    Line += TEXT("\r\n");
    AddLineToIndex(&Line);

    String_256 Description;
    if(OldIndexDescription.Length() == 0 || !GenerateIndexFile::UseOldIndexes)
    {
        String_256 TmpPath(LibPath.GetPath());
        LibraryFile::TidyUpSubPath(&TmpPath);
        TmpPath.Left(&Description, 60);
    }
    else
        Description = OldIndexDescription;  

    Line = TEXT("#");
    Line += String_16(_R(IDS_LIBRARIES_INDEX_DESCRITION)); // "#DESCRIPTION:"
    Line += TEXT(" ") + Description;
    Line += TEXT("\r\n");
    AddLineToIndex(&Line);

    if(IndexIsRemote)
    {
        Line = _R(IDS_LIBRARIES_INDEX_FILES);
        Line += TEXT(" ") + RemoteLocationOfFiles;
        Line += TEXT("\r\n");
        AddLineToIndex(&Line);
    }

    Line = _R(IDS_LIBRARIES_INDEX_START);
    Line += TEXT("\r\n");
    AddLineToIndex(&Line);

    return TRUE;
}

/***********************************************************************************************

>   BOOL GenerateIndexFile::AddToSubLibrary(void);

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    09/04/95

    Inputs:     
    Outputs:
    Returns:    TRUE if things went ok.

    Purpose:    This little baby scans a directory for all the files we're expecting and adds
                sensible dummy entries into the Index file...
    Notes:

***********************************************************************************************/

BOOL GenerateIndexFile::AddToSubLibrary(void)
{
    BOOL Problems = FALSE;
    INT32 Count = FileNameBuffer.ItemCount();
    INT32 i = 0;

    while(i < Count)
    {
        TCHAR *Item = FileNameBuffer.GetItem(i);
        i++;

        if(Item != NULL)
        {
            PathName FileToAdd(Item);

            if(!AddFile(&FileToAdd))
            {
                ERROR3("Problems adding file to index or keyword file - or ESC pressed");
                Problems = TRUE;
                i = Count;
            }
        }
    }

    return !Problems;
}

/***********************************************************************************************

>   INT32 GenerateIndexFile::CountValidFiles(void);

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    24/04/95

    Inputs:     
    Outputs:
    Returns:    Number of files that have 'add to index' potential for this type of library

    Purpose:    Counts what it returns
    Notes:

***********************************************************************************************/

INT32 GenerateIndexFile::CountValidFiles(void)
{
    // Progress bar for generation status
    String_64 Status(_R(IDS_LIBRARY_CREATION_SCANNING));
    BeginSlowJob(-1, FALSE, &Status);

    INT32 Count = 0;
    BOOL Counting = TRUE;
    BOOL Creating = FALSE;
    INT32 Pass = 0;
    BOOL ok = TRUE;

    String_256 FileSearch((const TCHAR *)LibPath.GetPath(TRUE));    
    FileSearch += TEXT("*.*");

    WIN32_FIND_DATA FileData;
    BOOL fFinished;

    // We go through the below code twice.
    // The first time we just count the number of files, so we know how big to make the
    // array for the second pass...
    do
    {
        Pass ++;
        Counting = (Pass == 1);
        Creating = (Pass == 2);

        fFinished = FALSE;
        hSearch = 0;

        // Start searching for files
        hSearch = FindFirstFile(FileSearch, &FileData);
        if (hSearch == INVALID_HANDLE_VALUE)
        {
            ERROR3("No valid files found in this directory");
            fFinished = TRUE;
        }

        while (!fFinished)
        {
            // Add full pathname to file
            String_256 FileToAddStr((const TCHAR *)LibPath.GetPath(TRUE));
            FileToAddStr += (TCHAR *)FileData.cFileName;

            // Only use normal files - not directories, hidden files, etc...
            DWORD FileAttributes = GetFileAttributes(FileToAddStr);

            if( ((FileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
                (FileAttributes & FILE_ATTRIBUTE_HIDDEN) ||
                (FileAttributes & FILE_ATTRIBUTE_SYSTEM)) == 0)
            {
                PathName FileToAdd(FileToAddStr);

                // Check if the file is addable to the index
                if(IsFileType(&FileToAdd, LibType))
                {
                    // First or second pass (first == counting files, second == adding files)
                    if(Counting)
                        Count ++;

                    // Second pass, allocate memory for string and add it into the buffer
                    if(Creating)
                        FileNameBuffer.AddItem((TCHAR *)FileToAddStr);
                }
            }
        
            // Find the next file
            if (!FindNextFile(hSearch, &FileData))
                fFinished = TRUE;
        }

        // Close the search handle
        if(!CloseSearchHandle())
            ERROR3("Couldn't close search handle.");

        if(Count != 0 && Counting)
        {
            ok = FileNameBuffer.Init(Count);
        }

        if(Count != 0 && Creating)
        {
            ok = FileNameBuffer.Sort();
        }


    } while(Count != 0 && Pass < 2 && ok);

    EndSlowJob();
    return Count;
}

#endif

/***********************************************************************************************

>   IndGenFileBuffer::IndGenFileBuffer()

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/05/95

    Inputs:
    Outputs:
    Returns:

    Purpose:    Constructor
    Notes:      Since MSDOS seems happy returning filenames of files in a directory in a
                completely random fashion, we need to have some way of storing all the ones
                it returns us and sorting them alphabetically, so we can generate index files
                in a nice alphabetical order.

                The data structure used below is basically an array of TCHAR *'s pointed to
                by Buffer. These TCHAR *'s are CCMalloced and given variable length C style
                strings by AddItem. The destructor handles the memory tidying up.

***********************************************************************************************/

IndGenFileBuffer::IndGenFileBuffer()
{
    Buffer = NULL;
    Items = 0;
    Position = 0;
}

/***********************************************************************************************

>   IndGenFileBuffer::~IndGenFileBuffer()

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/05/95

    Inputs:
    Outputs:
    Returns:

    Purpose:    Destructor - frees all the memory
    Notes:

***********************************************************************************************/

IndGenFileBuffer::~IndGenFileBuffer()
{   
    if(Buffer != NULL)
    {
        for(INT32 i = 0; i<Items; i++)
        {
            if(Buffer[i] != NULL)
                CCFree(Buffer[i]);
        }

        CCFree(Buffer);
        Buffer = NULL;
    }
}

#if 0

/***********************************************************************************************

>   BOOL IndGenFileBuffer::Init(INT32 Count)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/05/95

    Inputs:     Count   - Number of files we're going to be adding
    Outputs:
    Returns:    TRUE if things went ok.

    Purpose:    Initialise the FileName Buffer system with a given number of entries
    Notes:

***********************************************************************************************/

BOOL IndGenFileBuffer::Init(INT32 Count)
{
    ERROR3IF(Buffer != NULL, "IndGenFileBuffer::Init called twice for same object");

    Items = Count;
    Buffer = (TCHAR **)CCMalloc(sizeof(TCHAR *) * Count);

    if(Buffer == NULL)
    {
        ERROR3("IndGenFileBuffer::Init failed to allocate buffer memory");
        Items = 0;
        return FALSE;
    }

    for(INT32 i = 0; i<Items; i++)
    {
        Buffer[i] = NULL;
    }   

    return TRUE;
}

/***********************************************************************************************

>   BOOL IndGenFileBuffer::AddItem(INT32 Count)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/05/95

    Inputs:     String  - pointer to null terminated string of TCHARS which we want to add
    Outputs:
    Returns:    TRUE if things went ok.

    Purpose:    Add a filename to the FileName buffer
    Notes:

***********************************************************************************************/

BOOL IndGenFileBuffer::AddItem(TCHAR *String)
{
    ERROR3IF(Items == 0, "IndGenFileBuffer::AddItem called without initialising first");

    if(Position >= Items)
    {
        ERROR3("IndGenFileBuffer::AddItem called too many times");
        return FALSE;
    }

    BOOL ok = FALSE;

    Buffer[Position] = (TCHAR *)CCMalloc((camStrlen(String) + 1) * sizeof(TCHAR));
    if(Buffer[Position] != NULL)
    {
        camStrcpy(Buffer[Position], String);
        ok = TRUE;
    }

    Position++;

    return ok;
}

/***********************************************************************************************

>   BOOL IndGenFileBuffer::Sort(void)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/05/95

    Inputs:
    Outputs:    
    Returns:    TRUE if the buffer was sorted ok

    Purpose:    Sort the strings pointed to by the buffer alphabetically
    Notes:

***********************************************************************************************/

BOOL IndGenFileBuffer::Sort(void)
{
    qsort(Buffer, Items, sizeof(TCHAR *), IndGenFileBuffer::SortComparator);

    return FALSE;
}

/********************************************************************************************

>   static INT32 __cdecl IndGenFileBuffer::SortComparator(const void *Item1, const void *Item2)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/5/95

    Inputs:     Item1, Item2 - the strings to be compared

    Returns:    a negative, zero, or positive result of comparing the strings

    Purpose:    'qsort' comparator function, used when sorting the file name buffer

    Notes:

********************************************************************************************/

INT32 __cdecl IndGenFileBuffer::SortComparator(const void *Item1, const void *Item2)
{
    if(Item1 == NULL || Item2 == NULL)
    {
        ERROR3("IndGenFileBuffer::SortComparator given null params");
        return 0;
    }

    TCHAR *String1 = *((TCHAR **)Item1);
    TCHAR *String2 = *((TCHAR **)Item2);

    // Sort by name - case insensitive - 'FRED' and 'fred' are equal...
    INT32 Value = CompareString(LOCALE_USER_DEFAULT,
        (NORM_IGNORECASE | NORM_IGNOREKANATYPE | NORM_IGNOREWIDTH),
        String1, -1, String2, -1);  // multi-locale supported compare routine
    Value -= 2;

    return(Value);
}

/***********************************************************************************************

>   TCHAR *IndGenFileBuffer::GetItem(INT32 Count)

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    15/05/95

    Inputs:     Count   - position of item in buffer
    Outputs:    
    Returns:    Pointer to the string at offset 'Count'

    Purpose:    Return pointer to item at index 'Count'
    Notes:      This can return NULL, and will if the item hasn't been allocated properly...

***********************************************************************************************/

TCHAR *IndGenFileBuffer::GetItem(INT32 Count)
{
    ERROR3IF(Count > Position, "IndGenFileBuffer::GetItem given an index which hasn't been added yet");

    return Buffer[Count];
}

/***********************************************************************************************

>   BOOL GenerateIndexFile::FixSubLibraryNumber(void);

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    09/04/95

    Inputs:
    Outputs:
    Returns:    TRUE if things went ok.

    Purpose:    Poke the count field with the correct value
    Notes:

***********************************************************************************************/

BOOL GenerateIndexFile::FixSubLibraryNumber(void)
{
    if(IndexFile && IndexCountOff)
    {
        IndexFile->seek(IndexCountOff);
        String_256 Line;
        wsprintf(Line, "%05d", ID);
        AddLineToIndex(&Line);
    }
    else
        return FALSE;

    return TRUE;
}


/***********************************************************************************************

>   BOOL GenerateIndexFile::AddFile(PathName *FileName);

    Author:     Richard_Millican (Xara Group Ltd) <camelotdev@xara.com>
    Created:    09/04/95

    Inputs:     FileName - name of file to add to index
    Outputs:
    Returns:    TRUE if things went ok.

    Purpose:    Add a file to the index
    Notes:

***********************************************************************************************/

BOOL GenerateIndexFile::AddFile(PathName *FileName)
{
    // Update progress bar & Line count
    if(!ContinueSlowJob(ID))
        return FALSE;
    ID++;

    TRACEUSER( "Richard", _T("Adding %s - ID %d to Index file\n"), (const TCHAR *)FileName->GetPath(), ID);

    // Get the file's size
    INT32 Size = (DWORD)SGLibOil::FileSize(FileName);

    // Default filename - force to lower case
    String_256 FName(FileName->GetFileName(TRUE));
    FName.toLower();

    // And capitalise the first character
    TCHAR First = camToupper(((TCHAR *)FName)[0]);
    ((TCHAR *)FName)[0] = First;

    // Default description - lowercase filename without file extension
    String_256 Description;

#ifdef FILENAME_AS_DEFAULT_DESCRIPTION
    Description = FileName->GetFileName(FALSE);
    Description.toLower();

    // And capitalise the first character
    First = camToupper(((TCHAR *)Description)[0]);
    ((TCHAR *)Description)[0] = First;
#endif

    // Default keywords - none
    String_256 Keywords("");

    // Default title - none
    String_256 Title("");

    BOOL FoundProperDescription = FALSE;
    
    // If it's a ttf font, rip out the name from the file
    if(LibType == SGLib_Font) {

        String_8 Ending(".");
        Ending += FileName->GetType();
        Ending.toLower();
        Ending += ";";

        if(Ending.Sub((String_8)".ttf;") != -1)
        {
            String_256 MenuName;
            if(RipTrueTypeNameFromFile(FileName, &MenuName))
            {
                Description = MenuName;
                FoundProperDescription = TRUE;
            }
        }

        if(Ending.Sub((String_8)".pfb;") != -1)
        {
            String_256 MenuName;
            BOOL Bold = FALSE;
            BOOL Italic = FALSE;
            if(RipATMNameFromFile(FileName, &MenuName, &Bold, &Italic))
            {
                // Since this is going in the index, it would be silly to have a comma now wouldn't it ?
                if(Bold || Italic) MenuName += ";";
                if(Bold) MenuName += String_16(_R(IDS_FONTS_CAPITAL_BOLD));
                if(Italic) MenuName += String_16(_R(IDS_FONTS_CAPITAL_ITALIC));

                Description = MenuName;
                FoundProperDescription = TRUE;
            }
        }
    }

    // If it's an art / eps file, rip out the comment block
    // NB: The function checks to see if it can handle the file type, no need to do it here...
    // We could also rip authors and keywords out possibly in the future...
    if((LibType == SGLib_ClipArt || LibType == SGLib_ClipArt_WebThemes) && !FoundProperDescription && GenerateIndexFile::UseDocComments)
    {
        String_256 OldDesc(Description);
        String_256 OldKeywords(Keywords);
        String_256 OldTitle(Title);
        if(RipDescriptionFromFile(FileName, &OldDesc, &OldKeywords, &OldTitle))
        {
            Description = OldDesc;
            Keywords = OldKeywords;
            Title = OldTitle;
            FoundProperDescription = TRUE;
        }
    }

    // If we haven't found a name yet, scan the tmp copy of the old index (if there was one)
    // Also get any old keywords found in the index for the item
    if(TmpIndexFile != NULL)
    {
/*  if(!FoundProperDescription && TmpIndexFile != NULL && OldIndexOK && GenerateIndexFile::UseOldIndexes)
    { */ 
        String_256 OldDesc(Description);
        String_256 OldKeywords(Keywords);
        String_256 OldTitle(