TDE
/
tdegraphics
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdegraphics
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'eecec9afb8'
${ noResults }
tdegraphics/kviewshell/plugins/djvu/libdjvu/DjVuFile.h

849 lines
32 KiB
Raw Normal View History Unescape

Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features. BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegraphics@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
15 years ago
//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, Version 2. 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
//C- distributed by Lizardtech Software. On July 19th 2002, Lizardtech
//C- Software authorized us to replace the original DjVu(r) Reference
//C- Library notice by the following text (see doc/lizard2002.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, Version 2. 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- +------------------------------------------------------------------
//
// $Id: DjVuFile.h,v 1.9 2003/11/07 22:08:20 leonb Exp $
// $Name: release_3_5_15 $
#ifndef _DJVUFILE_H
#define _DJVUFILE_H
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#if NEED_GNUG_PRAGMAS
# pragma interface
#endif
#include "DjVuInfo.h"
#include "DjVuPalette.h"
#include "DjVuPort.h"
#ifdef HAVE_NAMESPACES
namespace DJVU {
# ifdef NOT_DEFINED // Just to fool emacs c++ mode
}
#endif
#endif
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
\Ref{DjVuImage}s.
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.9 2003/11/07 22:08:20 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:
\begin{itemize}
\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.
\end{itemize}
{\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:
\begin{itemize}
\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.
\end{itemize}
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. */
class DjVuFile : public DjVuPort
{
public:
enum { DECODING=1, DECODE_OK=2, DECODE_FAILED=4, DECODE_STOPPED=8,
DATA_PRESENT=16, ALL_DATA_PRESENT=32, INCL_FILES_CREATED=64,
MODIFIED=128, DONT_START_DECODE=256, STOPPED=512,
BLOCKED_STOPPED=1024, CAN_COMPRESS=2048, NEEDS_COMPRESSION=4096 };
enum { STARTED=1, FINISHED=2 };
/** @name Decoded file contents */
//@{
/// Pointer to the DjVu file information component.
GP<DjVuInfo> info;
/// Pointer to the background component of DjVu image (IW44 encoded).
GP<IW44Image> bg44;
/// Pointer to the background component of DjVu image (Raw).
GP<GPixmap> bgpm;
/// Pointer to the mask of foreground component of DjVu image (JB2 encoded).
GP<JB2Image> fgjb;
/// Pointer to the optional shape dictionary for the mask (JB2 encoded).
GP<JB2Dict> fgjd;
/// Pointer to a colors layer for the foreground component of DjVu image.
GP<GPixmap> fgpm;
/// Pointer to a colors vector for the foreground component of DjVu image.
GP<DjVuPalette> fgbc;
/// Pointer to collected annotation chunks.
GP<ByteStream> anno;
/// Pointer to collected hiddentext chunks.
GP<ByteStream> text;
/// Pointer to meta data chunks.
GP<ByteStream> meta;
/// Pointer to the *old* navigation directory contained in this file
GP<DjVuNavDir> dir;
/// Description of the file formed during decoding
GUTF8String description;
/// MIME type string describing the DjVu data.
GUTF8String mimetype;
/// Size of the file.
int file_size;
//@}
protected:
/** Default constructor. Must follow with an init() */
DjVuFile(void);
public:
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
\begin{enumerate}
\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.
\end{enumerate}
@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:
\begin{itemize}
\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:
\begin{itemize}
\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.
\end{itemize}
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}()
function.
{\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
#0x41,0x54,0x26,0x54#
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));
protected:
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;
private:
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
DjVuFile::get_flags(void) const
{
return flags;
}
inline GSafeFlags &
DjVuFile::get_safe_flags(void)
{
return flags;
}
inline bool
DjVuFile::is_decoding(void) const
{
return (flags & DECODING)!=0;
}
inline bool
DjVuFile::is_decode_ok(void) const
{
return (flags & DECODE_OK)!=0;
}
inline bool
DjVuFile::is_decode_failed(void) const
{
return (flags & DECODE_FAILED)!=0;
}
inline bool
DjVuFile::is_decode_stopped(void) const
{
return (flags & DECODE_STOPPED)!=0;
}
inline bool
DjVuFile::is_data_present(void) const
{
return (flags & DATA_PRESENT)!=0;
}
inline bool
DjVuFile::is_all_data_present(void) const
{
return (flags & ALL_DATA_PRESENT)!=0;
}
inline bool
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(info)
{
info->compressable=m;
}
if (m)
{
flags=flags | CAN_COMPRESS;
} else
{
flags=flags & ~CAN_COMPRESS;
}
}
inline void
DjVuFile::disable_standard_port(void)
{
simple_port=0;
}
inline bool
DjVuFile::inherits(const GUTF8String &class_name) const
{
return
(GUTF8String("DjVuFile") == class_name) ||
DjVuPort::inherits(class_name);
// !strcmp("DjVuFile", class_name) ||
// DjVuPort::inherits(class_name);
}
inline void
DjVuFile::wait_for_finish(void)
{
while(wait_for_finish(1))
EMPTY_LOOP;
}
inline GURL
DjVuFile::get_url(void) const
{
return url;
}
inline void
DjVuFile::set_verbose_eof
(const bool verbose)
{
verbose_eof=verbose;
}
inline void
DjVuFile::set_recover_errors
(const ErrorRecoveryAction action)
{
recover_errors=action;
}
//@}
#ifdef HAVE_NAMESPACES
}
# ifndef NOT_USING_DJVU_NAMESPACE
using namespace DJVU;
# endif
#endif
#endif