Logo Search packages:      
Sourcecode: djvulibre version File versions  Download package


//C-  -*- C++ -*-
//C- -------------------------------------------------------------------
//C- DjVuLibre-3.5
//C- Copyright (c) 2002  Leon Bottou and Yann Le Cun.
//C- Copyright (c) 2001  AT&T
//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- This program is distributed in the hope that it will be useful,
//C- but WITHOUT ANY WARRANTY; without even the implied warranty of
//C- GNU General Public License for more details.
//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- | 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- +------------------------------------------------------------------
// $Id: DjVuFile.h,v 1.12 2007/05/19 03:07:33 leonb Exp $
// $Name: debian_version_3_5_23-3 $

#ifndef _DJVUFILE_H
#define _DJVUFILE_H
#include "config.h"
# pragma interface

#include "DjVuInfo.h"
#include "DjVuPalette.h"
#include "DjVuPort.h"

namespace DJVU {
# ifdef NOT_DEFINED // Just to fool emacs c++ mode

class DjVuTXT;
class ByteStream;
class DataPool;
class JB2Image;
class JB2Dict;
class IW44Image;
class IFFByteStream;
class GPixmap;
class DjVuNavDir;

/** @name DjVuFile.h
    Files #"DjVuFile.h"# and #"DjVuFile.cpp"# contain implementation of the
    \Ref{DjVuFile} class, which takes the leading role in decoding of

    In the previous releases of the library the work of decoding has been
    entirely done in \Ref{DjVuImage}. Now, due to the introduction of multipage
    documents, the decoding procedure became significantly more complex and
    has been moved out from \Ref{DjVuImage} into \Ref{DjVuFile}.

    There is not much point though in creating just \Ref{DjVuFile} alone.
    The maximum power of the decoder is achieved when you create the
    \Ref{DjVuDocument} and work with {\bf it} when decoding the image.

    @memo Classes representing DjVu files.
    @author Andrei Erofeev <eaf@geocities.com>
    @version #$Id: DjVuFile.h,v 1.12 2007/05/19 03:07:33 leonb Exp $#


/** #DjVuFile# plays the central role in decoding \Ref{DjVuImage}s.
    First of all, it represents a DjVu file whether it's part of a
    multipage all-in-one-file DjVu document, or part of a multipage
    DjVu document where every page is in a separate file, or the whole
    single page document. #DjVuFile# can read its contents from a file
    and store it back when necessary.

    Second, #DjVuFile# does the greatest part of decoding work. In the
    past this was the responsibility of \Ref{DjVuImage}. Now, with the
    introduction of the multipage DjVu formats, the decoding routines
    have been extracted from the \Ref{DjVuImage} and put into this separate
    class #DjVuFile#.

    As \Ref{DjVuImage} before, #DjVuFile# now contains public class
    variables corresponding to every component, that can ever be decoded
    from a DjVu file (such as #INFO# chunk, #BG44# chunk, #SJBZ# chunk, etc.).

    As before, the decoding is initiated by a single function
    (\Ref{start_decode}() in this case, and \Ref{DjVuImage::decode}() before).
    The difference is that #DjVuFile# now handles threads creation itself.
    When you call the \Ref{start_decode}() function, it creates the decoding
    thread, which starts decoding, and which can create additional threads:
    one per each file included into this one.

    {\bf Inclusion} is also a new feature specifically designed for a
    multipage document. Indeed, inside a given document there can be a lot
    of things shared between its pages. Examples can be the document
    annotation (\Ref{DjVuAnno}) and other things like shared shapes and
    dictionary (to be implemented). To avoid putting these chunks into
    every page, we have invented new chunk called #INCL# which purpose is
    to make the decoder open the specified file and decode it.
    {\bf Source of data.} The #DjVuFile# can be initialized in two ways:
       \item With #URL# and \Ref{DjVuPort}. In this case #DjVuFile# will
             request its data thru the communication mechanism provided by
           \Ref{DjVuPort} in the constructor. If this file references
           (includes) any other file, data for them will also be requested
           in the same way.
       \item With \Ref{ByteStream}. In this case the #DjVuFile# will read
             its data directly from the passed stream. This constructor
           has been added to simplify creation of #DjVuFile#s, which do
           no include anything else. In this case the \Ref{ByteStream}
           is enough for the #DjVuFile# to initialize.
    {\bf Progress information.} #DjVuFile# does not do decoding silently.
    Instead, it sends a whole set of notifications through the mechanism
    provided by \Ref{DjVuPort} and \Ref{DjVuPortcaster}. It tells the user
    of the class about the progress of the decoding, about possible errors,
    chunk being decoded, etc. The data is requested using this mechanism too.

    {\bf Creating.} Depending on where you have data of the DjVu file, the
    #DjVuFile# can be initialized in two ways:
       \item By providing #URL# and pointer to \Ref{DjVuPort}. In this case
             #DjVuFile# will request data using communication mechanism
           provided by \Ref{DjVuPort}. This is useful when the data is on
           the web or when this file includes other files.
       \item By providing a \Ref{ByteStream} with the data for the file. Use
             it only when the file doesn't include other files.
    There is also a bunch of functions provided for composing
    the desired \Ref{DjVuDocument} and modifying #DjVuFile# structure. The
    examples are \Ref{delete_chunks}(), \Ref{insert_chunk}(),
    \Ref{include_file}() and \Ref{unlink_file}().

    {\bf Caching.} In the case of plugin it's important to do the caching
    of decoded images or files. #DjVuFile# appears to be the best candidate
    for caching, and that's why it supports this procedure. Whenever a
    #DjVuFile# is successfully decoded, it's added to the cache by
    \Ref{DjVuDocument}. Next time somebody needs it, it will be extracted
    from the cache directly by \Ref{DjVuDocument} and won't be decoded again.

    {\bf URLs.} Historically the biggest strain is put on making the decoder
    available for Netscape and IE plugins where the original files reside
    somewhere in the net. That is why #DjVuFile# uses {\bf URLs} to
    identify itself and other files. If you're working with files on the
    hard disk, you have to use the local URLs instead of file names.
    A good way to do two way conversion is the \Ref{GOS} class. Sometimes it
    happens that a given file does not reside anywhere but the memory. No
    problem in this case either. There is a special port \Ref{DjVuMemoryPort},
    which can associate any URL with the corresponding data in the memory.
    All you need to do is to invent your own URL prefix for this case.
    "#memory:#" will do. The usage of absolute URLs has many advantages among
    which is the capability to cache files with their URL being the cache key.

    Please note, that the #DjVuFile# class has been designed to work closely
    with \Ref{DjVuDocument}. So please review the documentation on this class
    too. */

00203 class DJVUAPI DjVuFile : public DjVuPort
   enum { STARTED=1, FINISHED=2 };

      /** @name Decoded file contents */
      /// Pointer to the DjVu file information component.
00215    GP<DjVuInfo>         info;
      /// Pointer to the background component of DjVu image (IW44 encoded).
00217    GP<IW44Image>  bg44;
      /// Pointer to the background component of DjVu image (Raw).
00219    GP<GPixmap>          bgpm;
      /// Pointer to the mask of foreground component of DjVu image (JB2 encoded).
00221    GP<JB2Image>         fgjb;
      /// Pointer to the optional shape dictionary for the mask (JB2 encoded).
00223    GP<JB2Dict>          fgjd;
      /// Pointer to a colors layer for the foreground component of DjVu image.
00225    GP<GPixmap>          fgpm;
      /// Pointer to a colors vector for the foreground component of DjVu image.
00227    GP<DjVuPalette>      fgbc;
      /// Pointer to collected annotation chunks.
00229    GP<ByteStream> anno;
      /// Pointer to collected hiddentext chunks.
00231    GP<ByteStream> text;
      /// Pointer to meta data chunks.
00233    GP<ByteStream> meta;
      /// Pointer to the *old* navigation directory contained in this file
00235    GP<DjVuNavDir> dir;
      /// Description of the file formed during decoding
00237    GUTF8String          description;
      /// MIME type string describing the DjVu data.
00239    GUTF8String          mimetype;
      /// Size of the file.
00241    int                  file_size;

      /** Default constructor.  Must follow with an init() */
   virtual ~DjVuFile(void);

      /** Initializes a #DjVuFile# object. This is a simplified initializer,
        which is not supposed to be used for decoding or creating
        #DjVuFile#s, which include other files.

        If the file is stored on the hard drive, you may also use the
        other constructor and pass it the file's URL and #ZERO# #port#.
        The #DjVuFile# will read the data itself.

        If you want to receive error messages and notifications, you
        may connect the #DjVuFile# to your own \Ref{DjVuPort} after
        it has been constructed.

        @param str The stream containing data for the file. */
   void init(const GP<ByteStream> & str);

      /** Creator, does the init(ByteStream &str) */
   static GP<DjVuFile> create( const GP<ByteStream> & str,
     const ErrorRecoveryAction recover_action=ABORT,
     const bool verbose_eof=true);
      /** Initializes a #DjVuFile# object. As you can notice, the data is not
        directly passed to this function. The #DjVuFile# will ask for it
        through the \Ref{DjVuPort} mechanism before the constructor
        finishes. If the data is stored locally on the hard disk then the
        pointer to \Ref{DjVuPort} may be set to #ZERO#, which will make
        #DjVuFile# read all data from the hard disk and report all errors
        to #stderr#.

        {\bf Note}. If the file includes (by means of #INCL# chunks) other
        files then you should be ready to
           \item Reply to requests \Ref{DjVuPort::id_to_url}() issued to
                 translate IDs (used in #INCL# chunks) to absolute URLs.
               Usually, when the file is created by \Ref{DjVuDocument}
               this job is done by it. If you construct such a file
               manually, be prepared to do the ID to URL translation
           \item Provide data for all included files.

        @param url The URL assigned to this file. It will be used when
               the #DjVuFile# asks for data.
        @param port All communication between #DjVuFile#s and \Ref{DjVuDocument}s
               is done through the \Ref{DjVuPort} mechanism. If the {\em url}
             is not local or the data does not reside on the hard disk,
             the {\em port} parameter must not be #ZERO#. If the {\em port}
             is #ZERO# then #DjVuFile# will create an internal instance
             of \Ref{DjVuSimplePort} for accessing local files and
             reporting errors. It can later be disabled by means
             of \Ref{disable_standard_port}() function. */
   void init(const GURL & url, GP<DjVuPort> port=0);

      /** Creator, does the init(const GURL &url, GP<DjVuPort> port=0) */
   static GP<DjVuFile> create(
     const GURL & url, GP<DjVuPort> port=0,
     const ErrorRecoveryAction recover_action=ABORT,
     const bool verbose_eof=true);

      /** Disables the built-in port for accessing local files, which may
        have been created in the case when the #port# argument to
        the \Ref{DjVuFile::DjVuFile}() constructor is #ZERO# */
   void           disable_standard_port(void);

      /** Looks for #decoded# navigation directory (\Ref{DjVuNavDir}) in this
        or included files. Returns #ZERO# if nothing could be found.

        {\bf Note.} This function does {\bf not} attempt to decode #NDIR#
        chunks. It is looking for predecoded components. #NDIR# can be
        decoded either during regular decoding (initiated by
        \Ref{start_decode}() function) or by \Ref{decode_ndir}() function,
        which processes this and included files recursively in search
        of #NDIR# chunks and decodes them. */
   GP<DjVuNavDir> find_ndir(void);

      /** @name #DjVuFile# flags query functions */
      /** Returns the #DjVuFile# flags. The value returned is the
        result of ORing one or more of the following constants:
           \item #DECODING# The decoding is in progress
           \item #DECODE_OK# The decoding has finished successfully
           \item #DECODE_FAILED# The decoding has failed
           \item #DECODE_STOPPED# The decoding has been stopped by
                 \Ref{stop_decode}() function
           \item #DATA_PRESENT# All data for this file has been received.
                 It's especially important in the case of Netscape or IE
               plugins when the data is being received while the
               decoding is done.
           \item #ALL_DATA_PRESENT# Not only data for this file, but also
                 for all included file has been received.
           \item #INCL_FILES_CREATED# All #INCL# and #INCF# chunks have been
                 processed and the corresponding #DjVuFile#s created. This
               is important to know to be sure that the list returned by
               \Ref{get_included_files}() is OK.
        \end{itemize} */
   long           get_flags(void) const;
      /// Returns #TRUE# if the file is being decoded.
   bool           is_decoding(void) const;
      /// Returns #TRUE# if decoding of the file has finished successfully.
   bool           is_decode_ok(void) const;
      /// Returns #TRUE# if decoding of the file has failed.
   bool           is_decode_failed(void) const;
      /** Returns #TRUE# if decoding of the file has been stopped by
        \Ref{stop_decode}() function. */
   bool           is_decode_stopped(void) const;
      /// Returns #TRUE# if this file has received all data.
   bool           is_data_present(void) const;
      /** Returns #TRUE# if this file {\bf and} all included files have
        received all data. */
   bool           is_all_data_present(void) const;
      /** Returns #TRUE# if all included files have been created. Only when
        this function returns 1, the \Ref{get_included_files}() returns
        the correct information. */
   bool           are_incl_files_created(void) const;
   bool           is_modified(void) const;
   bool           needs_compression(void) const;
   bool           can_compress(void) const;
   void           set_modified(bool m);
   void           set_needs_compression(bool m);
   void           set_can_compress(bool m);

      /// Returns the URL assigned to this file
   GURL           get_url(void) const;

      /** @name Decode control routines */
      /** Starts decode. If threads are enabled, the decoding will be
        done in another thread. Be sure to use \Ref{wait_for_finish}()
        or listen for notifications sent through the \Ref{DjVuPortcaster}
        to remain in sync. */
   void           start_decode(void);
      /** Start the decode iff not already decoded.  If sync is true, wait
          wait for decode to complete.  Returns true of start_decode is called.
   bool   resume_decode(const bool sync=false);
      /** Stops decode. If #sync# is 1 then the function will not return
        until the decoding thread actually dies. Otherwise it will
        just signal the thread to stop and will return immediately.
        Decoding of all included files will be stopped too. */
   void           stop_decode(bool sync);
      /** Recursively stops all data-related operations.

        Depending on the value of #only_blocked# flag this works as follows:
           \item If #only_blocked# is #TRUE#, the function will make sure,
                 that any further access to the file's data will result
               in a #STOP# exception if the desired data is not available
               (and the thread would normally block).
           \item If #only_blocked# is #FALSE#, then {\bf any} further
                 access to the file's data will result in immediate
               #STOP# exception.

        The action of this function is recursive, meaning that any #DjVuFile#
        included into this one will also be stopped.

        Use this function when you don't need the #DjVuFile# anymore. The
        results cannot be undone, and the whole idea is to make all threads
        working with this file exit with the #STOP# exception. */
   void           stop(bool only_blocked);
      /** Wait for the decoding to finish. This will wait for the
        termination of included files too. */
   void           wait_for_finish(void);
      /** Looks for #NDIR# chunk (navigation directory), and decodes its
        contents. If the #NDIR# chunk has not been found in {\em this} file,
        but this file includes others, the procedure will continue
        recursively. This function is useful to obtain the document
        navigation directory before any page has been decoded. After it
        returns the directory can be obtained by calling \Ref{find_ndir}()

        {\bf Warning.} Contrary to \Ref{start_decode}(), this function
        does not return before it completely decodes the directory.
        Make sure, that this file and all included files have enough data. */
   GP<DjVuNavDir> decode_ndir(void);
      /// Clears all decoded components.
   void           reset(void);
      /** Processes #INCL# chunks and creates included files.
        Normally you won't need to call this function because included
        files are created automatically when the file is being decoded.
        But if due to some reason you'd like to obtain the list of included
        files without decoding this file, this is an ideal function to call.

        {\bf Warning.} This function does not return before it reads the
        whole file, which may block your application under some circumstances
        if not all data is available. */
   void           process_incl_chunks(void);
      // Function needed by the cache
   unsigned int   get_memory_usage(void) const;

      /** Returns the list of included DjVuFiles.
        {\bf Warning.} Included files are normally created during decoding.
        Before that they do not exist.   If you call this function at
        that time and set #only_created# to #FALSE# then it will have to
        read all the data from this file in order to find #INCL# chunks,
        which may block your application, if not all data is available.

        @param only_created If #TRUE#, the file will not try to process
               #INCL# chunks and load referenced files. It will return
             just those files, which have already been created during
             the decoding procedure. */
   GPList<DjVuFile>     get_included_files(bool only_created=true);

      /** Includes a #DjVuFile# with the specified #id# into this one.
        This function will also insert an #INCL# chunk at position
        #chunk_num#. The function will request data for the included
        file and will create it before returning. */
   void           insert_file(const GUTF8String &id, int chunk_num=1);
      /// Will get rid of included file with the given #id#
   void           unlink_file(const GUTF8String &id);
      /** Will find an #INCL# chunk containing #name# in input #data# and
        will remove it */
   static GP<DataPool>  unlink_file(const GP<DataPool> & data, const GUTF8String &name);

      /// Returns the number of chunks in the IFF file data
   int            get_chunks_number(void);
      /// Returns the name of chunk number #chunk_num#
   GUTF8String    get_chunk_name(int chunk_num);
      /// Returns 1 if this file contains chunk with name #chunk_name#
   bool           contains_chunk(const GUTF8String &chunk_name);

      /** Processes the included files hierarchy and returns merged
        annotations. This function may be used even when the #DjVuFile#
        has not been decoded yet. If all data has been received for
        this #DjVuFile# and all included #DjVuFile#s, it will will
        gather annotations from them and will return the result.
        If no annotations have been found, #ZERO# will be returned.
        If either this #DjVuFile# or any of the included files do not
        have all the data, the function will use the results of
        decoding, which may have been started with the \Ref{start_decode}()
        function. Otherwise #ZERO# will be returned as well.

        If #max_level_ptr# pointer is not zero, the function will use
        it to store the maximum level number from which annotations
        have been obtained. #ZERO# level corresponds to the top-level
        page file.

        {\bf Summary:} This function will return complete annotations only
        when the \Ref{is_all_data_present}() returns #TRUE#. */
   GP<ByteStream> get_merged_anno(int * max_level_ptr=0);

      /** Returns the annotation chunks (#"ANTa"# and #"ANTz"#).  This
          function may be used even when the #DjVuFile# has not been decoded
          yet. If all data has been received for this #DjVuFile#, it will
          gather hidden text and return the result.  If no hidden text has
          been found, #ZERO# will be returned.

        {\bf Summary:} This function will return complete annotations
        only when the \Ref{is_all_data_present}() returns #TRUE#. */
   GP<ByteStream> get_anno(void);

      /** Returns the text chunks (#"TXTa"# and #"TXTz"#).  This function may
          be used even when the #DjVuFile# has not been decoded yet. If all
          data has been received for this #DjVuFile#, it will gather hidden
          text and return the result.  If no hidden text has been found,
          #ZERO# will be returned.

        {\bf Summary:} This function will return complete hidden text layers
        only when the \Ref{is_all_data_present}() returns #TRUE#. */
   GP<ByteStream> get_text(void);

      /** Returns the meta chunks (#"METa"# and #"METz"#).  This function may
          be used even when the #DjVuFile# has not been decoded yet. If all
          data has been received for this #DjVuFile#, it will gather metadata
          and return the result.  If no hidden text has been found, #ZERO#
          will be returned.

        {\bf Summary:} This function will return complete meta data only
        when the \Ref{is_all_data_present}() returns #TRUE#. */
   GP<ByteStream> get_meta(void);

      /** Goes down the hierarchy of #DjVuFile#s and merges their annotations.
          (shouldn't this one be private?).
        @param max_level_ptr If this pointer is not ZERO, the function
               will use it to store the maximum level at which annotations
             were found. Top-level page files have ZERO #level#.
        @param ignore_list The function will not process included #DjVuFile#s
               with URLs matching those mentioned in this #ignore_list#. */
   GP<ByteStream> get_merged_anno(const GList<GURL> & ignore_list,
                              int * max_level_ptr);

      /** Clears this file of all annotations. */
   void     remove_anno(void);

      /** Clears the hidden text. */
   void     remove_text(void);

      /// Clears the meta data.
   void remove_meta(void);

      /** Returns #TRUE# if the file contains annotation chunks.
        Known annotation chunks at the time of writing this help are:
        {\bf ANTa}, {\bf ANTz}, {\bf FORM:ANNO}. */
   bool           contains_anno(void);

      /** Returns #TRUE# if the file contains hiddentext chunks.
        Known hiddentext chunks at the time of writing this help are:
        {\bf TXTa}, and {\bf TXTz}. */
   bool           contains_text(void);

      /** Returns #TRUE# if the file contains metadata chunks.
        Known metadata chunks at the time of writing this help are:
        {\bf METa}, and {\bf METz}. */
   bool           contains_meta(void);

     /** Changes the value of the hiddentext. */
   void change_info(GP<DjVuInfo> info, const bool do_reset=false);
     /** Changes the value of the hiddentext. */
   void change_text(GP<DjVuTXT> txt, const bool do_reset=false);
     /** Changes the value of the metadata. */
   void change_meta(const GUTF8String &meta, const bool do_reset=false);
      /** @name Encoding routines */
      /** The main function that encodes data back into binary stream.
        The data returned will reflect possible changes made into the
        chunk structure, annotation chunks and navigation directory
        chunk #NDIR#.

        {\bf Note:} The file stream will not have the magic
        at the beginning.
        @param included_too Process included files too. */
   GP<ByteStream> get_djvu_bytestream(const bool included_too, const bool no_ndir=true);

      /** Same as \Ref{get_djvu_bytestream}(), returning a DataPool.
        @param included_too Process included files too. */
   GP<DataPool>         get_djvu_data(const bool included_too, const bool no_ndir=true );

      // Internal. Used by DjVuDocument
   GP<DataPool>         get_init_data_pool(void) const { return data_pool; };

      // Internal. Used by DjVuDocument. May block for data.
   void                 move(const GURL & dir_url);

      /** Internal. Used by DjVuDocument. The #name# should {\bf not}
        be encoded with \Ref{GOS::encode_reserved}(). */
   void                 set_name(const GUTF8String &name);

      // Internal. Used by DjVuDocument
   GSafeFlags &         get_safe_flags(void);

      // Internal. Used by DjVuImage
   void                 merge_anno(ByteStream &out);

      // Internal. Used by DjVuImage
   void                 get_text(ByteStream &out);

      // Internal. Used by DjVuImage
   void                 get_meta(ByteStream &out);

      // Internal. Used by DjVuDocEditor
   void                 rebuild_data_pool(void);

      // Functions inherited from DjVuPort
   virtual bool         inherits(const GUTF8String &class_name) const;
   virtual void         notify_chunk_done(const DjVuPort * source, const GUTF8String &name);
   virtual void         notify_file_flags_changed(const DjVuFile * source,
                                      long set_mask, long clr_mask);
   virtual void         set_recover_errors(const ErrorRecoveryAction=ABORT);
   virtual void         set_verbose_eof(const bool verbose_eof=true);
   virtual void         report_error(const GException &ex,const bool=true);
   static void set_decode_codec(GP<GPixmap> (*codec)(ByteStream &bs));

   GURL                 url;
   GP<DataPool>         data_pool;

   GPList<DjVuFile>     inc_files_list;
   GCriticalSection     inc_files_lock;
   GCriticalSection     anno_lock;
   GCriticalSection     text_lock;
   GCriticalSection     meta_lock;
   ErrorRecoveryAction  recover_errors;
   bool                 verbose_eof;
   int                  chunks_number;
   bool                 initialized;
   GSafeFlags           flags;

   GThread        * decode_thread;
   GP<DataPool>         decode_data_pool;
   GP<DjVuFile>         decode_life_saver;

   GP<DjVuPort>         simple_port;

   GMonitor       chunk_mon, finish_mon;

      // Functions called when the decoding thread starts
   static void    static_decode_func(void *);
   void     decode_func(void);
   void     decode(const GP<ByteStream> &str);
   GUTF8String decode_chunk(const GUTF8String &chkid,
     const GP<ByteStream> &str, bool djvi, bool djvu, bool iw44);
   int            get_dpi(int w, int h);

      // Functions dealing with the shape directory (fgjd)
   static GP<JB2Dict> static_get_fgjd(void *);
   GP<JB2Dict> get_fgjd(int block=0);

      // Functions used to wait for smth
   void           wait_for_chunk(void);
   bool           wait_for_finish(bool self);

      // INCL chunk processor
   GP<DjVuFile>   process_incl_chunk(ByteStream & str, int file_num=-1);

      // Trigger: called when DataPool has all data
   static void    static_trigger_cb(void *);
   void           trigger_cb(void);
      // Progress callback: called from time to time
   static void    progress_cb(int pos, void *);
   static void    get_merged_anno(const GP<DjVuFile> & file,
     const GP<ByteStream> &str_out, const GList<GURL> & ignore_list,
     int level, int & max_level, GMap<GURL, void *> & map);
   static void    get_anno(const GP<DjVuFile> & file,
     const GP<ByteStream> &str_out);
   static void    get_text(const GP<DjVuFile> & file,
     const GP<ByteStream> &str_out);
   static void    get_meta(const GP<DjVuFile> & file,
     const GP<ByteStream> &str_out);

   void          check() const;
   GP<DjVuNavDir>find_ndir(GMap<GURL, void *> & map);
   GP<DjVuNavDir>decode_ndir(GMap<GURL, void *> & map);
   void           add_djvu_data(IFFByteStream & str,
                        GMap<GURL, void *> & map,
                        const bool included_too, const bool no_ndir=true);
   void           move(GMap<GURL, void *> & map, const GURL & dir_url);
private: // dummy stuff
   static void decode(ByteStream *);
   static GUTF8String decode_chunk(const GUTF8String &, ByteStream *,bool,bool,bool);
   static void    get_merged_anno(const GP<DjVuFile> &,ByteStream *,
     const GList<GURL> &, int, int &, GMap<GURL, void *> &);
   static void    get_text(const GP<DjVuFile> &,ByteStream *);
   static void    get_meta(const GP<DjVuFile> &,ByteStream *);


inline long
00698 DjVuFile::get_flags(void) const
   return flags;

inline GSafeFlags &
   return flags;

inline bool
00710 DjVuFile::is_decoding(void) const
   return (flags & DECODING)!=0;

inline bool
00716 DjVuFile::is_decode_ok(void) const
   return (flags & DECODE_OK)!=0;

inline bool
00722 DjVuFile::is_decode_failed(void) const
   return (flags & DECODE_FAILED)!=0;

inline bool
00728 DjVuFile::is_decode_stopped(void) const
   return (flags & DECODE_STOPPED)!=0;

inline bool
00734 DjVuFile::is_data_present(void) const
   return (flags & DATA_PRESENT)!=0;

inline bool
00740 DjVuFile::is_all_data_present(void) const
   return (flags & ALL_DATA_PRESENT)!=0;

inline bool
00746 DjVuFile::are_incl_files_created(void) const
   return (flags & INCL_FILES_CREATED)!=0;

inline bool
DjVuFile::is_modified(void) const
   return (flags & MODIFIED)!=0;

inline void
DjVuFile::set_modified(bool m)
  flags=m ? (flags | MODIFIED) : (flags & ~MODIFIED);

inline bool
DjVuFile::needs_compression(void) const
   return (flags & NEEDS_COMPRESSION)!=0;

inline void
DjVuFile::set_needs_compression(bool m)
   if (m) flags=flags | NEEDS_COMPRESSION;
   else flags=flags & ~NEEDS_COMPRESSION;

inline bool
DjVuFile::can_compress(void) const
   return (flags & CAN_COMPRESS)!=0;

inline void
DjVuFile::set_can_compress(bool m)
   if (m)
     flags=flags | CAN_COMPRESS;
     flags=flags & ~CAN_COMPRESS;

inline void
00792 DjVuFile::disable_standard_port(void)

inline bool
00798 DjVuFile::inherits(const GUTF8String &class_name) const
      (GUTF8String("DjVuFile") == class_name) ||
//      !strcmp("DjVuFile", class_name) ||
//      DjVuPort::inherits(class_name);

inline void
00808 DjVuFile::wait_for_finish(void)

inline GURL
00815 DjVuFile::get_url(void) const
   return url;

inline void
(const bool verbose)

inline void
(const ErrorRecoveryAction action)


using namespace DJVU;
# endif

Generated by  Doxygen 1.6.0   Back to index