source: trunk/libdjvu/DjVmDir.cpp @ 280

Last change on this file since 280 was 280, checked in by rbri, 12 years ago

DJVU plugin: djvulibre updated to version 3.5.22

File size: 23.7 KB
Line 
1//C-  -*- C++ -*-
2//C- -------------------------------------------------------------------
3//C- DjVuLibre-3.5
4//C- Copyright (c) 2002  Leon Bottou and Yann Le Cun.
5//C- Copyright (c) 2001  AT&T
6//C-
7//C- This software is subject to, and may be distributed under, the
8//C- GNU General Public License, either Version 2 of the license,
9//C- or (at your option) any later version. The license should have
10//C- accompanied the software or you may obtain a copy of the license
11//C- from the Free Software Foundation at http://www.fsf.org .
12//C-
13//C- This program is distributed in the hope that it will be useful,
14//C- but WITHOUT ANY WARRANTY; without even the implied warranty of
15//C- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16//C- GNU General Public License for more details.
17//C-
18//C- DjVuLibre-3.5 is derived from the DjVu(r) Reference Library from
19//C- Lizardtech Software.  Lizardtech Software has authorized us to
20//C- replace the original DjVu(r) Reference Library notice by the following
21//C- text (see doc/lizard2002.djvu and doc/lizardtech2007.djvu):
22//C-
23//C-  ------------------------------------------------------------------
24//C- | DjVu (r) Reference Library (v. 3.5)
25//C- | Copyright (c) 1999-2001 LizardTech, Inc. All Rights Reserved.
26//C- | The DjVu Reference Library is protected by U.S. Pat. No.
27//C- | 6,058,214 and patents pending.
28//C- |
29//C- | This software is subject to, and may be distributed under, the
30//C- | GNU General Public License, either Version 2 of the license,
31//C- | or (at your option) any later version. The license should have
32//C- | accompanied the software or you may obtain a copy of the license
33//C- | from the Free Software Foundation at http://www.fsf.org .
34//C- |
35//C- | The computer code originally released by LizardTech under this
36//C- | license and unmodified by other parties is deemed "the LIZARDTECH
37//C- | ORIGINAL CODE."  Subject to any third party intellectual property
38//C- | claims, LizardTech grants recipient a worldwide, royalty-free,
39//C- | non-exclusive license to make, use, sell, or otherwise dispose of
40//C- | the LIZARDTECH ORIGINAL CODE or of programs derived from the
41//C- | LIZARDTECH ORIGINAL CODE in compliance with the terms of the GNU
42//C- | General Public License.   This grant only confers the right to
43//C- | infringe patent claims underlying the LIZARDTECH ORIGINAL CODE to
44//C- | the extent such infringement is reasonably necessary to enable
45//C- | recipient to make, have made, practice, sell, or otherwise dispose
46//C- | of the LIZARDTECH ORIGINAL CODE (or portions thereof) and not to
47//C- | any greater extent that may be necessary to utilize further
48//C- | modifications or combinations.
49//C- |
50//C- | The LIZARDTECH ORIGINAL CODE is provided "AS IS" WITHOUT WARRANTY
51//C- | OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
52//C- | TO ANY WARRANTY OF NON-INFRINGEMENT, OR ANY IMPLIED WARRANTY OF
53//C- | MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
54//C- +------------------------------------------------------------------
55//
56// $Id: DjVmDir.cpp,v 1.14 2008/08/05 20:50:35 bpearlmutter Exp $
57// $Name: release_3_5_22 $
58
59#ifdef HAVE_CONFIG_H
60# include "config.h"
61#endif
62#if NEED_GNUG_PRAGMAS
63# pragma implementation
64#endif
65
66#include "DjVmDir.h"
67#include "BSByteStream.h"
68#include "GURL.h"
69#include "debug.h"
70
71#include <ctype.h>
72
73
74#ifdef HAVE_NAMESPACES
75namespace DJVU {
76# ifdef NOT_DEFINED // Just to fool emacs c++ mode
77}
78#endif
79#endif
80
81
82GP<DjVmDir::File>
83DjVmDir::File::create(const GUTF8String &load_name,
84  const GUTF8String &save_name, const GUTF8String &title,
85  const FILE_TYPE file_type)
86{
87  File *file_ptr=new File();
88  GP<File> file=file_ptr;
89  file_ptr->set_load_name(load_name);
90  file_ptr->set_save_name(save_name);
91  file_ptr->set_title(title);
92  file_ptr->flags=(file_type & TYPE_MASK);
93  return file;
94}
95
96const GUTF8String &
97DjVmDir::File::check_save_name(const bool xis_bundled)
98{
99  if(!xis_bundled && !valid_name)
100  {
101    GUTF8String retval=name.length()?name:id;
102    if(GUTF8String(GNativeString(retval)) != retval)
103    {
104      const_cast<bool &>(valid_name)=true;
105      char *buf;
106      GPBuffer<char> gbuf(buf,2*retval.length()+1);
107      char *s=buf;
108      int i=0;
109      for(char c=retval[i++];c;)
110      {
111        static const char hex[]="0123456789ABCDEF";
112        int len=retval.nextChar(i)-i;
113        if(len>1 || ((len == 1)&&(c&0x80)))
114        {
115          do
116          {
117            s++[0]=hex[(c>>4)&0xf];
118            s++[0]=hex[(c&0xf)];
119            c=retval[i++];
120          } while(c && ((--len) > 0));
121        }else
122        {
123          s++[0]=c;
124          c=retval[i++];
125        }
126      }
127      s++[0]=0;
128      oldname=retval;
129      name=buf;
130    }
131    const_cast<bool &>(valid_name)=true;
132  }
133  return *(name.length()?&name:&id);
134}
135
136const GUTF8String &
137DjVmDir::File::get_save_name(void) const
138{
139  return *(name.length()?&name:&id);
140}
141
142void
143DjVmDir::File::set_load_name(const GUTF8String &xid)
144{
145  GURL url=GURL::UTF8(xid);
146  if(!url.is_valid())
147  {
148    url=GURL::Filename::UTF8(xid);
149  }
150  id=url.fname();
151}
152
153void
154DjVmDir::File::set_save_name(const GUTF8String &xname)
155{
156  GURL url;
157  valid_name=false;
158  if(!xname.length())
159  {
160    GURL url=GURL::UTF8(id);
161    if(!url.is_valid())
162    {
163      name=id;
164    }else
165    {
166      name=url.fname();
167    }
168  }else
169  {
170    GURL url=GURL::UTF8(xname);
171    if(!url.is_valid())
172    {
173      url=GURL::Filename::UTF8(xname);
174    }
175    name=url.fname();
176  }
177  oldname="";
178}
179
180/* DjVmDir::File */
181
182DjVmDir::File::File(void) : offset(0), size(0), valid_name(false),
183   flags(0), page_num(-1) { }
184
185GUTF8String
186DjVmDir::File::get_str_type(void) const
187{
188   GUTF8String type;
189   switch(flags & TYPE_MASK)
190   {
191      case INCLUDE:
192        type="INCLUDE";
193        break;
194      case PAGE:
195        type="PAGE";
196        break;
197      case THUMBNAILS:
198        type="THUMBNAILS";
199        break;
200      case SHARED_ANNO:
201        type="SHARED_ANNO";
202        break;
203      default:
204        //  Internal error: please modify DjVmDir::File::get_str_type()
205        //  to contain all possible File types.
206              G_THROW( ERR_MSG("DjVmDir.get_str_type") );
207   }
208   return type;
209}
210
211
212const int DjVmDir::version=1;
213
214void 
215DjVmDir::decode(const GP<ByteStream> &gstr)
216{
217   ByteStream &str=*gstr;
218   DEBUG_MSG("DjVmDir::decode(): decoding contents of 'DIRM' chunk...\n");
219   DEBUG_MAKE_INDENT(3);
220   
221   GCriticalSectionLock lock(&class_lock);
222
223   GPosition pos;
224
225   files_list.empty();
226   page2file.resize(-1);
227   name2file.empty();
228   id2file.empty();
229   title2file.empty();
230
231   int ver=str.read8();
232   bool bundled=(ver & 0x80)!=0;
233   ver&=0x7f;
234
235   DEBUG_MSG("DIRM version=" << ver << ", our version=" << version << "\n");
236   if (ver>version)
237      G_THROW( ERR_MSG("DjVmDir.version_error") "\t" 
238               + GUTF8String(version) + "\t" + GUTF8String(ver));
239   // Unable to read DJVM directories of versions higher than xxx
240   // Data version number is yyy.
241   DEBUG_MSG("bundled directory=" << bundled << "\n");
242   DEBUG_MSG("reading the directory records...\n");
243   int files=str.read16();
244   DEBUG_MSG("number of files=" << files << "\n");
245
246   if (files)
247   {
248      DEBUG_MSG("reading offsets (and sizes for ver==0)\n");
249      for(int nfile=0;nfile<files;nfile++)
250      {
251         GP<File> file=new File();
252         files_list.append(file);
253         if (bundled)
254         {
255            file->offset=str.read32();
256            if (ver==0)
257              file->size=str.read24();
258            if (file->offset==0)
259               G_THROW( ERR_MSG("DjVmDir.no_indirect") );
260         } else
261         {
262           file->offset=file->size=0;
263         }
264      }
265
266      GP<ByteStream> gbs_str=BSByteStream::create(gstr);
267      ByteStream &bs_str=*gbs_str;
268      if (ver>0)
269      {
270         DEBUG_MSG("reading and decompressing sizes...\n");
271         for(GPosition pos=files_list;pos;++pos)
272            files_list[pos]->size=bs_str.read24();
273      }
274         
275      DEBUG_MSG("reading and decompressing flags...\n");
276      for(pos=files_list;pos;++pos)
277         files_list[pos]->flags=bs_str.read8();
278
279      if (!ver)
280      {
281         DEBUG_MSG("converting flags from version 0...\n");
282         for(pos=files_list;pos;++pos)
283         {
284            unsigned char flags_0=files_list[pos]->flags;
285            unsigned char flags_1;
286            flags_1=(flags_0 & File::IS_PAGE_0)?(File::PAGE):(File::INCLUDE);
287            if (flags_0 & File::HAS_NAME_0)
288              flags_1|=File::HAS_NAME;
289            if (flags_0 & File::HAS_TITLE_0)
290              flags_1|=File::HAS_TITLE;
291            files_list[pos]->flags=flags_1;
292         }
293      }
294   
295      DEBUG_MSG("reading and decompressing names...\n");
296      GTArray<char> strings;
297      char buffer[1024];
298      int length;
299      while((length=bs_str.read(buffer, 1024)))
300      {
301         int strings_size=strings.size();
302         strings.resize(strings_size+length-1);
303         memcpy((char*) strings+strings_size, buffer, length);
304      }
305      DEBUG_MSG("size of decompressed names block=" << strings.size() << "\n");
306   
307         // Copy names into the files
308      const char * ptr=strings;
309      for(pos=files_list;pos;++pos)
310      {
311         GP<File> file=files_list[pos];
312
313         file->id=ptr;
314         ptr+=file->id.length()+1;
315         if (file->flags & File::HAS_NAME)
316         {
317            file->name=ptr;
318            ptr+=file->name.length()+1;
319         } else
320         {
321            file->name=file->id;
322         }
323         if (file->flags & File::HAS_TITLE)
324         {
325            file->title=ptr;
326       ptr+=file->title.length()+1;
327         } else
328       file->title=file->id;
329   /* msr debug:  multipage file, file->title is null. 
330         DEBUG_MSG(file->name << ", " << file->id << ", " << file->title << ", " <<
331                   file->offset << ", " << file->size << ", " <<
332                   file->is_page() << "\n"); */
333      }
334
335         // Check that there is only one file with SHARED_ANNO flag on
336      int shared_anno_cnt=0;
337      for(pos=files_list;pos;++pos)
338      {
339         if (files_list[pos]->is_shared_anno())
340         {
341            shared_anno_cnt++;
342         }
343      }
344      if (shared_anno_cnt>1)
345        G_THROW( ERR_MSG("DjVmDir.corrupt") );
346
347         // Now generate page=>file array for direct access
348      int pages=0;
349      for(pos=files_list;pos;++pos)
350              pages+=files_list[pos]->is_page() ? 1 : 0;
351      DEBUG_MSG("got " << pages << " pages\n");
352      page2file.resize(pages-1);
353      int page_num=0;
354      for(pos=files_list;pos;++pos)
355      {
356               GP<File> file=files_list[pos];
357               if (file->is_page())
358               {
359                  page2file[page_num]=file;
360                  file->page_num=page_num++;
361               }
362      }
363
364         // Generate name2file map
365      for(pos=files_list;pos;++pos)
366      {
367               GP<File> file=files_list[pos];
368               if (name2file.contains(file->name))
369                  G_THROW( ERR_MSG("DjVmDir.dupl_name") "\t" + file->name );
370               name2file[file->name]=file;
371      }
372
373         // Generate id2file map
374      for(pos=files_list;pos;++pos)
375      {
376               GP<File> file=files_list[pos];
377               if (id2file.contains(file->id))
378                  G_THROW( ERR_MSG("DjVmDir.dupl_id") "\t" + file->id);
379               id2file[file->id]=file;
380      }
381
382         // Generate title2file map
383      for(pos=files_list;pos;++pos)
384      {
385               GP<File> file=files_list[pos];
386               if (file->title.length())
387               {
388                  if (title2file.contains(file->title))
389                     G_THROW( ERR_MSG("DjVmDir.dupl_title") "\t" + file->title);
390                  title2file[file->title]=file;
391               }
392      }
393   }
394}
395
396
397void
398DjVmDir::encode(const GP<ByteStream> &gstr, const bool do_rename) const
399{
400  bool bundled = true;
401  GPosition pos = files_list;
402  if (files_list.size() && !files_list[pos]->offset)
403    bundled = false;
404  for (pos=files_list; pos; ++pos)
405    if ( !bundled !=  !files_list[pos]->offset)
406      //  There directory contains both indirect and bundled records.
407      G_THROW( ERR_MSG("DjVmDir.bad_dir") );
408  // Do the real work
409  encode(gstr, bundled, do_rename);
410}
411
412void
413DjVmDir::encode(const GP<ByteStream> &gstr, const bool bundled, const bool do_rename) const
414{
415  ByteStream &str=*gstr;
416  DEBUG_MSG("DjVmDir::encode(): encoding contents of the 'DIRM' chunk do_rename=" << do_rename << "\n");
417  DEBUG_MAKE_INDENT(3);
418   
419  GCriticalSectionLock lock((GCriticalSection *) &class_lock);
420  GPosition pos;
421
422  DEBUG_MSG("encoding version number=" << version << ", bundled=" << bundled << "\n");
423  str.write8(version | ((int) bundled<< 7));
424   
425  DEBUG_MSG("storing the number of records=" << files_list.size() << "\n");
426  str.write16(files_list.size());
427
428  if (files_list.size())
429    {
430      // Check that there is only one file with shared annotations
431      int shared_anno_cnt=0;
432      for (pos=files_list; pos; ++pos)
433        if (files_list[pos]->is_shared_anno())
434          shared_anno_cnt++;
435      if (shared_anno_cnt>1)
436        G_THROW( ERR_MSG("DjVmDir.multi_save") );
437     
438      if (bundled)
439        {
440          // We need to store offsets uncompressed. That's because when
441          // we save a DjVmDoc, we first compress the DjVmDir with dummy
442          // offsets and after computing the real offsets we rewrite the
443          // DjVmDir, which should not change its size during this operation
444          DEBUG_MSG("storing offsets for every record\n");
445          for (pos=files_list; pos; ++pos)
446            {
447              GP<File> file=files_list[pos];
448              if (!file->offset)
449                // The directory contains record without offset
450                G_THROW( ERR_MSG("DjVmDir.bad_dir") );
451              str.write32(file->offset);
452            }
453        }
454
455      GP<ByteStream> gbs_str=BSByteStream::create(gstr, 50);
456      ByteStream &bs_str=*gbs_str;
457      DEBUG_MSG("storing and compressing sizes for every record\n");
458      for (pos=files_list; pos; ++pos)
459        {
460          const GP<File> file(files_list[pos]);
461          bs_str.write24(file->size);
462        }
463      DEBUG_MSG("storing and compressing flags for every record\n");
464      const bool xdo_rename=(do_rename||!bundled);
465      for (pos=files_list;pos;++pos)
466        {
467          const GP<File> file(files_list[pos]);
468          if (xdo_rename)
469            {
470              const GUTF8String new_id = file->name;
471              if (!new_id)
472                {
473                  if (!file->oldname.length() || file->oldname == new_id)
474                    file->flags &= ~File::HAS_NAME;
475                  else
476                    file->flags |= File::HAS_NAME;
477                }
478            }
479          else
480            {
481              if (!file->name.length() || file->name == file->id)
482                file->flags &= ~File::HAS_NAME;
483              else
484                file->flags |= File::HAS_NAME;
485            }
486          if (file->title.length() && (file->title!=file->id))
487            file->flags |= File::HAS_TITLE;
488          else
489            file->flags &= ~File::HAS_TITLE;
490
491          bs_str.write8(file->flags);
492        }
493
494     DEBUG_MSG("storing and compressing names...\n");
495     for(pos=files_list;pos;++pos)
496     {
497         GP<File> file=files_list[pos];
498         GUTF8String id;
499         GUTF8String name;
500         GUTF8String title;
501         if (xdo_rename)
502           {
503             id = file->name;
504             if (! id)
505               id = file->id;
506             if ((file->flags) & File::HAS_NAME)
507               name = file->oldname;
508           }
509         else
510           {
511             id=file->id;
512             if ((file->flags) & File::HAS_NAME)
513               name = file->name;
514           }
515         if ((file->flags) & File::HAS_TITLE)
516           title = file->title;
517         DEBUG_MSG("rename=" <<xdo_rename<<" id='" << id << "' name='" << name << "' title='" << title << "'\n");
518         bs_str.writestring(id);
519         bs_str.write8(0);
520         if (name.length())
521           {
522             bs_str.writestring(name);
523             bs_str.write8(0);
524           }
525         if (title.length())
526           {
527             bs_str.writestring(title);
528             bs_str.write8(0);
529           }
530     }
531    }
532  DEBUG_MSG("done\n");
533}
534
535GP<DjVmDir::File>
536DjVmDir::page_to_file(int page_num) const
537{
538   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
539
540   return (page_num<page2file.size())?page2file[page_num]:(GP<DjVmDir::File>(0));
541}
542
543GP<DjVmDir::File>
544DjVmDir::name_to_file(const GUTF8String & name) const
545{
546   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
547
548   GPosition pos;
549   return (name2file.contains(name, pos))?name2file[pos]:(GP<DjVmDir::File>(0));
550}
551
552GP<DjVmDir::File>
553DjVmDir::id_to_file(const GUTF8String &id) const
554{
555   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
556
557   GPosition pos;
558   return (id2file.contains(id, pos))?id2file[pos]:(GP<DjVmDir::File>(0));
559}
560
561GP<DjVmDir::File>
562DjVmDir::title_to_file(const GUTF8String &title) const
563{
564   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
565   GPosition pos;
566   return (title2file.contains(title, pos))?title2file[pos]:(GP<DjVmDir::File>(0));
567}
568
569GP<DjVmDir::File>
570DjVmDir::pos_to_file(int fileno, int *ppageno) const
571{
572  GCriticalSectionLock lock((GCriticalSection *) &class_lock);
573  GPosition pos = files_list;
574  int pageno = 0;
575  while (pos && --fileno >= 0) {
576    if (files_list[pos]->is_page())
577      ++pageno;
578    ++pos;
579  }
580  if (!pos)
581    return 0;
582  if (ppageno)
583    *ppageno = pageno;
584  return files_list[pos];
585}
586
587GPList<DjVmDir::File>
588DjVmDir::get_files_list(void) const
589{
590  GCriticalSectionLock lock((GCriticalSection *) &class_lock);
591  return files_list;
592}
593
594int
595DjVmDir::get_files_num(void) const
596{
597  GCriticalSectionLock lock((GCriticalSection *) &class_lock);
598  return files_list.size();
599}
600
601int
602DjVmDir::get_pages_num(void) const
603{
604   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
605   return page2file.size();
606}
607
608int
609DjVmDir::get_file_pos(const File * f) const
610{
611   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
612   int cnt;
613   GPosition pos;
614   for(pos=files_list, cnt=0;pos&&(files_list[pos]!=f);++pos, cnt++)
615                   continue;
616   return (pos)?cnt:(-1);
617}
618
619int
620DjVmDir::get_page_pos(int page_num) const
621{
622   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
623   
624   GP<File> file=page_to_file(page_num);
625   return (file)?get_file_pos(file):(-1);
626}
627
628GP<DjVmDir::File>
629DjVmDir::get_shared_anno_file(void) const
630{
631   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
632
633   GP<File> file;
634   for(GPosition pos=files_list;pos;++pos)
635   {
636      GP<File> frec=files_list[pos];
637      if (frec->is_shared_anno())
638      {
639         file=frec;
640         break;
641      }
642   }
643   return file;
644}
645
646int
647DjVmDir::insert_file(const GP<File> & file, int pos_num)
648{
649   DEBUG_MSG("DjVmDir::insert_file(): name='" 
650             << file->name << "', pos=" << pos_num << "\n");
651   DEBUG_MAKE_INDENT(3);
652   
653   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
654   
655   if (pos_num<0)
656     pos_num=files_list.size();
657
658   //// Modify maps
659   //   if (! File::is_legal_id(file->id))
660   //     G_THROW( ERR_MSG("DjVmDir.bad_file") "\t" + file->id);
661   if (id2file.contains(file->id))
662     G_THROW( ERR_MSG("DjVmDir.dupl_id2") "\t" + file->id);
663   if (name2file.contains(file->name))
664     G_THROW( ERR_MSG("DjVmDir.dupl_name2") "\t" + file->name);
665   name2file[file->name]=file;
666   id2file[file->id]=file;
667   if (file->title.length())
668     {
669       if (title2file.contains(file->title)) 
670         // duplicate titles may become ok some day
671         G_THROW( ERR_MSG("DjVmDir.dupl_title2") "\t" + file->title);
672       title2file[file->title]=file;
673     }
674
675      // Make sure that there is no more than one file with shared annotations
676   if (file->is_shared_anno())
677   {
678      for(GPosition pos=files_list;pos;++pos)
679         if (files_list[pos]->is_shared_anno())
680            G_THROW( ERR_MSG("DjVmDir.multi_save2") );
681   }
682   
683      // Add the file to the list
684   int cnt;
685   GPosition pos;
686   for(pos=files_list, cnt=0;pos&&(cnt!=pos_num);++pos, cnt++)
687                   continue;
688   if (pos)
689     files_list.insert_before(pos, file);
690   else
691     files_list.append(file);
692
693   if (file->is_page())
694   {
695         // This file is also a page
696         // Count its number
697      int page_num=0;
698      for(pos=files_list;pos;++pos)
699      {
700         GP<File> &f=files_list[pos];
701         if (f==file)
702           break;
703         if (f->is_page())
704           page_num++;
705      }
706
707      int i;
708      page2file.resize(page2file.size());
709      for(i=page2file.size()-1;i>page_num;i--)
710         page2file[i]=page2file[i-1];
711      page2file[page_num]=file;
712      for(i=page_num;i<page2file.size();i++)
713         page2file[i]->page_num=i;
714   }
715   return pos_num;
716}
717
718void
719DjVmDir::delete_file(const GUTF8String &id)
720{
721   DEBUG_MSG("Deleting file with id='" << (const char *)id << "'\n");
722   DEBUG_MAKE_INDENT(3);
723
724   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
725   
726   for(GPosition pos=files_list;pos;++pos)
727   {
728      GP<File> & f=files_list[pos];
729      if (id == f->id)
730      {
731         name2file.del(f->name);
732         id2file.del(f->id);
733         title2file.del(f->title);
734         if (f->is_page())
735         {
736            for(int page=0;page<page2file.size();page++)
737            {
738               if (page2file[page]==f)
739               {
740                  int i;
741                  for(i=page;i<page2file.size()-1;i++)
742                     page2file[i]=page2file[i+1];
743                  page2file.resize(page2file.size()-2);
744                  for(i=page;i<page2file.size();i++)
745                     page2file[i]->page_num=i;
746                  break;
747               }
748            }
749         }
750         files_list.del(pos);
751         break;
752      }
753   }
754}
755
756void
757DjVmDir::set_file_name(const GUTF8String &id, const GUTF8String &name)
758{
759   DEBUG_MSG("DjVmDir::set_file_name(): id='" << id << "', name='" << name << "'\n");
760   DEBUG_MAKE_INDENT(3);
761   
762   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
763
764   GPosition pos;
765   
766      // First see, if the name is unique
767   for(pos=files_list;pos;++pos)
768   {
769      GP<File> file=files_list[pos];
770      if (file->id!=id && file->name==name)
771        G_THROW( ERR_MSG("DjVmDir.name_in_use") "\t" + GUTF8String(name));
772   }
773
774      // Check if ID is valid
775   if (!id2file.contains(id, pos))
776      G_THROW( ERR_MSG("DjVmDir.no_info") "\t" + GUTF8String(id));
777   GP<File> file=id2file[pos];
778   name2file.del(file->name);
779   file->name=name;
780   name2file[name]=file;
781}
782
783void
784DjVmDir::set_file_title(const GUTF8String &id, const GUTF8String &title)
785{
786   DEBUG_MSG("DjVmDir::set_file_title(): id='" << id << "', title='" << title << "'\n");
787   DEBUG_MAKE_INDENT(3);
788   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
789   GPosition pos;
790      // Check if ID is valid
791   if (!id2file.contains(id, pos))
792      G_THROW( ERR_MSG("DjVmDir.no_info") "\t" + GUTF8String(id));
793   GP<File> file=id2file[pos];
794   title2file.del(file->title);
795   file->title=title;
796   title2file[title]=file;
797}
798
799GPList<DjVmDir::File>
800DjVmDir::resolve_duplicates(const bool save_as_bundled)
801{
802  GCriticalSectionLock lock((GCriticalSection *) &class_lock);
803  // Make sure all the filenames are unique.
804  GPosition pos;
805  GMap<GUTF8String,void *> save_map;
806  GMap<GUTF8String,GPList<DjVmDir::File> > conflicts;
807  for(pos=files_list;pos;++pos)
808  {
809    const GUTF8String save_name=files_list[pos]->check_save_name(save_as_bundled).downcase();
810    if(save_map.contains(save_name))
811    {
812      conflicts[save_name].append(files_list[pos]);
813    }else
814    {
815      save_map[save_name]=0;
816    }
817  }
818  for(pos=conflicts;pos;++pos)
819  {
820    const GUTF8String &save_name=conflicts.key(pos);
821    const int dot=save_name.rsearch('.',0);
822    GPList<DjVmDir::File> &cfiles=conflicts[pos];
823    int count=1;
824    for(GPosition qpos=cfiles;qpos;++qpos)
825    {
826      GUTF8String new_name=cfiles[qpos]->get_load_name();
827      if((new_name != GUTF8String(GNativeString(new_name)))
828        ||conflicts.contains(new_name))
829      {
830        do
831        {
832          new_name=(dot<0)
833            ?(save_name+"-"+GUTF8String(count++))
834            :(save_name.substr(0,dot)+"-"+GUTF8String(count++)+
835              save_name.substr(dot,(unsigned int)(-1)));
836        } while(save_map.contains(new_name.downcase()));
837      }
838      cfiles[qpos]->set_save_name(new_name);
839      save_map[new_name]=0;
840    }
841  }
842  return files_list;
843}
844
845
846#ifdef HAVE_NAMESPACES
847}
848# ifndef NOT_USING_DJVU_NAMESPACE
849using namespace DJVU;
850# endif
851#endif
Note: See TracBrowser for help on using the repository browser.