source: trunk/libdjvu/DjVmDir.cpp @ 206

Last change on this file since 206 was 206, checked in by Eugene Romanenko, 14 years ago

DJVU plugin: djvulibre updated to version 3.5.19

File size: 23.9 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.13 2007/03/25 20:48:29 leonb Exp $
57// $Name: release_3_5_19 $
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                if(!file->oldname.length() || file->oldname == new_id)
473                  file->flags &= ~File::HAS_NAME;
474                else
475                  file->flags |= File::HAS_NAME;
476            }
477          else 
478            {
479              if (!file->name.length() || file->name == file->id)
480                file->flags &= ~File::HAS_NAME;
481              else
482                file->flags |= File::HAS_NAME;
483            }
484          if (file->title.length() && (file->title!=file->id))
485            file->flags |= File::HAS_TITLE;
486          else
487            file->flags &= ~File::HAS_TITLE;
488
489       bs_str.write8(file->flags);
490     }
491
492     DEBUG_MSG("storing and compressing names...\n");
493     for(pos=files_list;pos;++pos)
494     {
495         GP<File> file=files_list[pos];
496         GUTF8String id;
497         GUTF8String name;
498         GUTF8String title;
499         if (xdo_rename)
500           {
501             id = file->name;
502             if (! id)
503               id = file->id;
504             if ((file->flags) & File::HAS_NAME)
505               name = file->oldname;
506           }
507         else
508           {
509             id=file->id;
510             if ((file->flags) & File::HAS_NAME)
511               name = file->name;
512           }
513         if ((file->flags) & File::HAS_TITLE)
514           title = file->title;
515         DEBUG_MSG("rename=" <<xdo_rename<<" id='" << id << "' name='" << name << "' title='" << title << "'\n");
516         bs_str.writestring(id);
517         bs_str.write8(0);
518         if (name.length())
519           {
520             bs_str.writestring(name);
521             bs_str.write8(0);
522           }
523         if (title.length())
524           {
525             bs_str.writestring(title);
526             bs_str.write8(0);
527           }
528     }
529    }
530  DEBUG_MSG("done\n");
531}
532
533GP<DjVmDir::File>
534DjVmDir::page_to_file(int page_num) const
535{
536   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
537
538   return (page_num<page2file.size())?page2file[page_num]:(GP<DjVmDir::File>(0));
539}
540
541GP<DjVmDir::File>
542DjVmDir::name_to_file(const GUTF8String & name) const
543{
544   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
545
546   GPosition pos;
547   return (name2file.contains(name, pos))?name2file[pos]:(GP<DjVmDir::File>(0));
548}
549
550GP<DjVmDir::File>
551DjVmDir::id_to_file(const GUTF8String &id) const
552{
553   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
554
555   GPosition pos;
556   return (id2file.contains(id, pos))?id2file[pos]:(GP<DjVmDir::File>(0));
557}
558
559GP<DjVmDir::File>
560DjVmDir::title_to_file(const GUTF8String &title) const
561{
562   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
563   GPosition pos;
564   return (title2file.contains(title, pos))?title2file[pos]:(GP<DjVmDir::File>(0));
565}
566
567GP<DjVmDir::File>
568DjVmDir::pos_to_file(int fileno, int *ppageno) const
569{
570  GCriticalSectionLock lock((GCriticalSection *) &class_lock);
571  GPosition pos = files_list;
572  int pageno = 0;
573  while (pos && --fileno >= 0) {
574    if (files_list[pos]->is_page())
575      ++pageno;
576    ++pos;
577  }
578  if (!pos)
579    return 0;
580  if (ppageno)
581    *ppageno = pageno;
582  return files_list[pos];
583}
584
585GPList<DjVmDir::File>
586DjVmDir::get_files_list(void) const
587{
588  GCriticalSectionLock lock((GCriticalSection *) &class_lock);
589  return files_list;
590}
591
592int
593DjVmDir::get_files_num(void) const
594{
595  GCriticalSectionLock lock((GCriticalSection *) &class_lock);
596  return files_list.size();
597}
598
599int
600DjVmDir::get_pages_num(void) const
601{
602   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
603   return page2file.size();
604}
605
606int
607DjVmDir::get_file_pos(const File * f) const
608{
609   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
610   int cnt;
611   GPosition pos;
612   for(pos=files_list, cnt=0;pos&&(files_list[pos]!=f);++pos, cnt++)
613                   continue;
614   return (pos)?cnt:(-1);
615}
616
617int
618DjVmDir::get_page_pos(int page_num) const
619{
620   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
621   
622   GP<File> file=page_to_file(page_num);
623   return (file)?get_file_pos(file):(-1);
624}
625
626GP<DjVmDir::File>
627DjVmDir::get_shared_anno_file(void) const
628{
629   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
630
631   GP<File> file;
632   for(GPosition pos=files_list;pos;++pos)
633   {
634      GP<File> frec=files_list[pos];
635      if (frec->is_shared_anno())
636      {
637         file=frec;
638         break;
639      }
640   }
641   return file;
642}
643
644int
645DjVmDir::insert_file(const GP<File> & file, int pos_num)
646{
647   DEBUG_MSG("DjVmDir::insert_file(): name='" 
648             << file->name << "', pos=" << pos_num << "\n");
649   DEBUG_MAKE_INDENT(3);
650   
651   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
652   
653   if (pos_num<0)
654     pos_num=files_list.size();
655
656   //// Modify maps
657   //   if (! File::is_legal_id(file->id))
658   //     G_THROW( ERR_MSG("DjVmDir.bad_file") "\t" + file->id);
659   if (id2file.contains(file->id))
660     G_THROW( ERR_MSG("DjVmDir.dupl_id2") "\t" + file->id);
661   if (name2file.contains(file->name))
662     G_THROW( ERR_MSG("DjVmDir.dupl_name2") "\t" + file->name);
663   name2file[file->name]=file;
664   id2file[file->id]=file;
665   if (file->title.length())
666     {
667       if (title2file.contains(file->title)) 
668         // duplicate titles may become ok some day
669         G_THROW( ERR_MSG("DjVmDir.dupl_title2") "\t" + file->title);
670       title2file[file->title]=file;
671     }
672
673      // Make sure that there is no more than one file with shared annotations
674   if (file->is_shared_anno())
675   {
676      for(GPosition pos=files_list;pos;++pos)
677         if (files_list[pos]->is_shared_anno())
678            G_THROW( ERR_MSG("DjVmDir.multi_save2") );
679   }
680   
681      // Add the file to the list
682   int cnt;
683   GPosition pos;
684   for(pos=files_list, cnt=0;pos&&(cnt!=pos_num);++pos, cnt++)
685                   continue;
686   if (pos)
687     files_list.insert_before(pos, file);
688   else
689     files_list.append(file);
690
691   if (file->is_page())
692   {
693         // This file is also a page
694         // Count its number
695      int page_num=0;
696      for(pos=files_list;pos;++pos)
697      {
698         GP<File> &f=files_list[pos];
699         if (f==file)
700           break;
701         if (f->is_page())
702           page_num++;
703      }
704
705      int i;
706      page2file.resize(page2file.size());
707      for(i=page2file.size()-1;i>page_num;i--)
708         page2file[i]=page2file[i-1];
709      page2file[page_num]=file;
710      for(i=page_num;i<page2file.size();i++)
711         page2file[i]->page_num=i;
712   }
713   return pos_num;
714}
715
716void
717DjVmDir::delete_file(const GUTF8String &id)
718{
719   DEBUG_MSG("Deleting file with id='" << (const char *)id << "'\n");
720   DEBUG_MAKE_INDENT(3);
721
722   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
723   
724   for(GPosition pos=files_list;pos;++pos)
725   {
726      GP<File> & f=files_list[pos];
727      if (id == f->id)
728      {
729         name2file.del(f->name);
730         id2file.del(f->id);
731         title2file.del(f->title);
732         if (f->is_page())
733         {
734            for(int page=0;page<page2file.size();page++)
735            {
736               if (page2file[page]==f)
737               {
738                  int i;
739                  for(i=page;i<page2file.size()-1;i++)
740                     page2file[i]=page2file[i+1];
741                  page2file.resize(page2file.size()-2);
742                  for(i=page;i<page2file.size();i++)
743                     page2file[i]->page_num=i;
744                  break;
745               }
746            }
747         }
748         files_list.del(pos);
749         break;
750      }
751   }
752}
753
754void
755DjVmDir::set_file_name(const GUTF8String &id, const GUTF8String &name)
756{
757   DEBUG_MSG("DjVmDir::set_file_name(): id='" << id << "', name='" << name << "'\n");
758   DEBUG_MAKE_INDENT(3);
759   
760   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
761
762   GPosition pos;
763   
764      // First see, if the name is unique
765   for(pos=files_list;pos;++pos)
766   {
767      GP<File> file=files_list[pos];
768      if (file->id!=id && file->name==name)
769        G_THROW( ERR_MSG("DjVmDir.name_in_use") "\t" + GUTF8String(name));
770   }
771
772      // Check if ID is valid
773   if (!id2file.contains(id, pos))
774      G_THROW( ERR_MSG("DjVmDir.no_info") "\t" + GUTF8String(id));
775   GP<File> file=id2file[pos];
776   name2file.del(file->name);
777   file->name=name;
778   name2file[name]=file;
779}
780
781void
782DjVmDir::set_file_title(const GUTF8String &id, const GUTF8String &title)
783{
784   DEBUG_MSG("DjVmDir::set_file_title(): id='" << id << "', title='" << title << "'\n");
785   DEBUG_MAKE_INDENT(3);
786   GCriticalSectionLock lock((GCriticalSection *) &class_lock);
787   GPosition pos;
788      // Check if ID is valid
789   if (!id2file.contains(id, pos))
790      G_THROW( ERR_MSG("DjVmDir.no_info") "\t" + GUTF8String(id));
791   GP<File> file=id2file[pos];
792   title2file.del(file->title);
793   file->title=title;
794   title2file[title]=file;
795}
796
797GPList<DjVmDir::File>
798DjVmDir::resolve_duplicates(const bool save_as_bundled)
799{
800  GCriticalSectionLock lock((GCriticalSection *) &class_lock);
801  // Make sure all the filenames are unique.
802  GPosition pos;
803  GMap<GUTF8String,void *> save_map;
804  GMap<GUTF8String,GPList<DjVmDir::File> > conflicts;
805  for(pos=files_list;pos;++pos)
806  {
807    const GUTF8String save_name=files_list[pos]->check_save_name(save_as_bundled).downcase();
808    if(save_map.contains(save_name))
809    {
810      conflicts[save_name].append(files_list[pos]);
811    }else
812    {
813      save_map[save_name]=0;
814    }
815  }
816  for(pos=conflicts;pos;++pos)
817  {
818    const GUTF8String &save_name=conflicts.key(pos);
819    const int dot=save_name.rsearch('.',0);
820    GPList<DjVmDir::File> &cfiles=conflicts[pos];
821    int count=1;
822    for(GPosition qpos=cfiles;qpos;++qpos)
823    {
824      GUTF8String new_name=cfiles[qpos]->get_load_name();
825      if((new_name != GUTF8String(GNativeString(new_name)))
826        ||conflicts.contains(new_name))
827      {
828        do
829        {
830          new_name=(dot<0)
831            ?(save_name+"-"+GUTF8String(count++))
832            :(save_name.substr(0,dot)+"-"+GUTF8String(count++)+
833              save_name.substr(dot,(unsigned int)(-1)));
834        } while(save_map.contains(new_name.downcase()));
835      }
836      cfiles[qpos]->set_save_name(new_name);
837      save_map[new_name]=0;
838    }
839  }
840  return files_list;
841}
842
843
844#ifdef HAVE_NAMESPACES
845}
846# ifndef NOT_USING_DJVU_NAMESPACE
847using namespace DJVU;
848# endif
849#endif
Note: See TracBrowser for help on using the repository browser.