summaryrefslogtreecommitdiffstats
path: root/kviewshell/plugins/djvu/libdjvu/GIFFManager.h
diff options
context:
space:
mode:
Diffstat (limited to 'kviewshell/plugins/djvu/libdjvu/GIFFManager.h')
-rw-r--r--kviewshell/plugins/djvu/libdjvu/GIFFManager.h394
1 files changed, 394 insertions, 0 deletions
diff --git a/kviewshell/plugins/djvu/libdjvu/GIFFManager.h b/kviewshell/plugins/djvu/libdjvu/GIFFManager.h
new file mode 100644
index 00000000..722f592f
--- /dev/null
+++ b/kviewshell/plugins/djvu/libdjvu/GIFFManager.h
@@ -0,0 +1,394 @@
+//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: GIFFManager.h,v 1.8 2003/11/07 22:08:21 leonb Exp $
+// $Name: release_3_5_15 $
+
+#ifndef _GIFFMANAGER_H
+#define _GIFFMANAGER_H
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#if NEED_GNUG_PRAGMAS
+# pragma interface
+#endif
+
+
+#include "IFFByteStream.h"
+#include "GContainer.h"
+#include "Arrays.h"
+#include "GSmartPointer.h"
+#include "GString.h"
+
+#ifdef HAVE_NAMESPACES
+namespace DJVU {
+# ifdef NOT_DEFINED // Just to fool emacs c++ mode
+}
+#endif
+#endif
+
+
+/** @name GIFFManager.h
+
+ Files #"GIFFManager.h"# and #"GIFFManager.cpp"# define more convenient
+ interface to IFF files. You may want to use the {\Ref GIFFManager} class
+ instead of coping with {\Ref IFFByteStream} especially when you have to
+ insert or move chunks, which is a kind of tricky with sequential access
+ provided by {\Ref IFFByteStream}.
+
+ You will mostly deal with {\Ref GIFFManager} class, but sometimes you may
+ want to use {\Ref GIFFChunk}s as well thus bypassing {\Ref GIFFManager}'s
+ interface and working with the chunks hierarchy yourself.
+
+ Interface to IFF files.
+ @author
+ Andrei Erofeev <[email protected]> -- Initial implementation.
+ @version
+ #$Id: GIFFManager.h,v 1.8 2003/11/07 22:08:21 leonb Exp $# */
+
+/** #GIFFChunk# is the base class for other IFF chunks understood by
+ {\Ref GIFFManager}. It provides some basic interface, and is not supposed
+ to be used on its own. */
+
+class GIFFChunk : public GPEnabled
+{
+protected:
+ GIFFChunk(void);
+ GIFFChunk(const GUTF8String &name);
+ GIFFChunk(const GUTF8String &name, const TArray<char> & data);
+public:
+ /// Default creator.
+ static GP<GIFFChunk> create(void) {return new GIFFChunk();}
+
+ /** Creates the chunk with the given name. The {\em name} may not
+ contain dots colons or brackets */
+ static GP<GIFFChunk> create(const GUTF8String &name)
+ {return new GIFFChunk(name);}
+
+ /** Creates the {\em plain chunk} containing raw data */
+ static GP<GIFFChunk> create(const GUTF8String &name, const TArray<char> & data)
+ { return new GIFFChunk(name,data); }
+
+ /// Destructor
+ virtual ~GIFFChunk(void);
+
+ /// Returns the name of the chunk (without possible #FORM:# or similar prefixes)
+ GUTF8String get_name(void) const;
+ /// Returns full chunk name, with possible container specification
+ GUTF8String get_full_name(void) const;
+ /// Returns the chunk type, like #CAT# for chunk #CAT:DJVU#
+ GUTF8String get_type(void) const;
+ /// Returns TRUE if the chunk may contain other chunks or FALSE otherwise
+ bool is_container(void) const;
+ /** Sets the chunk name. The {\em name} may not contain dots or brackets,
+ but {\bf may} contain colons. */
+ void set_name(GUTF8String name);
+ /** Parses the {\em name} probably containing colon and compares it
+ with its own name returning TRUE if they are the same */
+ bool check_name(GUTF8String name);
+
+ /** Adds the {\em chunk} to the chunks list at position {\em order}.
+ Set {\em order} to #-1# to append the chunk to the list.
+ {\bf Note!} By adding chunk #PROP# you will convert this chunk
+ to type #LIST# {\em automatically}. */
+ void add_chunk(const GP<GIFFChunk> & chunk, int order=-1);
+ /** Removes the chunk with given {\em name}. The {\em name} may not
+ contain dots, but MAY contain colons and brackets (the latter -
+ for specifying the chunk number) */
+ void del_chunk(const GUTF8String &name);
+ /** Returns the chunk with given {\em name}. The {\em name} may not
+ contain dots, but MAY contain colons and brackets (the latter -
+ for specifying the chunk number). If {\em position} is not zero
+ then the chunk position in its parent will be put into #*position# */
+ GP<GIFFChunk>get_chunk(const GUTF8String &name, int * position=0);
+ /** Returns the number of chunks with given {\em name}. The {\em name}
+ may not contain dots and brackets. If {\em name} is ZERO, the
+ total number of chunks will be returned. */
+ int get_chunks_number(const GUTF8String &name);
+ int get_chunks_number(void);
+ /** Returns the data array for plain chunks */
+ TArray<char> get_data(void) const;
+
+ /** Saves the chunk into the {\Ref IFFByteStream}.
+ Set {\em use_trick} to #1# if this is a top-level chunk */
+ void save(IFFByteStream & istr, bool use_trick=0);
+private:
+ char name[5];
+ GUTF8String type;
+ GPList<GIFFChunk> chunks;
+ TArray<char> data;
+ static GUTF8String decode_name(const GUTF8String &name, int &number);
+};
+
+inline GUTF8String
+GIFFChunk::get_name(void) const { return GUTF8String(name, 4); }
+
+inline GUTF8String
+GIFFChunk::get_type(void) const { return type; }
+
+inline GUTF8String
+GIFFChunk::get_full_name(void) const { return get_type()+":"+get_name(); }
+
+inline bool
+GIFFChunk::is_container(void) const { return type.length()!=0; }
+
+inline TArray<char>
+GIFFChunk::get_data(void) const { return data; }
+
+inline
+GIFFChunk::GIFFChunk(void) { name[0]=0; }
+
+inline
+GIFFChunk::GIFFChunk(const GUTF8String &name) { set_name(name); }
+
+inline
+GIFFChunk::GIFFChunk(const GUTF8String &name, const TArray<char> & data_in) :
+ data(data_in)
+{
+ set_name(name);
+}
+
+//************************************************************************
+
+/** Intuitive interface to IFF files.
+
+ It's too terrible to keep reading/writing IFF files chunk after chunk
+ using {\Ref IFFByteStream}s. This class allows you to operate with chunks
+ as with structures or arrays without even caring about the byte streams.
+
+ Some of the examples are below:
+ \begin{verbatim}
+ GP<GIFFChunk> chunk;
+ chunk=manager1.get_chunk("BG44[2]");
+ manager2.add_chunk(".FORM:DJVU.BG44[-1]", chunk);
+ \end{verbatim}
+
+ {\bf Chunk name}
+ \begin{itemize}
+ \item Every chunk name may contain optional prefix #FORM:#, #LIST:#,
+ #PROP:# or #CAT:#. If the prefix is omitted and the chunk happens
+ to contain other chunks, #FORM:# will be assumed.
+ \item Every chunk name may be {\em short} or {\em complete}.
+ {\em short} chunk names may not contain dots as they're a
+ subchunks names with respect to a given chunk.
+ {\em complete} chunk names may contain dots. But there may be
+ or may not be the {\em leading dot} in the name. If the
+ {\em leading dot} is present, then the name is assumed to contain
+ the name of the top-level chunk as well. Otherwise it's treated
+ {\em with respect} to the top-level chunk. You may want to use
+ the leading dot only when you add a chunk to an empty document,
+ since a command like #manager.addChunk(".FORM:DJVU.BG44", chunk)#
+ will create the top level chunk of the requested type (#FORM:DJVU#)
+ and will add chunk #BG44# to it {\em automatically}.
+ \item You may use {\em brackets} in the name to specify the chunk's
+ position. The meaning of the number inside the brackets depends
+ on the function you call. In most of the cases this is the number
+ of the chunk with the given name in the parent chunk. But sometimes
+ (as in #addChunk(name, buffer, length)#) the brackets at the
+ end of the #name# actually specify the {\em position} of the
+ chunk in the parent. For example, to insert #INCL# chunk into
+ #DJVU# form at position #1# (make it the second) you may want to
+ use #manager.addChunk(".DJVU.INCL[1]", data, size)#. At the same
+ time, to get 2-nd chunk with name #BG44# from form #DJVU# you
+ should do smth like #chunk=manager.getChunk("BG44[1]")#. Note, that
+ here the manager will search for chunk #BG44# in form #DJVU# and
+ will take the second {\em found} one.
+ \end{itemize} */
+
+class GIFFManager : public GPEnabled
+{
+protected:
+ GIFFManager(void);
+ void init(void);
+ void init(const GUTF8String &name);
+public:
+ /// Default creator.
+ static GP<GIFFManager> create(void);
+
+ /** Creates the {\Ref GIFFManager} and assigns name {\em name} to
+ the top-level chunk. you may use chunk type names (before colon)
+ to set the top-level chunk type, or omit it to work with #FORM# */
+ static GP<GIFFManager> create(const GUTF8String &name);
+
+ /// Virtual destructor.
+ virtual ~GIFFManager(void);
+
+ /// Sets the name of the top level chunk to {\em name}
+ void set_name(const GUTF8String &name);
+ /** Adds the chunk {\em chunk} to chunk with name {\em parent_name} at
+ position {\em pos}. {\em parent_name} may contain dots, brackets
+ and colons. All missing chunks in the chain will be created.
+
+ {\bf Examples:}
+ \begin{verbatim}
+ ;; To set the top-level chunk to 'ch'
+ m.addChunk(".", ch);
+ ;; To add 'ch' to the top-level chunk "DJVU" creating it if necessary
+ m.addChunk(".DJVU", ch);
+ ;; Same as above regardless of top-level chunk name
+ m.addChunk("", ch);
+ ;; To add 'ch' to 2nd FORM DJVU in top-level form DJVM
+ m.addChunk(".FORM:DJVM.FORM:DJVU[1]", ch);
+ ;; Same thing regardless of the top-level chunk name
+ m.addChunk("FORM:DJVU[1]", ch);
+ \end{verbatim} */
+ void add_chunk(GUTF8String parent_name, const GP<GIFFChunk> & chunk, int pos=-1);
+ /** If {\em name}={\em name1}.{\em name2} where {\em name2} doesn't
+ contain dots, then #addChunk()# will create plain chunk with
+ name {\em name2} with data {\em buffer} of size {\em length} and
+ will add it to chunk {\em name1} in the same way as
+ #addChunk(name, chunk, pos)# function would do it. The #pos# in
+ this case is either #-1# (append) or is extracted from between
+ brackets if the {\em name} ends with them.
+
+ {\bf Examples:}
+ \begin{verbatim}
+ ;; To insert INCL chunk at position 2 (make it 3rd)
+ m.addChunk("INCL[2]", data, length);
+ ;; To append chunk BG44 to 2nd DjVu file inside DjVm archive:
+ m.addChunk(".DJVM.DJVU[1].BG44", data, length);
+ \end{verbatim} */
+ void add_chunk(GUTF8String name, const TArray<char> & data);
+ /** Will remove chunk with name {\em name}. You may use dots, colons
+ and brackets to specify the chunk uniquely.
+
+ {\bf Examples:}
+ \begin{verbatim}
+ ;; To remove 2nd DjVu document from DjVm archive use
+ m.delChunk(".DJVM.DJVU[1]");
+ ;; Same thing without top-level chunk name specification
+ m.delChunk("DJVU[1]");
+ ;; Same thing for the first DJVU chunk
+ m.delChunk("DJVU");
+ \end{verbatim}
+ */
+ void del_chunk(GUTF8String name);
+ void del_chunk(void);
+ /** Will return the number of chunks with given name. The {\em name} may
+ not end with brackets, but may contain them inside. It may also
+ contain dots and colons. If {\em name} is ZERO, the total number
+ of chunks will be returned.
+
+ {\bf Examples:}
+ \begin{verbatim}
+ ;; To get the number of DJVU forms inside DjVm document
+ m.getChunksNumber(".DJVM.DJVU");
+ ;; Same thing without top-level chunk name specification
+ m.getChunksNumber("DJVU");
+ \end{verbatim}
+ */
+ int get_chunks_number(const GUTF8String &name);
+ int get_chunks_number(void);
+
+ /** Returns the chunk with name {\em name}. The {\em name} may contain dots
+ colons and slashes. If {\em position} is not zero, #*position# will
+ be assigned the position of the found chunk in the parent chunk.
+
+ {\bf Examples:}
+ \begin{verbatim}
+ ;; To get the directory chunk of DjVm document
+ m.getChunk(".DJVM.DIR0");
+ ;; To get chunk corresponding to 2nd DJVU form
+ m.getChunk(".DJVU[1]");
+ \end{verbatim} */
+ GP<GIFFChunk>get_chunk(GUTF8String name, int * position=0);
+
+ /** Loads the composite {\em chunk}'s contents from stream {\em istr}. */
+ void load_chunk(IFFByteStream & istr, GP<GIFFChunk> chunk);
+ /** Loads the file contents from stream {\em str} */
+ void load_file(GP<ByteStream> str);
+ /** Loads the file contents from the data array {\em data} */
+ void load_file(const TArray<char> & data);
+ /** Saves all the chunks into stream {\em str} */
+ void save_file(GP<ByteStream> str);
+ /** Saves all the chunks into the data array {\em data} */
+ void save_file(TArray<char> & data);
+
+private:
+ GP<GIFFChunk> top_level;
+
+ static const char * check_leading_dot(const GUTF8String &name);
+private: //dummy methods
+ static void save_file(ByteStream *);
+ static void load_file(ByteStream *);
+};
+
+inline void
+GIFFManager::set_name(const GUTF8String &name)
+{
+ top_level->set_name(name);
+}
+
+inline
+GIFFManager::GIFFManager(void) {}
+
+inline void
+GIFFManager::init(void)
+{
+ top_level=GIFFChunk::create();
+}
+
+inline void
+GIFFManager::init(const GUTF8String &name)
+{
+ top_level=GIFFChunk::create(name);
+}
+
+
+#ifdef HAVE_NAMESPACES
+}
+# ifndef NOT_USING_DJVU_NAMESPACE
+using namespace DJVU;
+# endif
+#endif
+#endif