//C-  -*- C++ -*-

//C- -------------------------------------------------------------------

//C- DjVuLibre-3.5

//C- Copyright (c) 2002  Leon Bottou and Yann Le Cun.

//C- Copyright (c) 2001  AT&T

//C-

//C- This software is subject to, and may be distributed under, the

//C- GNU General Public License, either Version 2 of the license,

//C- or (at your option) any later version. The license should have

//C- accompanied the software or you may obtain a copy of the license

//C- from the Free Software Foundation at http://www.fsf.org .

//C-

//C- This program is distributed in the hope that it will be useful,

//C- but WITHOUT ANY WARRANTY; without even the implied warranty of

//C- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

//C- GNU General Public License for more details.

//C- 

//C- DjVuLibre-3.5 is derived from the DjVu(r) Reference Library from

//C- Lizardtech Software.  Lizardtech Software has authorized us to

//C- replace the original DjVu(r) Reference Library notice by the following

//C- text (see doc/lizard2002.djvu and doc/lizardtech2007.djvu):

//C-

//C-  ------------------------------------------------------------------

//C- | DjVu (r) Reference Library (v. 3.5)

//C- | Copyright (c) 1999-2001 LizardTech, Inc. All Rights Reserved.

//C- | The DjVu Reference Library is protected by U.S. Pat. No.

//C- | 6,058,214 and patents pending.

//C- |

//C- | This software is subject to, and may be distributed under, the

//C- | GNU General Public License, either Version 2 of the license,

//C- | or (at your option) any later version. The license should have

//C- | accompanied the software or you may obtain a copy of the license

//C- | from the Free Software Foundation at http://www.fsf.org .

//C- |

//C- | The computer code originally released by LizardTech under this

//C- | license and unmodified by other parties is deemed "the LIZARDTECH

//C- | ORIGINAL CODE."  Subject to any third party intellectual property

//C- | claims, LizardTech grants recipient a worldwide, royalty-free, 

//C- | non-exclusive license to make, use, sell, or otherwise dispose of 

//C- | the LIZARDTECH ORIGINAL CODE or of programs derived from the 

//C- | LIZARDTECH ORIGINAL CODE in compliance with the terms of the GNU 

//C- | General Public License.   This grant only confers the right to 

//C- | infringe patent claims underlying the LIZARDTECH ORIGINAL CODE to 

//C- | the extent such infringement is reasonably necessary to enable 

//C- | recipient to make, have made, practice, sell, or otherwise dispose 

//C- | of the LIZARDTECH ORIGINAL CODE (or portions thereof) and not to 

//C- | any greater extent that may be necessary to utilize further 

//C- | modifications or combinations.

//C- |

//C- | The LIZARDTECH ORIGINAL CODE is provided "AS IS" WITHOUT WARRANTY

//C- | OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED

//C- | TO ANY WARRANTY OF NON-INFRINGEMENT, OR ANY IMPLIED WARRANTY OF

//C- | MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

//C- +------------------------------------------------------------------

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#if NEED_GNUG_PRAGMAS

# pragma implementation

#endif

#include "DjVuDocument.h"

#include "DjVmDoc.h"

#include "DjVmDir0.h"

#include "DjVmNav.h"

#include "DjVuNavDir.h"

#include "DjVuImage.h"

#include "DjVuFileCache.h"

#include "IFFByteStream.h"

#include "GOS.h"

#include "DataPool.h"

#include "IW44Image.h"

#include "GRect.h"

#include "debug.h"

#ifdef HAVE_NAMESPACES

namespace DJVU {

# ifdef NOT_DEFINED // Just to fool emacs c++ mode

}

#endif

#endif

static const char octets[4]={0x41,0x54,0x26,0x54};

const float	DjVuDocument::thumb_gamma=(float)2.20;

void (* DjVuDocument::djvu_import_codec)(

  GP<DataPool> &pool, const GURL &url, bool &needs_compression,

  bool &needs_rename )=0;

void (* DjVuDocument::djvu_compress_codec)(

  GP<ByteStream> &doc,const GURL &where,bool bundled)=0;

void

DjVuDocument::set_import_codec(

  void (*codec)(

    GP<DataPool> &pool, const GURL &url, bool &needs_compression, bool &needs_rename ))

{

  djvu_import_codec=codec;

}

void

DjVuDocument::set_compress_codec(

  void (* codec)(

    GP<ByteStream> &doc,const GURL &where,bool bundled))

{

  djvu_compress_codec=codec;

}

DjVuDocument::DjVuDocument(void)

  : doc_type(UNKNOWN_TYPE),

    needs_compression_flag(false),

    can_compress_flag(false),

    needs_rename_flag(false),

    has_url_names(false),

    recover_errors(ABORT),

    verbose_eof(false),

    init_started(false),

    cache(0) 

{

}

GP<DjVuDocument>

DjVuDocument::create(

  GP<DataPool> pool, GP<DjVuPort> xport, DjVuFileCache * const xcache)

{

  DjVuDocument *doc=new DjVuDocument;

  GP<DjVuDocument> retval=doc;

  doc->init_data_pool=pool;

  doc->start_init(GURL(),xport,xcache);

  return retval;

}

GP<DjVuDocument>

DjVuDocument::create(

  const GP<ByteStream> &bs, GP<DjVuPort> xport, DjVuFileCache * const xcache)

{

  return create(DataPool::create(bs),xport,xcache);

}

GP<DjVuDocument>

DjVuDocument::create_wait(

  const GURL &url, GP<DjVuPort> xport, DjVuFileCache * const xcache)

{

  GP<DjVuDocument> retval=create(url,xport,xcache);

  retval->wait_for_complete_init();

  return retval;

}

void

DjVuDocument::start_init(

  const GURL & url, GP<DjVuPort> xport, DjVuFileCache * xcache)

{

   DEBUG_MSG("DjVuDocument::start_init(): initializing class...\n");

   DEBUG_MAKE_INDENT(3);

   if (init_started)

      G_THROW( ERR_MSG("DjVuDocument.2nd_init") );

   if (!get_count())

      G_THROW( ERR_MSG("DjVuDocument.not_secure") );

   if(url.is_empty())

   {

     if (!init_data_pool)

       G_THROW( ERR_MSG("DjVuDocument.empty_url") );

     if(init_url.is_empty())

     {

       init_url=invent_url("document.djvu");

     }

   }else

   {

     init_url=url;

   }

      // Initialize

   cache=xcache;

   doc_type=UNKNOWN_TYPE;

   DataPool::close_all();

   DjVuPortcaster * pcaster=get_portcaster();

   if (!xport)

     xport=simple_port=new DjVuSimplePort();

   pcaster->add_route(this, xport);

   pcaster->add_route(this, this);

   if(!url.is_empty())

   {

     init_data_pool=pcaster->request_data(this, init_url);

     if(init_data_pool)

     {

       if(!init_url.is_empty() && init_url.is_local_file_url() && djvu_import_codec)

       {

         djvu_import_codec(init_data_pool,init_url,needs_compression_flag,needs_rename_flag);

       }

       if(needs_rename_flag)

         can_compress_flag=true;

     }

     if (!init_data_pool) 

     {

       G_THROW( ERR_MSG("DjVuDocument.fail_URL") "\t"+init_url.get_string());

     }

   }

      // Now we say it is ready

   init_started=true;

   init_thread_flags=STARTED;

   init_life_saver=this;

   init_thr.create(static_init_thread, this);

}

DjVuDocument::~DjVuDocument(void)

{

      // No more messages, please. We're being destroyed.

   get_portcaster()->del_port(this);

      // We want to stop any DjVuFile which has been created by us

      // and is still being decoded. We have to stop them manually because

      // they keep the "life saver" in the decoding thread and won't stop

      // when we clear the last reference to them

   {

      GCriticalSectionLock lock(&ufiles_lock);

      for(GPosition pos=ufiles_list;pos;++pos)

      {

          GP<DjVuFile> file=ufiles_list[pos]->file;

          file->stop_decode(false);

          file->stop(false);	// Disable any access to data

      }

      ufiles_list.empty();

   }

   GPList<DjVuPort> ports=get_portcaster()->prefix_to_ports(get_int_prefix());

   for(GPosition pos=ports;pos;++pos)

   {

     GP<DjVuPort> port=ports[pos];

     if (port->inherits("DjVuFile"))

     {

       DjVuFile * file=(DjVuFile *) (DjVuPort *) port;

       file->stop_decode(false);

       file->stop(false);	// Disable any access to data

     }

   }

   DataPool::close_all();

}

void

DjVuDocument::stop_init(void)

{

   DEBUG_MSG("DjVuDocument::stop_init(): making sure that the init thread dies.\n");

   DEBUG_MAKE_INDENT(3);

   GMonitorLock lock(&init_thread_flags);

   while((init_thread_flags & STARTED) &&

	 !(init_thread_flags & FINISHED))

   {

      if (init_data_pool) init_data_pool->stop(true);	// blocking operation

      if (ndir_file) ndir_file->stop(false);

      {

	 GCriticalSectionLock lock(&ufiles_lock);

	 for(GPosition pos=ufiles_list;pos;++pos)

	    ufiles_list[pos]->file->stop(false);	// Disable any access to data

	 ufiles_list.empty();

      }

      init_thread_flags.wait(50);

   }

}

void

DjVuDocument::check() const

{

  if (!init_started)

    G_THROW( ERR_MSG("DjVuDocument.not_init") );

}

void

DjVuDocument::static_init_thread(void * cl_data)

{

  DjVuDocument * th=(DjVuDocument *) cl_data;

  GP<DjVuDocument> life_saver=th;

  th->init_life_saver=0;

  G_TRY {

    th->init_thread();

  } G_CATCH(exc) {

    G_TRY {

      int changed = DjVuDocument::DOC_INIT_FAILED;

      th->flags |= changed;

      get_portcaster()->notify_doc_flags_changed(th, changed, 0);

    } G_CATCH_ALL {

    } G_ENDCATCH;

    G_TRY {

      th->check_unnamed_files();

      if (!exc.cmp_cause(ByteStream::EndOfFile) && th->verbose_eof)

        get_portcaster()->notify_error(th, ERR_MSG("DjVuDocument.init_eof"));

      else if (!exc.cmp_cause(DataPool::Stop))

        get_portcaster()->notify_status(th, ERR_MSG("DjVuDocument.stopped"));

      else

        get_portcaster()->notify_error(th, exc.get_cause());

    } G_CATCH_ALL {

    } G_ENDCATCH;

    th->init_thread_flags |= FINISHED;

  } G_ENDCATCH;

}

void

DjVuDocument::init_thread(void)

      // This function is run in a separate thread.

      // The goal is to detect the document type (BUNDLED, OLD_INDEXED, etc.)

      // and decode navigation directory.

{

   DEBUG_MSG("DjVuDocument::init_thread(): guessing what we're dealing with\n");

   DEBUG_MAKE_INDENT(3);

   DjVuPortcaster * pcaster=get_portcaster();

   GP<ByteStream> stream=init_data_pool->get_stream();

   GP<IFFByteStream> giff=IFFByteStream::create(stream);

   IFFByteStream &iff=*giff;

   GUTF8String chkid;

   int size=iff.get_chunk(chkid);

   if (!size)

     G_THROW( ByteStream::EndOfFile );

   if (size < 0)

     G_THROW( ERR_MSG("DjVuDocument.no_file") );

   if (size<8)

     G_THROW( ERR_MSG("DjVuDocument.not_DjVu") );

   if (chkid=="FORM:DJVM")

   {

     DEBUG_MSG("Got DJVM document here\n");

     DEBUG_MAKE_INDENT(3);

     size=iff.get_chunk(chkid);

     if (chkid=="DIRM")

       {

	 djvm_dir=DjVmDir::create();

	 djvm_dir->decode(iff.get_bytestream());

	 iff.close_chunk();

	 if (djvm_dir->is_bundled())

           {

             DEBUG_MSG("Got BUNDLED file.\n");

             doc_type=BUNDLED;

           } 

         else

           {

             DEBUG_MSG("Got INDIRECT file.\n");

             doc_type=INDIRECT;

           }

	 flags|=DOC_TYPE_KNOWN | DOC_DIR_KNOWN;

	 pcaster->notify_doc_flags_changed(this, 

                                           DOC_TYPE_KNOWN | DOC_DIR_KNOWN, 0);

	 check_unnamed_files();

         /* Check for NAVM */

         size=iff.get_chunk(chkid);

         if (size && chkid=="NAVM")

           {

             djvm_nav=DjVmNav::create();

             djvm_nav->decode(iff.get_bytestream());

             iff.close_chunk();

           }

       }

     else if (chkid=="DIR0")

       {

	 DEBUG_MSG("Got OLD_BUNDLED file.\n");

	 doc_type=OLD_BUNDLED;

	 flags|=DOC_TYPE_KNOWN;

	 pcaster->notify_doc_flags_changed(this, DOC_TYPE_KNOWN, 0);

	 check_unnamed_files();

       } 

     else 

       G_THROW( ERR_MSG("DjVuDocument.bad_format") );

     if (doc_type==OLD_BUNDLED)

       {

         // Read the DjVmDir0 directory. We are unable to tell what

         // files are pages and what are included at this point.

         // We only know that the first file with DJVU (BM44 or PM44)

         // form *is* the first page. The rest will become known

         // after we decode DjVuNavDir

	 djvm_dir0=DjVmDir0::create();

	 djvm_dir0->decode(*iff.get_bytestream());

	 iff.close_chunk();

         // Get offset to the first DJVU, PM44 or BM44 chunk

	 int first_page_offset=0;

	 while(!first_page_offset)

           {

             int offset;

             size=iff.get_chunk(chkid, &offset);

             if (size==0) G_THROW( ERR_MSG("DjVuDocument.no_page") );

             if (chkid=="FORM:DJVU" || 

                 chkid=="FORM:PM44" || chkid=="FORM:BM44")

               {

                 DEBUG_MSG("Got 1st page offset=" << offset << "\n");

                 first_page_offset=offset;

               }

             iff.close_chunk();

           }

         // Now get the name of this file

	 int file_num;

	 for(file_num=0;file_num<djvm_dir0->get_files_num();file_num++)

           {

             DjVmDir0::FileRec & file=*djvm_dir0->get_file(file_num);

             if (file.offset==first_page_offset)

               {

                 first_page_name=file.name;

                 break;

               }

           }

	 if (!first_page_name.length())

           G_THROW( ERR_MSG("DjVuDocument.no_page") );

	 flags|=DOC_DIR_KNOWN;

	 pcaster->notify_doc_flags_changed(this, DOC_DIR_KNOWN, 0);

	 check_unnamed_files();

       }

   } 

   else // chkid!="FORM:DJVM"

     {

       // DJVU format

       DEBUG_MSG("Got DJVU OLD_INDEXED or SINGLE_PAGE document here.\n");

       doc_type=SINGLE_PAGE;

       flags |= DOC_TYPE_KNOWN;

       pcaster->notify_doc_flags_changed(this, DOC_TYPE_KNOWN, 0);

       check_unnamed_files();

     }

   if (doc_type==OLD_BUNDLED || doc_type==SINGLE_PAGE)

     {

       DEBUG_MSG("Searching for NDIR chunks...\n");

       ndir_file=get_djvu_file(-1);

       if (ndir_file) ndir=ndir_file->decode_ndir();

       ndir_file=0;	// Otherwise ~DjVuDocument() will stop (=kill) it

       if (!ndir)

         {

           // Seems to be 1-page old-style document. Create dummy NDIR

           if (doc_type==OLD_BUNDLED)

             {

               ndir=DjVuNavDir::create(GURL::UTF8("directory",init_url));

               ndir->insert_page(-1, first_page_name);

             } 

           else

             {

               ndir=DjVuNavDir::create(GURL::UTF8("directory",init_url.base()));

               ndir->insert_page(-1, init_url.fname());

             }

         } 

       else

         {

           if (doc_type==SINGLE_PAGE)

             doc_type=OLD_INDEXED;

         }

       flags|=DOC_NDIR_KNOWN;

       pcaster->notify_doc_flags_changed(this, DOC_NDIR_KNOWN, 0);

       check_unnamed_files();

     }

   flags |= DOC_INIT_OK;

   pcaster->notify_doc_flags_changed(this, DOC_INIT_OK, 0);

   check_unnamed_files();

   init_thread_flags|=FINISHED;

   DEBUG_MSG("DOCUMENT IS FULLY INITIALIZED now: doc_type='" <<

	     (doc_type==BUNDLED ? "BUNDLED" :

	      doc_type==OLD_BUNDLED ? "OLD_BUNDLED" :

	      doc_type==INDIRECT ? "INDIRECT" :

	      doc_type==OLD_INDEXED ? "OLD_INDEXED" :

	      doc_type==SINGLE_PAGE ? "SINGLE_PAGE" :

	      "UNKNOWN") << "'\n");

}

bool

DjVuDocument::wait_for_complete_init(void)

{

  flags.enter();

  while(!(flags & DOC_INIT_FAILED) &&

        !(flags & DOC_INIT_OK)) flags.wait();

  flags.leave();

  init_thread_flags.enter();

  while (!(init_thread_flags & FINISHED))

    init_thread_flags.wait();

  init_thread_flags.leave();

  return (flags & (DOC_INIT_OK | DOC_INIT_FAILED))!=0;

}

int

DjVuDocument::wait_get_pages_num(void) const

{

  GSafeFlags &f=const_cast<GSafeFlags &>(flags);

  f.enter();

  while(!(f & DOC_TYPE_KNOWN) &&

        !(f & DOC_INIT_FAILED) &&

        !(f & DOC_INIT_OK)) f.wait();

  f.leave();

  return get_pages_num();

}

GUTF8String

DjVuDocument::get_int_prefix(void) const

{

      // These NAMEs are used to enable DjVuFile sharing inside the same

      // DjVuDocument using DjVuPortcaster. Since URLs are unique to the

      // document, other DjVuDocuments cannot retrieve files until they're

      // assigned some permanent name. After '?' there should be the real

      // file's URL. Please note, that output of this function is used only

      // as name for DjVuPortcaster. Not as a URL.

   GUTF8String retval;

   return retval.format("document_%p%d?", this, hash(init_url));

}

void

DjVuDocument::set_file_aliases(const DjVuFile * file)

{

   DEBUG_MSG("DjVuDocument::set_file_aliases(): setting global aliases for file '"

	     << file->get_url() << "'\n");

   DEBUG_MAKE_INDENT(3);

   DjVuPortcaster * pcaster=DjVuPort::get_portcaster();

   GMonitorLock lock(&((DjVuFile *) file)->get_safe_flags());

   pcaster->clear_aliases(file);

   if (file->is_decode_ok() && cache)

   {

	 // If file is successfully decoded and caching is enabled,

	 // assign a global alias to this file, so that any other

	 // DjVuDocument will be able to use it.

      pcaster->add_alias(file, file->get_url().get_string());

      if (flags & (DOC_NDIR_KNOWN | DOC_DIR_KNOWN))

      {

	 int page_num=url_to_page(file->get_url());

	 if (page_num>=0)

	 {

	    if (page_num==0) pcaster->add_alias(file, init_url.get_string()+"#-1");

	    pcaster->add_alias(file, init_url.get_string()+"#"+GUTF8String(page_num));

	 }

      }

	 // The following line MUST stay here. For OLD_INDEXED documents

	 // a page may finish decoding before DIR or NDIR becomes known

	 // (multithreading, remember), so the code above would not execute

      pcaster->add_alias(file, file->get_url().get_string()+"#-1");

   } else pcaster->add_alias(file, get_int_prefix()+file->get_url());

}

void

DjVuDocument::check_unnamed_files(void)

{

  DEBUG_MSG("DjVuDocument::check_unnamed_files(): Seeing if we can fix some...\n");

  DEBUG_MAKE_INDENT(3);

  if (flags & DOC_INIT_FAILED)

  {

    // Init failed. All unnamed files should be terminated

    GCriticalSectionLock lock(&ufiles_lock);

    for(GPosition pos=ufiles_list;pos;++pos)

    {

      GP<DjVuFile> file=ufiles_list[pos]->file;

      file->stop_decode(true);

      file->stop(false);	// Disable any access to data

    }

    ufiles_list.empty();

    return;

  }

  if ((flags & DOC_TYPE_KNOWN)==0)

    return;

  // See the list of unnamed files (created when there was insufficient

  // information about DjVuDocument structure) and try to fix those,

  // which can be fixed at this time

  while(true)

  {

    DjVuPortcaster * pcaster=get_portcaster();

    GP<UnnamedFile> ufile;

    GURL new_url;

    GPosition pos ;   

	   GCriticalSectionLock lock(&ufiles_lock);

     for(pos=ufiles_list;pos;)

     {

	G_TRY

        {

          GP<UnnamedFile> f=ufiles_list[pos];

          if (f->id_type==UnnamedFile::ID) 

            new_url=id_to_url(f->id);

          else 

            new_url=page_to_url(f->page_num);

          if (!new_url.is_empty())

          {

            ufile=f;

            // Don't take it off the list. We want to be

            // able to stop the init from ~DjVuDocument();

            //

            // ufiles_list.del(pos);

            break;

          } else if (is_init_complete())

          {

            // No empty URLs are allowed at this point.

            // We now know all information about the document

            // and can determine if a page is inside it or not

            f->data_pool->set_eof();

            GUTF8String msg;

            if (f->id_type==UnnamedFile::ID)

              msg= ERR_MSG("DjVuDocument.miss_page_name") "\t"+f->id;

            else 

              msg= ERR_MSG("DjVuDocument.miss_page_num") "\t"+GUTF8String(f->page_num);

            G_THROW(msg);

          }

          ++pos;

        }

        G_CATCH(exc)

        {

          pcaster->notify_error(this, exc.get_cause());

          GP<DataPool> pool=ufiles_list[pos]->data_pool;

          if (pool)

            pool->stop();

          GPosition this_pos=pos;

          ++pos;

          ufiles_list.del(this_pos);

        }

        G_ENDCATCH;

     }

     if (ufile && !new_url.is_empty())

       {

         DEBUG_MSG("Fixing file: '" << ufile->url << "'=>'" << new_url << "'\n");

         // Now, once we know its real URL we can request a real DataPool and

         // can connect the DataPool owned by DjVuFile to that real one

         // Note, that now request_data() will not play fool because

         // we have enough information

         G_TRY

           {

             if (ufile->data_pool)

               {

                 GP<DataPool> new_pool=pcaster->request_data(ufile->file, new_url);

                 if(!new_pool)

                   G_THROW( ERR_MSG("DjVuDocument.fail_URL") "\t"+new_url.get_string());

                 ufile->data_pool->connect(new_pool);

               }

             ufile->file->set_name(new_url.fname());

             ufile->file->move(new_url.base());

             set_file_aliases(ufile->file);

           }

         G_CATCH(exc)

           {

             pcaster->notify_error(this, exc.get_cause());

           }   

         G_ENDCATCH;

       }

     else

       break;

     // Remove the 'ufile' from the list

     for(pos=ufiles_list;pos;++pos)

       if (ufiles_list[pos]==ufile)

         {

           ufiles_list.del(pos);

           break;

         }

  } // while(1)

}

int

DjVuDocument::get_pages_num(void) const

{

  check();

  if (flags & DOC_TYPE_KNOWN)

    {

      if (doc_type==BUNDLED || doc_type==INDIRECT)

	return djvm_dir->get_pages_num();

      else if (flags & DOC_NDIR_KNOWN)

	return ndir->get_pages_num();

    }

  return 1;

}

GURL

DjVuDocument::page_to_url(int page_num) const

{

   check();

   DEBUG_MSG("DjVuDocument::page_to_url(): page_num=" << page_num << "\n");

   DEBUG_MAKE_INDENT(3);

   GURL url;

   if (flags & DOC_TYPE_KNOWN)

      switch(doc_type)

      {

	 case SINGLE_PAGE:

         {

           if (page_num<1) 

             url=init_url;

           else

             G_THROW( ERR_MSG("DjVuDocument.big_num") );

           break;

         }

	 case OLD_INDEXED:

	 {

	    if (page_num<0) 

              url=init_url;

	    else if (flags & DOC_NDIR_KNOWN) 

              url=ndir->page_to_url(page_num);

	    break;

	 }

	 case OLD_BUNDLED:

	 {

	    if (page_num<0) 

              page_num=0;

	    if (page_num==0 && (flags & DOC_DIR_KNOWN))

              url=GURL::UTF8(first_page_name,init_url);

	    else if (flags & DOC_NDIR_KNOWN)

              url=ndir->page_to_url(page_num);

	    break;

	 }

	 case BUNDLED:

	 {

	    if (page_num<0)

              page_num=0;

	    if (flags & DOC_DIR_KNOWN)

	    {

	      GP<DjVmDir::File> file=djvm_dir->page_to_file(page_num);

	      if (!file) 

                G_THROW( ERR_MSG("DjVuDocument.big_num") );

	      url=GURL::UTF8(file->get_load_name(),init_url);

	    }

	    break;

	 }

	 case INDIRECT:

	 {

	    if (page_num<0) page_num=0;

	    if (flags & DOC_DIR_KNOWN)

	    {

	       GP<DjVmDir::File> file=djvm_dir->page_to_file(page_num);

	       if (!file)

                 G_THROW( ERR_MSG("DjVuDocument.big_num") );

	       url=GURL::UTF8(file->get_load_name(),init_url.base());

	    }

	    break;

	 }

	 default:

	    G_THROW( ERR_MSG("DjVuDocument.unk_type") );

      }

   return url;

}

int

DjVuDocument::url_to_page(const GURL & url) const

{

   check();

   DEBUG_MSG("DjVuDocument::url_to_page(): url='" << url << "'\n");

   DEBUG_MAKE_INDENT(3);

   int page_num=-1;

   if (flags & DOC_TYPE_KNOWN)

      switch(doc_type)

      {

	 case SINGLE_PAGE:

	 case OLD_BUNDLED:

	 case OLD_INDEXED:

	 {

	    if (flags & DOC_NDIR_KNOWN) page_num=ndir->url_to_page(url);

	    break;

	 }

	 case BUNDLED:

	 {

	    if (flags & DOC_DIR_KNOWN)

	    {

	       GP<DjVmDir::File> file;

	       if (url.base()==init_url)

                 file=djvm_dir->id_to_file(url.fname());

	       if (file)

                 page_num=file->get_page_num();

	    }

	    break;

	 }

	 case INDIRECT:

	 {

	    if (flags & DOC_DIR_KNOWN)

	    {

	       GP<DjVmDir::File> file;

	       if (url.base()==init_url.base())

                 file=djvm_dir->id_to_file(url.fname());

	       if (file)

                 page_num=file->get_page_num();

	    }

	    break;

	 }

	 default:

	    G_THROW( ERR_MSG("DjVuDocument.unk_type") );

      }

   return page_num;

}

GURL

DjVuDocument::id_to_url(const GUTF8String & id) const

{

   check();

   DEBUG_MSG("DjVuDocument::id_to_url(): translating ID='" << id << "' to URL\n");

   DEBUG_MAKE_INDENT(3);

   if (flags & DOC_TYPE_KNOWN)

      switch(doc_type)

      {

	 case BUNDLED:

	    if (flags & DOC_DIR_KNOWN)

	    {

	      GP<DjVmDir::File> file=djvm_dir->id_to_file(id);

	      if (!file)

              {

                file=djvm_dir->name_to_file(id);

	        if (!file)

                  file=djvm_dir->title_to_file(id);

              }

	      if (file)

	        return GURL::UTF8(file->get_load_name(),init_url);

	    }

	    break;

	 case INDIRECT:

	    if (flags & DOC_DIR_KNOWN)

	    {

	       GP<DjVmDir::File> file=djvm_dir->id_to_file(id);

	       if (!file)

               {

                 file=djvm_dir->name_to_file(id);

	         if (!file)

                   file=djvm_dir->title_to_file(id);

               }

	       if (file)

	         return GURL::UTF8(file->get_load_name(),init_url.base());

	    }

	    break;

	 case OLD_BUNDLED:

	    if (flags & DOC_DIR_KNOWN)

	    {

	       GP<DjVmDir0::FileRec> frec=djvm_dir0->get_file(id);

	       if (frec)

                 return GURL::UTF8(id,init_url);

	    }

	    break;

	 case OLD_INDEXED:

	 case SINGLE_PAGE:

	    return GURL::UTF8(id,init_url.base());

	    break;

      }

   return GURL();

}

GURL

DjVuDocument::id_to_url(const DjVuPort * source, const GUTF8String &id)

{

   return id_to_url(id);

}

GP<DjVuFile>

DjVuDocument::url_to_file(const GURL & url, bool dont_create) const

      // This function is private and is called from two places:

      // id_to_file() and get_djvu_file() ONLY when the structure is known

{

   check();

   DEBUG_MSG("DjVuDocument::url_to_file(): url='" << url << "'\n");

   DEBUG_MAKE_INDENT(3);

      // Try DjVuPortcaster to find existing files.

   DjVuPortcaster * pcaster=DjVuPort::get_portcaster();

   GP<DjVuPort> port;

   if (cache)

   {

	 // First - fully decoded files

      port=pcaster->alias_to_port(url.get_string());

      if (port && port->inherits("DjVuFile"))

      {

	 DEBUG_MSG("found fully decoded file using DjVuPortcaster\n");

	 return (DjVuFile *) (DjVuPort *) port;

      }

   }

      // Second - internal files

   port=pcaster->alias_to_port(get_int_prefix()+url);

   if (port && port->inherits("DjVuFile"))

   {