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

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 <eaf@geocities.com> -- 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