//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, either Version 2 of the license,

//C- or (at your option) any later version. 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 from

//C- Lizardtech Software.  Lizardtech Software has authorized us to

//C- replace the original DjVu(r) Reference Library notice by the following

//C- text (see doc/lizard2002.djvu and doc/lizardtech2007.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, either Version 2 of the license,

//C- | or (at your option) any later version. 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- +------------------------------------------------------------------

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#if NEED_GNUG_PRAGMAS

# pragma implementation

#endif

#include "IW44Image.h"

#include "GOS.h"

#include "GString.h"

#include "DjVuDocEditor.h"

#include "DjVuDumpHelper.h"

#include "BSByteStream.h"

#include "DjVuText.h"

#include "DjVuAnno.h"

#include "DjVuInfo.h"

#include "IFFByteStream.h"

#include "DataPool.h"

#include "DjVuPort.h"

#include "DjVuFile.h"

#include "DjVmNav.h"

#include "common.h"

static bool modified = false;

static bool verbose = false;

static bool save = false;

static bool nosave = false;

static bool utf8 = false;

static unsigned char utf8bom[] = { 0xef, 0xbb, 0xbf };

struct DJVUSEDGlobal 

{

  // Globals that need static initialization

  // are grouped here to work around broken compilers.

  GUTF8String djvufile;

  GP<ByteStream> cmdbs;

  GP<DjVuDocEditor> doc;

  GPList<DjVmDir::File> selected;

  GP<DjVuFile> file;

  GUTF8String fileid;

};

static DJVUSEDGlobal& g(void)

{

  static DJVUSEDGlobal g;

  return g;

}

static GUTF8String 

ToNative(GUTF8String s)

{

  if (utf8)

    return s;

  // fake the damn GUTF8/GNative type check

  GNativeString n = s;

  return GUTF8String((const char*)n);

}

// --------------------------------------------------

// PARSING BYTESTREAM

// --------------------------------------------------

// -- A bytestream that performs buffering and 

//    offers a stdio-like interface for reading files.

class ParsingByteStream : public ByteStream 

{

private:

  enum { bufsize=512 };

  const GP<ByteStream> &gbs;

  ByteStream &bs;

  unsigned char buffer[bufsize];

  int  bufpos;

  int  bufend;

  bool goteof;

  ParsingByteStream(const GP<ByteStream> &gbs;;

  int getbom(int c);

public:

  static GP<ParsingByteStream> create(const GP<ByteStream> &gbs) 

  { return new ParsingByteStream(gbs); }

  size_t read(void *buffer, size_t size);

  size_t write(const void *buffer, size_t size);

  long int tell() const;

  int eof();

  int unget(int c);

  inline int get();

  int get_spaces(bool skipseparator=false);

  GUTF8String get_token(bool skipseparator=false, bool compat=false);

  const char *get_error_context(int c=EOF);

};

ParsingByteStream::ParsingByteStream(const GP<ByteStream> &xgbs)

  : gbs(xgbs),bs(*gbs), bufpos(1), bufend(1), goteof(false)

{ 

}

int 

ParsingByteStream::eof() // aka. feof

{

  if (bufpos < bufend) 

    return false;

  if (goteof)

    return true;

  bufend = bufpos = 1;

  while (bs.read(buffer+bufend,1) && ++bufend<(int)bufsize)

    if (buffer[bufend-1]=='\r' || buffer[bufend-1]=='\n')

      break;

  if (bufend == bufpos)

    goteof = true;

  return goteof;

}

size_t 

ParsingByteStream::read(void *buf, size_t size)

{

  if (size < 1)

    return 0;

  if (bufend == bufpos) 

    {

      if (size >= bufsize)

        return bs.read(buf, size);

      if (eof())

        return 0;

    }

  if (bufpos + (int)size > bufend)

    size = bufend - bufpos;

  memcpy(buf, buffer+bufpos, size);

  bufpos += size;

  return size;

}

size_t 

ParsingByteStream::write(const void *, size_t )

{

  G_THROW("Cannot write() into a ParsingByteStream");

  return 0;

}

long int

ParsingByteStream::tell() const

{ 

  G_THROW("Cannot tell() a ParsingByteStream");

  return 0;

}

int 

ParsingByteStream::getbom(int c)

{

  int i = 0;

  while (c == utf8bom[i++])

    {

      if (i >= 3)

        i = 0;

      if (bufpos < bufend || !eof())

        c = buffer[bufpos++];

    }

  while (--i > 0)

    {

      unget(c);

      c = utf8bom[i-1];

    }

  return c;

}

inline int 

ParsingByteStream::get() // like getc() skipping bom.

{

  int c = EOF;

  if (bufpos < bufend || !eof())

    c = buffer[bufpos++];

  if (c == utf8bom[0])

    return getbom(c);

  return c;

}

int  

ParsingByteStream::unget(int c) // like ungetc()

{

  if (bufpos > 0 && c != EOF) 

    return buffer[--bufpos] = (unsigned char)c;

  return EOF;

}

int

ParsingByteStream::get_spaces(bool skipseparator)

{

   int c = get();

   while (c==' ' || c=='\t' || c=='\r' 

          || c=='\n' || c=='#' || c==';' )

     {

       if (c == '#')

         do { c=get(); } while (c!=EOF && c!='\n' && c!='\r');

       if (!skipseparator && (c=='\n' || c=='\r' || c==';'))

         break;

       c = get();

     }

   return c;

}

const char *

ParsingByteStream::get_error_context(int c)

{

  static char buffer[22];

  unget(c);

  int len = read((void*)buffer, sizeof(buffer)-1);

  buffer[(len>0)?len:0] = 0;

  for (int i=0; i

    if (buffer[i]=='\n')

      buffer[i] = 0;

  return buffer;

}

GUTF8String

ParsingByteStream::get_token(bool skipseparator, bool compat)

{

  GUTF8String str;

  int c = get_spaces(skipseparator);

  if (c == EOF)

    {

      return str;

    }

  if (!skipseparator && (c=='\n' || c=='\r' || c==';'))

    {

      unget(c);

      return str;

    }

  if (c != '\"' && c != '\'') 

    {

      while (c!=' ' && c!='\t' && c!='\r' && c!=';'

             && c!='\n' && c!='#' && c!=EOF)

        {

          str += c;

          c = get();

        }

      unget(c);

    }

  else 

    {

      int delim = c;

      c = get();

      while (c != delim && c!=EOF) 

        {

          if (c == '\\') 

            {

              c = get();

              if (compat && c!='\"')

                {

                  str += '\\';

                }

              else if (c>='0' && c<='7')

                {

                  int x = 0;

                  { // extra nesting for windows

                    for (int i=0; i<3 && c>='0' && c<='7'; i++) 

                    {

                      x = x * 8 + c - '0';

                      c = get();

                    }

                  }

                  unget(c);

                  c = x;

                }

              else 

                {

                  const char *tr1 = "tnrbfva";

                  const char *tr2 = "\t\n\r\b\f\013\007";

                  { // extra nesting for windows

                    for (int i=0; tr1[i]; i++)

                    {

                      if (c == tr1[i])

                        c = tr2[i];

                    }

                  }

                }

            }

          if (c != EOF)

            str += c;

          c = get();

        }

    }

  return str;

}

// --------------------------------------------------

// COMMANDS

// --------------------------------------------------

static void

vprint(const char *fmt, ... )

#ifdef __GNUC__

  __attribute__ ((format (printf, 1, 2)));

static void

vprint(const char *fmt, ... )

#endif

{

  if (verbose)

    {

      GUTF8String msg("");

      va_list args;

      va_start(args, fmt);

      msg.vformat(fmt, args);

      fprintf(stderr,"djvused: %s\n", (const char*)ToNative(msg));

    }

}

static void

verror(const char *fmt, ... )

#ifdef __GNUC__

  __attribute__ ((format (printf, 1, 2)));

static void

verror(const char *fmt, ... )

#endif

{

  GUTF8String msg;

  va_list args;

  va_start(args, fmt);

  msg.vformat(fmt, args);

  G_THROW((const char*)ToNative(msg));

}

static void

get_data_from_file(const char *cmd, ParsingByteStream &pbs, ByteStream &out)

{

  GUTF8String fname = pbs.get_token();

  if (! fname)

    {

      vprint("%s: enter data and terminate with a period on a single line", cmd);

      int c = pbs.get_spaces(true);

      pbs.unget(c);

      char skip[4];

      char term0[4] = "\n.\n";

      char term1[4] = "\r.\r";

      char *s = skip;

      int state = 1;

      while (state < 3) 

        {

          c = pbs.get();

          if (c == EOF)

            break;

          if ( c == term0[state] || c == term1[state] )

            {

              state += 1;

              *s++ = c;

            }

          else

            {

              { // extra nesting for windows

                for (char *m=skip; m

                  out.write8(*m);

              }

              s = skip;

              state = 0;

              if (c == '\n')

                pbs.unget(c);

              else if (c != EOF)

                out.write8(c);

            }

        }

      pbs.unget(c);

    }

  else

    {

      GP<ByteStream> in=ByteStream::create(GURL::Filename::UTF8(fname),"rb");

      out.copy(*in);

    }

}

static bool

char_unquoted(unsigned char c, bool eightbit)

{

  if (eightbit && c>=0x80)

    return true;

  if (c==0x7f || c=='\"' || c=='\\')

    return false;

  if (c>=0x20 && c<0x7f)

    return true;

  return false;

}

static void

print_c_string(const char *data, int length, ByteStream &out, bool eightbit)

{

  out.write("\"",1);

  while (*data && length>0) 

    {

      int span = 0;

      while (span

        span++;

      if (span > 0) 

        {

          out.write(data, span);

          data += span;

          length -= span;

        }

      else

        {

          char buf[5];

          static const char *tr1 = "\"\\tnrbf";

          static const char *tr2 = "\"\\\t\n\r\b\f";

          sprintf(buf,"\\%03o", (int)(((unsigned char*)data)[0]));

          { // extra nesting for windows

            for (int i=0; tr2[i]; i++)

              if (*(char*)data == tr2[i])

                buf[1] = tr1[i];

          }

          if (buf[1]<'0' || buf[1]>'3')

            buf[2] = 0;

          out.write(buf, ((buf[2]) ? 4 : 2));

          data += 1;

          length -= 1;

        }

    }

  out.write("\"",1);

}

void

command_ls(ParsingByteStream &)

{

  int pagenum = 0;

  GPList<DjVmDir::File> lst = g().doc->get_djvm_dir()->get_files_list();

  { // extra nesting for windows

    for (GPosition p=lst; p; ++p) 

    {

      GP<DjVmDir::File> f = lst[p];

      if (f->is_page())

        fprintf(stdout,"%4d P ", ++pagenum);

      else if (f->is_include())

        fprintf(stdout,"     I ");

      else if (f->is_thumbnails())

        continue;

      else if (f->is_shared_anno())

        fprintf(stdout,"     A ");

      else

        fprintf(stdout,"     ? ");

      GUTF8String id = f->get_load_name();

      fprintf(stdout,"%8d  %s", f->size, (const char*)ToNative(id));

      GUTF8String name = f->get_save_name();

      if (name != id)

        fprintf(stdout," F=%s", (const char*)ToNative(name));

      GUTF8String title = f->get_title();

      if (title != id && f->is_page())

        fprintf(stdout," T=%s", (const char*)ToNative(title));

      fprintf(stdout,"\n");

    }

  }

  if (g().doc->get_thumbnails_num() == g().doc->get_pages_num())

    fprintf(stdout,"     T %8s  %s\n", "", "<thumbnails>");

}

void

command_n(ParsingByteStream &)

{

  int pagenum = 0;

  GPList<DjVmDir::File> lst = g().doc->get_djvm_dir()->get_files_list();

  { // extra nesting for windows

    for (GPosition p=lst; p; ++p) 

    {

      GP<DjVmDir::File> f = lst[p];

      if (f->is_page())

        ++pagenum;

    }

  }

  fprintf(stdout,"%d\n", pagenum); 

}

void

command_dump(ParsingByteStream &)

{

  GP<DataPool> pool;

  // Need to be modified to handle "selected" list.

  if (g().file)

    pool = g().file->get_djvu_data(false, false);

  else

    pool = g().doc->get_init_data_pool();

  DjVuDumpHelper helper;

  GP<ByteStream> bs = helper.dump(pool);

  size_t size = bs->size();

  GUTF8String str;

  char *buf = str.getbuf(size);

  bs->seek(0);

  bs->readall(buf, size);

  GUTF8String ns = ToNative(str);

  GP<ByteStream> obs=ByteStream::create("w");

  obs->writall((const char*)ns, ns.length());

}

static void

print_size(const GP<DjVuFile> &file)

{

  GP<DjVuInfo> info = file->info;

  if (! info)

    {

      const GP<ByteStream> pbs(file->get_djvu_bytestream(false, false));

      const GP<IFFByteStream> iff(IFFByteStream::create(pbs));

      GUTF8String chkid;

      if (! iff->get_chunk(chkid))

        verror("Selected file contains no data");

      if (chkid == "FORM:DJVU")

        {

          while (iff->get_chunk(chkid) && chkid!="INFO")

            iff->close_chunk();

          if (chkid == "INFO")

            { 

              info = DjVuInfo::create();

              info->decode(*iff->get_bytestream());

            }

        }

      else if (chkid == "FORM:BM44" || chkid == "FORM:PM44")

        {

          while (iff->get_chunk(chkid) && chkid!="BM44" && chkid!="PM44")

            iff->close_chunk();

          if (chkid=="BM44" || chkid=="PM44")

            {

              GP<IW44Image> junk=IW44Image::create_decode(IW44Image::COLOR);

              junk->decode_chunk(iff->get_bytestream());

              fprintf(stdout,"width=%d height=%d\n", 

                      junk->get_width(), junk->get_height());

            }

        }

    }

  if (info)

    {

      fprintf(stdout,"width=%d height=%d", info->width, info->height);

      if (info->orientation)

        fprintf(stdout, " rotation=%d", info->orientation);

      fprintf(stdout,"\n");

    }

}

void

command_size(ParsingByteStream &)

{

  GPList<DjVmDir::File> &lst = g().selected;

  { // extra nesting for windows

    for (GPosition p=lst; p; ++p)

    {

      if (lst[p]->is_page())

        {

          GUTF8String fileid = g().doc->page_to_id(lst[p]->get_page_num());

          const GP<DjVuFile> f = g().doc->get_djvu_file(fileid);

          print_size(f);

        }

    }

  }

}

static void

select_all(void)

{

  g().file = 0;

  g().fileid = "";

  g().selected = g().doc->get_djvm_dir()->get_files_list();

}

static void

select_clear(void)

{

  g().file = 0;

  g().fileid = "<all>";

  g().selected.empty();

}

static void

select_add(GP<DjVmDir::File> frec)

{

  GPosition selp = g().selected;

  GPList<DjVmDir::File> all = g().doc->get_djvm_dir()->get_files_list();

  GPosition allp = all;

  while (allp)

    {

      if (all[allp] == frec)

        break;

      if ( selp && all[allp] == g().selected[selp])

        ++ selp;

      ++ allp;

    }

  if (allp && (!selp || all[allp] != g().selected[selp]))

    {

      g().selected.insert_before(selp, frec);

      if (! g().file)

        {

          g().fileid = frec->get_load_name();

          g().file = g().doc->get_djvu_file(g().fileid);

        }

      else

        {

          g().fileid = "<multiple>";

          g().file = 0;

        }

    }

}

void

command_select(ParsingByteStream &pbs)

{

  GUTF8String pagid = pbs.get_token();

  // Case of NULL

  if (pagid == "") 

    {

      select_all();

      vprint("select: selecting entire document");

      return;

    } 

  // Case of a single page number

  if (pagid.is_int())

    {

      int pageno = atoi(pagid);

      GP<DjVmDir::File> frec = g().doc->get_djvm_dir()->page_to_file(pageno-1);

      if (!frec)

        verror("page \"%d\" not found", pageno);

      select_clear();

      select_add(frec);

      vprint("select: selecting \"%s\"", (const char*)ToNative(g().fileid));

      return;

    }

  // Case of a single file id

  GP<DjVmDir::File> frec = g().doc->get_djvm_dir()->id_to_file(pagid);

  if (!frec)

    frec = g().doc->get_djvm_dir()->name_to_file(pagid);

  if (!frec)

    frec = g().doc->get_djvm_dir()->title_to_file(pagid);

  if (!frec)

    verror("page \"%s\" not found", (const char*)ToNative(pagid));

  select_clear();

  select_add(frec);

  vprint("select: selecting \"%s\"", (const char*)ToNative(g().fileid));

}  

void

command_select_shared_ant(ParsingByteStream &)

{

  GP<DjVmDir::File> frec = g().doc->get_djvm_dir()->get_shared_anno_file();

  if (! frec)

    verror("select-shared-ant: no shared annotation file"); 

  select_clear();

  select_add(frec);

  vprint("select-shared-ant: selecting shared annotation");

}

void

command_create_shared_ant(ParsingByteStream &)

{

  GP<DjVmDir::File> frec = g().doc->get_djvm_dir()->get_shared_anno_file();

  if (! frec)

    {

      vprint("create-shared-ant: creating shared annotation file");

      g().doc->create_shared_anno_file();

      frec = g().doc->get_djvm_dir()->get_shared_anno_file();

      if (!frec) G_THROW("internal error");

    }

  select_clear();

  select_add(frec);

  vprint("select-shared-ant: selecting shared annotation");

}

void

command_showsel(ParsingByteStream &)

{

  int pagenum = 0;

  GPList<DjVmDir::File> &lst = g().selected;

  { // extra nesting for windows

    for (GPosition p=lst; p; ++p) 

    {

      GP<DjVmDir::File> f = lst[p];

      if (f->is_page())

        fprintf(stdout,"%4d P ", ++pagenum);

      else if (f->is_include())

        fprintf(stdout,"     I ");

      else if (f->is_thumbnails())

        fprintf(stdout,"     T ");

      else if (f->is_shared_anno())

        fprintf(stdout,"     A ");

      else

        fprintf(stdout,"     ? ");

      GUTF8String id = f->get_load_name();

      fprintf(stdout,"%8d  %s", f->size, (const char*)ToNative(id));

      GUTF8String name = f->get_save_name();

      if (name != id)

        fprintf(stdout," F=%s", (const char*)ToNative(name));

      GUTF8String title = f->get_title();

      if (title != id && f->is_page())

        fprintf(stdout," T=%s", (const char*)ToNative(title));

      fprintf(stdout,"\n");

    }

  }

  if (g().doc->get_thumbnails_num() == g().doc->get_pages_num())

    fprintf(stdout,"     T %8s  %s\n", "", "<thumbnails>");

}

void

command_set_page_title(ParsingByteStream &pbs)

{

  if (! g().file)

    verror("must select a single page first");

  GUTF8String fname = pbs.get_token();

  if (! fname)

    verror("must provide a name");

  GPList<DjVmDir::File> &lst = g().selected;

  GPosition pos = lst;

  if (! lst[pos]->is_page())

    verror("component file is not a page");

  g().doc->set_file_title(g().fileid, fname);

  vprint("set-page-title: modified \"%s\"", (const char*)ToNative(g().fileid));

  modified = true;

}

GP<DjVuInfo> decode_info(GP<DjVuFile> file)

{

  GP<DjVuInfo> info = file->info;

  if (! info)

    {

      const GP<ByteStream> pbs(file->get_djvu_bytestream(false, false));

      const GP<IFFByteStream> iff(IFFByteStream::create(pbs));

      GUTF8String chkid;

      if (! iff->get_chunk(chkid))

        return 0;

      if (chkid == "FORM:DJVU")

        {

          while (iff->get_chunk(chkid) && chkid!="INFO")

            iff->close_chunk();

          if (chkid == "INFO")

            {

              info = DjVuInfo::create();

              info->decode(*iff->get_bytestream());

            }

        }

      file->info = info;

    }

  return info;

}

bool

set_rotation(GP<DjVuFile> file, int rot, bool relative)

{

  // decode info

  GP<DjVuInfo> info = decode_info(file);

  if (! info)

    return false;

  if (relative)

    rot += info->orientation;

  info->orientation = rot & 3;

  file->set_modified(true);

  modified = true;

  return true;

}

void

command_set_rotation(ParsingByteStream &pbs)

{

  GUTF8String rot = pbs.get_token();

  if (! rot.is_int())

    verror("usage: set-rotation [+-]<rot>");

  int rotation = rot.toInt();

  bool relative = (rot[0]=='+' || rot[0]=='-');

  if (! relative)

    if (rotation < 0 || rotation > 3)

      verror("absolute rotation must be in range 0..3");

  int rcount = 0;

  if (g().file)

    {

      GUTF8String id = g().fileid;

      if (set_rotation(g().file, rotation, relative))

        rcount += 1;

    }

  else

    {

      GPList<DjVmDir::File> &lst = g().selected;

      for (GPosition p=lst; p; ++p)

        {

          GUTF8String id = lst[p]->get_load_name();

          const GP<DjVuFile> f(g().doc->get_djvu_file(id));

          if (set_rotation(f, rotation, relative))

            rcount += 1;

        }

    }

  vprint("rotated %d pages", rcount);

}

bool

set_dpi(GP<DjVuFile> file, int dpi)

{

  // decode info

  GP<DjVuInfo> info = decode_info(file);

  if (! info)

    return false;

  info->dpi = dpi;

  file->set_modified(true);

  modified = true;

  return true;

}

void

command_set_dpi(ParsingByteStream &pbs)

{

  GUTF8String sdpi = pbs.get_token();

  if (! sdpi.is_int())

    verror("usage: set-dpi <dpi>");

  int dpi = sdpi.toInt();

  if (dpi < 25 || dpi > 6000)

    verror("resolution should be in range 25..6000dpi");

  int rcount = 0;

  if (g().file)

    {

      GUTF8String id = g().fileid;

      if (set_dpi(g().file, dpi))

        rcount += 1;

    }

  else

    {

      GPList<DjVmDir::File> &lst = g().selected;

      for (GPosition p=lst; p; ++p)

        {

          GUTF8String id = lst[p]->get_load_name();

          const GP<DjVuFile> f(g().doc->get_djvu_file(id));

          if (set_dpi(f, dpi))

            rcount += 1;