Ignore:
Timestamp:
May 3, 2006, 10:14:37 AM (15 years ago)
Author:
Eugene Romanenko
Message:

update makefiles, remove absolute paths, update djvulibre to version 3.5.17

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libdjvu/ddjvuapi.cpp

    r15 r17  
    5353//C- */
    5454
    55 /* $Id: ddjvuapi.cpp,v 1.41 2005/09/12 21:31:06 leonb Exp $ */
     55/* $Id: ddjvuapi.cpp,v 1.55 2006/02/21 16:10:29 docbill Exp $ */
    5656
    5757#ifdef HAVE_CONFIG_H
     
    111111#include "DjVuAnno.h"
    112112#include "DjVuToPS.h"
     113#include "DjVmDir.h"
     114#include "DjVmDoc.h"
    113115
    114116
     
    155157  GP<DjVuFileCache> cache;
    156158  GPList<ddjvu_message_p> mlist;
     159  GP<ddjvu_message_p> mpeeked;
    157160  int uniqueid;
    158161  ddjvu_message_callback_t callbackfun;
     
    206209  bool pageinfoflag;            // was the first m_pageinfo sent?
    207210  bool pagedoneflag;            // was the final m_pageinfo sent?
    208   bool redisplayflag;           // did we receive a redisplay notification?
    209211  // virtual job functions:
    210212  virtual ddjvu_status_t status();
     
    337339    {
    338340      setlocale(LC_ALL,"");
    339       DjVuMessage::use_language();
    340341      if (programname)
    341342        djvu_programname(programname);
     343      DjVuMessage::use_language();
     344      DjVuMessageLite::create();
    342345      ctx = new ddjvu_context_s;
    343346      ref(ctx);
     
    347350      ctx->cache = DjVuFileCache::create();
    348351    }
    349   G_CATCH(ex)
     352  G_CATCH_ALL
    350353    {
    351354      if (ctx)
     
    365368        unref(ctx);
    366369    }
    367   G_CATCH(ex)
     370  G_CATCH_ALL
    368371    {
    369372    }
     
    383386  ddjvu_context_t *ctx = head.context;
    384387  if (! msg) msg = new ddjvu_message_p;
    385   msg->p.m_any = head;
    386   {
    387     GMonitorLock lock(&ctx->monitor);
    388     ctx->mlist.append(msg);
    389     ctx->monitor.broadcast();
    390   }
     388  msg->p.m_any = head;
     389  GMonitorLock lock(&ctx->monitor);
    391390  if (ctx->callbackfun)
    392391    (*ctx->callbackfun)(ctx, ctx->callbackarg);
     392  ctx->mlist.append(msg);
     393  ctx->monitor.broadcast();
    393394}
    394395
     
    401402      msg_push(head, msg);
    402403    }
    403   G_CATCH(ex)
     404  G_CATCH_ALL
    404405    {
    405406    }
     
    424425      p->p.m_error.message = (const char*)(p->tmp1);
    425426    }
    426   G_CATCH(ex)
     427  G_CATCH_ALL
    427428    {
    428429    }
     
    451452      p->p.m_error.lineno = ex.get_line();
    452453    }
    453   G_CATCH(exc)
     454  G_CATCH_ALL
    454455    {
    455456    }
     
    472473
    473474#ifdef __GNUG__
    474 # define ERROR(x, m) \
     475# define ERROR1(x, m) \
    475476    msg_push_nothrow(xhead(DDJVU_ERROR,x),\
    476477                     msg_prep_error(m,__func__,__FILE__,__LINE__))
    477478#else
    478 # define ERROR(x, m) \
     479# define ERROR1(x, m) \
    479480    msg_push_nothrow(xhead(DDJVU_ERROR,x),\
    480481                     msg_prep_error(m,0,__FILE__,__LINE__))
     
    497498  G_CATCH(ex)
    498499    {
    499       ERROR(ctx, ex);
     500      ERROR1(ctx, ex);
    500501    }
    501502  G_ENDCATCH;
     
    513514  G_CATCH(ex)
    514515    {
    515       ERROR(ctx, ex);
     516      ERROR1(ctx, ex);
    516517    }
    517518  G_ENDCATCH;
     
    526527      GMonitorLock lock(&ctx->monitor);
    527528      if (ctx->cache)
    528         return ctx->cache->clear();
     529      {
     530        ctx->cache->clear();
     531        return;
     532      }
    529533    }
    530534  G_CATCH(ex)
    531535    {
    532       ERROR(ctx, ex);
     536      ERROR1(ctx, ex);
    533537    }
    534538  G_ENDCATCH;
     
    549553      while (p) {
    550554        GPosition s = p; ++p;
    551         if (ctx->mlist[s]->p.m_any.job == this)
     555        if (ctx->mlist[s]->p.m_any.job == this ||
     556            ctx->mlist[s]->p.m_any.document == this ||
     557            ctx->mlist[s]->p.m_any.page == this )
    552558          ctx->mlist.del(s);
    553559      }
    554560    }
    555   G_CATCH()
     561  G_CATCH_ALL
    556562    {
    557563    }
     
    592598      unref(job);
    593599    }
    594   G_CATCH(ex)
     600  G_CATCH_ALL
    595601    {
    596602    }
     
    609615  G_CATCH(ex)
    610616    {
    611       ERROR(job, ex);
     617      ERROR1(job, ex);
    612618    }
    613619  G_ENDCATCH;
     
    625631  G_CATCH(ex)
    626632    {
    627       ERROR(job, ex);
     633      ERROR1(job, ex);
    628634    }
    629635  G_ENDCATCH;
     
    656662    {
    657663      GMonitorLock lock(&ctx->monitor);
     664      if (ctx->mpeeked)
     665        return &ctx->mpeeked->p;       
    658666      GPosition p = ctx->mlist;
    659       if (p)
    660         return &ctx->mlist[p]->p;
    661     }
    662   G_CATCH(ex)
     667      if (! p)
     668        return 0;
     669      ctx->mpeeked = ctx->mlist[p];
     670      ctx->mlist.del(p);
     671      return &ctx->mpeeked->p;       
     672    }
     673  G_CATCH_ALL
    663674    {
    664675    }
     
    673684    {
    674685      GMonitorLock lock(&ctx->monitor);
     686      if (ctx->mpeeked)
     687        return &ctx->mpeeked->p;       
    675688      while (! ctx->mlist.size())
    676       {
    677689        ctx->monitor.wait();
    678       }
    679690      GPosition p = ctx->mlist;
    680       if (p)
    681         return &ctx->mlist[p]->p;
    682     }
    683   G_CATCH(ex)
     691      if (! p)
     692        return 0;
     693      ctx->mpeeked = ctx->mlist[p];
     694      ctx->mlist.del(p);
     695      return &ctx->mpeeked->p;       
     696    }
     697  G_CATCH_ALL
    684698    {
    685699    }
     
    694708    {
    695709      GMonitorLock lock(&ctx->monitor);
    696       GPosition p = ctx->mlist;
    697       if (p)
    698         ctx->mlist.del(p);
    699     }
    700   G_CATCH(ex)
     710      ctx->mpeeked = 0;
     711    }
     712  G_CATCH_ALL
    701713    {
    702714    }
     
    876888        unref(d);
    877889      d = 0;
    878       ERROR(ctx, ex);
     890      ERROR1(ctx, ex);
    879891    }
    880892  G_ENDCATCH;
     
    912924        unref(d);
    913925      d = 0;
    914       ERROR(ctx, ex);
     926      ERROR1(ctx, ex);
    915927    }
    916928  G_ENDCATCH;
     
    950962  G_CATCH(ex)
    951963    {
    952       ERROR(doc,ex);
     964      ERROR1(doc,ex);
    953965    }
    954966  G_ENDCATCH;
     
    971983        G_THROW("Unknown stream ID");
    972984      if (stop)
    973         pool->stop();
    974       else
    975         pool->set_eof();
     985        pool->stop(true);
     986      pool->set_eof();
    976987    }
    977988  G_CATCH(ex)
    978989    {
    979       ERROR(doc, ex);
     990      ERROR1(doc, ex);
    980991    }
    981992  G_ENDCATCH;
     
    10141025  G_CATCH(ex)
    10151026    {
    1016       ERROR(document,ex);
     1027      ERROR1(document,ex);
    10171028    }
    10181029  G_ENDCATCH;
     
    10311042  G_CATCH(ex)
    10321043    {
    1033       ERROR(document,ex);
     1044      ERROR1(document,ex);
    10341045    }
    10351046  G_ENDCATCH;
    10361047  return 1;
    10371048}
     1049
     1050
     1051int
     1052ddjvu_document_get_filenum(ddjvu_document_t *document)
     1053{
     1054  G_TRY
     1055    {
     1056      DjVuDocument *doc = document->doc;
     1057      if (! (doc && doc->is_init_ok()))
     1058        return 0;
     1059      GP<DjVmDir> dir = doc->get_djvm_dir();
     1060      if (dir)
     1061        return dir->get_files_num();
     1062    }
     1063  G_CATCH(ex)
     1064    {
     1065      ERROR1(document,ex);
     1066    }
     1067  G_ENDCATCH;
     1068  return 1;
     1069}
     1070
     1071ddjvu_status_t
     1072ddjvu_document_get_fileinfo(ddjvu_document_t *document, int fileno,
     1073                            ddjvu_fileinfo_t *info)
     1074{
     1075  G_TRY
     1076    {
     1077      memset(info, 0, sizeof(ddjvu_fileinfo_t));
     1078      DjVuDocument *doc = document->doc;
     1079      if (! doc)
     1080        return DDJVU_JOB_NOTSTARTED;
     1081      if (! doc->is_init_ok())
     1082        return document->status();
     1083      GP<DjVmDir> dir = doc->get_djvm_dir();
     1084      GP<DjVmDir::File> file = dir->pos_to_file(fileno, &info->pageno);
     1085      if (! file)
     1086        G_THROW("Illegal file number");
     1087      if (file->is_page())
     1088        info->type = 'P';
     1089      else if (file->is_thumbnails())
     1090        info->type = 'T';
     1091      else if (file->is_shared_anno())
     1092        info->type = 'S';
     1093      else
     1094        info->type = 'I';
     1095      info->size = file->size;
     1096      info->id = file->get_load_name();
     1097      info->name = file->get_save_name();
     1098      info->title = file->get_title();
     1099      return DDJVU_JOB_OK;
     1100    }
     1101  G_CATCH(ex)
     1102    {
     1103      ERROR1(document,ex);
     1104    }
     1105  G_ENDCATCH;
     1106  return DDJVU_JOB_FAILED;
     1107}
     1108
     1109int
     1110ddjvu_document_search_pageno(ddjvu_document_t *document, const char *name)
     1111{
     1112  G_TRY
     1113    {
     1114      DjVuDocument *doc = document->doc;
     1115      if (! (doc && doc->is_init_ok()))
     1116        return -1;
     1117      GP<DjVmDir> dir = doc->get_djvm_dir();
     1118      if (! dir)
     1119        return 0;
     1120      GP<DjVmDir::File> file;
     1121      if (! (file = dir->id_to_file(GUTF8String(name))))
     1122        if (! (file = dir->name_to_file(GUTF8String(name))))
     1123          if (! (file = dir->title_to_file(GUTF8String(name))))
     1124            {
     1125              char *edata=0;
     1126              long int p = strtol(name, &edata, 10);
     1127              if (edata!=name && !*edata && p>=0)
     1128                file = dir->page_to_file(p);
     1129            }
     1130      if (file)
     1131        {
     1132          int pageno = -1;
     1133          int fileno = dir->get_file_pos(file);
     1134          if (dir->pos_to_file(fileno, &pageno))
     1135            return pageno;
     1136        }
     1137    }
     1138  G_CATCH(ex)
     1139    {
     1140      ERROR1(document,ex);
     1141    }
     1142  G_ENDCATCH;
     1143  return -1;
     1144}
     1145
     1146
     1147int
     1148ddjvu_document_check_pagedata(ddjvu_document_t *document, int pageno)
     1149{
     1150  G_TRY
     1151    {
     1152      document->pageinfoflag = true;
     1153      DjVuDocument *doc = document->doc;
     1154      if (doc && doc->is_init_ok())
     1155        {
     1156          GP<DjVuFile> file;
     1157          if (doc->get_doc_type()==DjVuDocument::INDIRECT)
     1158            file = doc->get_djvu_file(pageno, true);
     1159          else
     1160            file = doc->get_djvu_file(pageno, false);           
     1161          if (file && file->is_all_data_present())
     1162            return 1;
     1163        }
     1164    }
     1165  G_CATCH(ex)
     1166    {
     1167      ERROR1(document,ex);
     1168    }
     1169  G_ENDCATCH;
     1170  return 0;
     1171}
     1172
    10381173
    10391174ddjvu_status_t
     
    10641199                      GP<DjVuInfo> info=DjVuInfo::create();
    10651200                      info->decode(*gbs);
    1066                       int rot = ((360-GRect::findangle(info->orientation))/90)%4;
     1201                      int rot = info->orientation;
    10671202                      if (pageinfo)
    10681203                        {
    1069                           pageinfo->width = (rot&1) ? info->height : info->width;
    1070                           pageinfo->height = (rot&1) ? info->width : info->height;
     1204                          pageinfo->width =
     1205                            (rot&1) ? info->height : info->width;
     1206                          pageinfo->height =
     1207                            (rot&1) ? info->width : info->height;
    10711208                          pageinfo->dpi = info->dpi;
    10721209                        }
     
    10761213              else if (chkid == "FORM:BM44" || chkid == "FORM:PM44")
    10771214                {
    1078                   while (iff->get_chunk(chkid) && chkid!="BM44" && chkid!="PM44")
     1215                  while (iff->get_chunk(chkid) &&
     1216                         chkid!="BM44" && chkid!="PM44")
    10791217                    iff->close_chunk();
    10801218                  if (chkid=="BM44" || chkid=="PM44")
     
    10831221                      if (gbs->read8() == 0)
    10841222                        {
     1223                          gbs->read8();
    10851224                          gbs->read8();
    10861225                          gbs->read8();
     
    11041243  G_CATCH(ex)
    11051244    {
    1106       ERROR(document, ex);
     1245      ERROR1(document, ex);
    11071246    }
    11081247  G_ENDCATCH;
     
    11311270      p->pageinfoflag = false;
    11321271      p->pagedoneflag = false;
    1133       p->redisplayflag = false;
    1134       if (job)
    1135         p->job = job;
    1136       else
    1137         p->job = job = p;
     1272      p->job = job = ((job) ? job : p);
    11381273      if (pageid)
    11391274        p->img = doc->get_page(GNativeString(pageid), false, job);
     
    11461281        unref(p);
    11471282      p = 0;
    1148       ERROR(document, ex);
     1283      ERROR1(document, ex);
    11491284    }
    11501285  G_ENDCATCH;
     
    12441379{
    12451380  GMonitorLock lock(&monitor);
    1246   if (! img || pageinfoflag) return;
    1247   msg_push(xhead(DDJVU_PAGEINFO, this));
    1248   pageinfoflag = true;
    1249   msg_push(xhead(DDJVU_RELAYOUT, this));
    1250   if ( redisplayflag )
    1251     notify_redisplay(img);
     1381  if (img && !pageinfoflag)
     1382    {
     1383      msg_push(xhead(DDJVU_PAGEINFO, this));
     1384      msg_push(xhead(DDJVU_RELAYOUT, this));
     1385      pageinfoflag = true;
     1386    }
    12521387}
    12531388
     
    12561391{
    12571392  GMonitorLock lock(&monitor);
    1258   redisplayflag = true;
     1393  if (img && !pageinfoflag)
     1394    {
     1395      msg_push(xhead(DDJVU_PAGEINFO, this));
     1396      msg_push(xhead(DDJVU_RELAYOUT, this));
     1397      pageinfoflag = true;
     1398    }
    12591399  if (img && pageinfoflag)
    12601400    msg_push(xhead(DDJVU_REDISPLAY, this));
     
    12861426  G_CATCH(ex)
    12871427    {
    1288       ERROR(page, ex);
     1428      ERROR1(page, ex);
    12891429    }
    12901430  G_ENDCATCH;
     
    13021442  G_CATCH(ex)
    13031443    {
    1304       ERROR(page, ex);
     1444      ERROR1(page, ex);
    13051445    }
    13061446  G_ENDCATCH;
     
    13181458  G_CATCH(ex)
    13191459    {
    1320       ERROR(page, ex);
     1460      ERROR1(page, ex);
    13211461    }
    13221462  G_ENDCATCH;
     
    13341474  G_CATCH(ex)
    13351475    {
    1336       ERROR(page, ex);
     1476      ERROR1(page, ex);
    13371477    }
    13381478  G_ENDCATCH;
     
    13501490  G_CATCH(ex)
    13511491    {
    1352       ERROR(page, ex);
    1353     }
    1354   G_ENDCATCH;
     1492      ERROR1(page, ex);
     1493    }
     1494  G_ENDCATCH;
     1495  return DJVUVERSION;
     1496}
     1497
     1498int
     1499ddjvu_code_get_version(void)
     1500{
    13551501  return DJVUVERSION;
    13561502}
     
    13721518  G_CATCH(ex)
    13731519    {
    1374       ERROR(page, ex);
     1520      ERROR1(page, ex);
    13751521    }
    13761522  G_ENDCATCH;
     
    13911537  G_CATCH(ex)
    13921538    {
    1393       ERROR(page, ex);
     1539      ERROR1(page, ex);
    13941540    }
    13951541  G_ENDCATCH;
     
    14101556  G_CATCH(ex)
    14111557    {
    1412       ERROR(page, ex);
     1558      ERROR1(page, ex);
    14131559    }
    14141560  G_ENDCATCH;
     
    14191565// ----------------------------------------
    14201566// Rotations
    1421 
    1422 ddjvu_page_rotation_t
    1423 ddjvu_page_get_rotation(ddjvu_page_t *page)
    1424 {
    1425   ddjvu_page_rotation_t rot = DDJVU_ROTATE_0;
    1426   G_TRY
    1427     {
    1428       if (page && page->img)
    1429         rot = (ddjvu_page_rotation_t)page->img->get_rotate();
    1430     }
    1431   G_CATCH(ex)
    1432     {
    1433       ERROR(page, ex);
    1434     }
    1435   G_ENDCATCH;
    1436   return rot;
    1437 }
    14381567
    14391568void
     
    14491578        case DDJVU_ROTATE_180:
    14501579        case DDJVU_ROTATE_270:
    1451           if (page && page->img && page->pageinfoflag)
    1452             {
    1453               int old = page->img->get_rotate();
    1454               if (old != (int)rot)
    1455                 {
    1456                   page->img->set_rotate((int)rot);
    1457                   msg_push(xhead(DDJVU_RELAYOUT, page));
    1458                   if (page->redisplayflag)
    1459                     msg_push(xhead(DDJVU_REDISPLAY, page));
    1460                 }
    1461             }
     1580          if (page && page->img && page->img->get_info())
     1581            page->img->set_rotate((int)rot);
    14621582          break;
    14631583        default:
     
    14681588  G_CATCH(ex)
    14691589    {
    1470       ERROR(page, ex);
    1471     }
    1472   G_ENDCATCH;
     1590      ERROR1(page, ex);
     1591    }
     1592  G_ENDCATCH;
     1593}
     1594
     1595ddjvu_page_rotation_t
     1596ddjvu_page_get_rotation(ddjvu_page_t *page)
     1597{
     1598  ddjvu_page_rotation_t rot = DDJVU_ROTATE_0;
     1599  G_TRY
     1600    {
     1601      if (page && page->img)
     1602        rot = (ddjvu_page_rotation_t)(page->img->get_rotate() & 3);
     1603    }
     1604  G_CATCH(ex)
     1605    {
     1606      ERROR1(page, ex);
     1607    }
     1608  G_ENDCATCH;
     1609  return rot;
     1610}
     1611
     1612ddjvu_page_rotation_t
     1613ddjvu_page_get_initial_rotation(ddjvu_page_t *page)
     1614{
     1615  ddjvu_page_rotation_t rot = DDJVU_ROTATE_0;
     1616  G_TRY
     1617    {
     1618      GP<DjVuInfo> info;
     1619      if (page && page->img)
     1620        info = page->img->get_info();
     1621      if (info)
     1622        rot = (ddjvu_page_rotation_t)(info->orientation & 3);
     1623    }
     1624  G_CATCH(ex)
     1625    {
     1626      ERROR1(page, ex);
     1627    }
     1628  G_ENDCATCH;
     1629  return rot;
     1630}
     1631
     1632
     1633// ----------------------------------------
     1634// Rectangles
     1635
     1636static void
     1637rect2grect(const ddjvu_rect_t *r, GRect &g)
     1638{
     1639  g.xmin = r->x;
     1640  g.ymin = r->y;
     1641  g.xmax = r->x + r->w;
     1642  g.ymax = r->y + r->h;
     1643}
     1644
     1645static void
     1646grect2rect(const GRect &g, ddjvu_rect_t *r)
     1647{
     1648  if (g.isempty())
     1649    {
     1650      r->x = r->y = 0;
     1651      r->w = r->h = 0;
     1652    }
     1653  else
     1654    {
     1655      r->x = g.xmin;
     1656      r->y = g.ymin;
     1657      r->w = g.width();
     1658      r->h = g.height();
     1659    }
     1660}
     1661
     1662ddjvu_rectmapper_t *
     1663ddjvu_rectmapper_create(ddjvu_rect_t *input, ddjvu_rect_t *output)
     1664{
     1665  GRect ginput, goutput;
     1666  rect2grect(input, ginput);
     1667  rect2grect(output, goutput);
     1668  GRectMapper *mapper = new GRectMapper;
     1669  if (!ginput.isempty())
     1670    mapper->set_input(ginput);
     1671  if (!goutput.isempty())
     1672    mapper->set_output(goutput);
     1673  return (ddjvu_rectmapper_t*)mapper;
     1674}
     1675
     1676void
     1677ddjvu_rectmapper_modify(ddjvu_rectmapper_t *mapper,
     1678                        int rotation, int mirrorx, int mirrory)
     1679{
     1680  GRectMapper *gmapper = (GRectMapper*)mapper;
     1681  if (! gmapper) return;
     1682  gmapper->rotate(rotation);
     1683  if (mirrorx & 1)
     1684    gmapper->mirrorx();
     1685  if (mirrory & 1)
     1686    gmapper->mirrory();
     1687}
     1688
     1689void
     1690ddjvu_rectmapper_release(ddjvu_rectmapper_t *mapper)
     1691{
     1692  GRectMapper *gmapper = (GRectMapper*)mapper;
     1693  if (! gmapper) return;
     1694  delete gmapper;
     1695}
     1696
     1697void
     1698ddjvu_map_point(ddjvu_rectmapper_t *mapper, int *x, int *y)
     1699{
     1700  GRectMapper *gmapper = (GRectMapper*)mapper;
     1701  if (! gmapper) return;
     1702  gmapper->map(*x,*y);
     1703}
     1704
     1705void
     1706ddjvu_map_rect(ddjvu_rectmapper_t *mapper, ddjvu_rect_t *rect)
     1707{
     1708  GRectMapper *gmapper = (GRectMapper*)mapper;
     1709  if (! gmapper) return;
     1710  GRect grect;
     1711  rect2grect(rect,grect);
     1712  gmapper->map(grect);
     1713  grect2rect(grect,rect);
     1714}
     1715
     1716void
     1717ddjvu_unmap_point(ddjvu_rectmapper_t *mapper, int *x, int *y)
     1718{
     1719  GRectMapper *gmapper = (GRectMapper*)mapper;
     1720  if (! gmapper) return;
     1721  gmapper->unmap(*x,*y);
     1722}
     1723
     1724void
     1725ddjvu_unmap_rect(ddjvu_rectmapper_t *mapper, ddjvu_rect_t *rect)
     1726{
     1727  GRectMapper *gmapper = (GRectMapper*)mapper;
     1728  if (! gmapper) return;
     1729  GRect grect;
     1730  rect2grect(rect,grect);
     1731  gmapper->unmap(grect);
     1732  grect2rect(grect,rect);
    14731733}
    14741734
     
    14821742  uint32_t rgb[3][256];
    14831743  uint32_t palette[6*6*6];
     1744  uint32_t xorval;
    14841745  double gamma;
    14851746  char ditherbits;
     
    15211782        if (sizeof(uint16_t)!=2 || sizeof(uint32_t)!=4)
    15221783          return fmt_error(fmt);
    1523         if (nargs!=3 || !args)
     1784        if (!args || nargs<3 || nargs>4)
    15241785          return fmt_error(fmt);
    1525         for (int j=0; j<3; j++)
     1786        { // extra nesting for windows
     1787          for (int j=0; j<3; j++)
    15261788          {
    15271789            int shift = 0;
     
    15341796              fmt->rgb[j][i] = (mask & ((int)((i*mask+127.0)/255.0)))<<shift;
    15351797          }
     1798        }
     1799        if (nargs >= 4)
     1800          fmt->xorval = args[3];
    15361801        break;
    15371802      }
     
    15401805        if (nargs!=6*6*6 || !args)
    15411806          return fmt_error(fmt);
    1542         for (int k=0; k<6*6*6; k++)
    1543           fmt->palette[k] = args[k];
    1544         int j=0;
    1545         for(int i=0; i<6; i++)
    1546           for(; j < (i+1)*0x33 - 0x19 && j<256; j++)
     1807        { // extra nesting for windows
     1808          for (int k=0; k<6*6*6; k++)
     1809            fmt->palette[k] = args[k];
     1810        }
     1811        { // extra nesting for windows
     1812          int j=0;
     1813          for(int i=0; i<6; i++)
     1814            for(; j < (i+1)*0x33 - 0x19 && j<256; j++)
    15471815            {
    15481816              fmt->rgb[0][j] = i * 6 * 6;
     
    15501818              fmt->rgb[2][j] = i;
    15511819            }
     1820        }
    15521821        break;
    15531822      }
     
    16021871{
    16031872  const uint32_t (*r)[256] = fmt->rgb;
     1873  const uint32_t xorval = fmt->xorval;
    16041874  switch(fmt->style)
    16051875    {
     
    16211891        uint16_t *b = (uint16_t*)buf;
    16221892        while (--w >= 0) {
    1623           b[0]=(r[0][p->r]+r[1][p->g]+r[2][p->b]);
     1893          b[0]=(r[0][p->r]|r[1][p->g]|r[2][p->b])^xorval;
    16241894          b+=1; p+=1;
    16251895        }
     
    16301900        uint32_t *b = (uint32_t*)buf;
    16311901        while (--w >= 0) {
    1632           b[0]=(r[0][p->r]+r[1][p->g]+r[2][p->b]);
     1902          b[0]=(r[0][p->r]|r[1][p->g]|r[2][p->b])^xorval;
    16331903          b+=1; p+=1;
    16341904        }
     
    17001970{
    17011971  const uint32_t (*r)[256] = fmt->rgb;
     1972  const uint32_t xorval = fmt->xorval;
    17021973  switch(fmt->style)
    17031974    {
     
    17161987        while (--w >= 0) {
    17171988          unsigned char x = g[*p];
    1718           b[0]=(r[0][x]+r[1][x]+r[2][x]);
     1989          b[0]=(r[0][x]|r[1][x]|r[2][x])^xorval;
    17191990          b+=1; p+=1;
    17201991        }
     
    17261997        while (--w >= 0) {
    17271998          unsigned char x = g[*p];
    1728           b[0]=(r[0][x]+r[1][x]+r[2][x]);
     1999          b[0]=(r[0][x]|r[1][x]|r[2][x])^xorval;
    17292000          b+=1; p+=1;
    17302001        }
     
    18262097      GP<GPixmap> pm;
    18272098      GP<GBitmap> bm;
    1828       GRect prect;
    1829       GRect rrect;
     2099      GRect prect, rrect;
     2100      rect2grect(pagerect, prect);
     2101      rect2grect(renderrect, rrect);
    18302102      if (pixelformat && pixelformat->ytoptobottom)
    18312103        {
    1832           prect.xmin = pagerect->x;
    1833           prect.xmax = prect.xmin + pagerect->w;
    18342104          prect.ymin = renderrect->y + renderrect->h;
    18352105          prect.ymax = prect.ymin + pagerect->h;
    1836           rrect.xmin = renderrect->x;
    1837           rrect.xmax = rrect.xmin + renderrect->w;
    18382106          rrect.ymin = pagerect->y + pagerect->h;
    1839           rrect.ymax = rrect.ymin + renderrect->h;
    1840         }
    1841       else
    1842         {
    1843           prect.xmin = pagerect->x;
    1844           prect.xmax = prect.xmin + pagerect->w;
    1845           prect.ymin = pagerect->y;
    1846           prect.ymax = prect.ymin + pagerect->h;
    1847           rrect.xmin = renderrect->x;
    1848           rrect.xmax = rrect.xmin + renderrect->w;
    1849           rrect.ymin = renderrect->y;
    18502107          rrect.ymax = rrect.ymin + renderrect->h;
    18512108        }
     
    18772134            case DDJVU_RENDER_FOREGROUND:
    18782135              pm = img->get_fg_pixmap(rrect, prect, pixelformat->gamma);
     2136              if (! pm)
     2137                bm = img->get_bitmap(rrect, prect);
    18792138              break;
    18802139            }
     
    18962155  G_CATCH(ex)
    18972156    {
    1898       ERROR(page, ex);
     2157      ERROR1(page, ex);
    18992158    }
    19002159  G_ENDCATCH;
     
    19232182              pool->get_data( (void*)(char*)thumb->data, 0, size);
    19242183            }
    1925           G_CATCH(ex)
     2184          G_CATCH_ALL
    19262185            {
    19272186              thumb->data.empty();
     
    19752234  G_CATCH(ex)
    19762235    {
    1977       ERROR(document, ex);
     2236      ERROR1(document, ex);
    19782237    }
    19792238  G_ENDCATCH;
     
    20322291  G_CATCH(ex)
    20332292    {
    2034       ERROR(document, ex);
     2293      ERROR1(document, ex);
    20352294    }
    20362295  G_ENDCATCH;
     
    21082367      r = self->run();
    21092368    }
    2110   G_CATCH(ex)
     2369  G_CATCH_ALL
    21112370    {
    21122371      r = DDJVU_JOB_FAILED;
     
    21642423};
    21652424
     2425bool
     2426ddjvu_printjob_s::inherits(const GUTF8String &classname)
     2427{
     2428  return (classname == "ddjvu_printjob_s")
     2429    || ddjvu_runnablejob_s::inherits(classname);
     2430}
     2431
    21662432ddjvu_status_t
    21672433ddjvu_printjob_s::run()
    21682434{
     2435  mydoc->doc->wait_for_complete_init();
    21692436  progress_low = 0;
    21702437  progress_high = 1;
     
    21772444}
    21782445
    2179 bool
    2180 ddjvu_printjob_s::inherits(const GUTF8String &classname)
    2181 {
    2182   return (classname == "ddjvu_printjob_s")
    2183     || ddjvu_runnablejob_s::inherits(classname);
    2184 }
    2185 
    21862446void
    21872447ddjvu_printjob_s::cbrefresh(void *data)
     
    21912451    {
    21922452      msg_push(xhead(DDJVU_INFO,self), msg_prep_info("Print job stopped"));
    2193       G_THROW("STOP");
     2453      G_THROW(DataPool::Stop);
    21942454    }
    21952455}
     
    24682728        unref(job);
    24692729      job = 0;
    2470       ERROR(document, ex);
     2730      ERROR1(document, ex);
    24712731    }
    24722732  G_ENDCATCH;
     
    24752735
    24762736// ----------------------------------------
    2477 // Not yet implemented
     2737// Saving (insufficiently tested)
     2738
     2739struct DJVUNS ddjvu_savejob_s : public ddjvu_runnablejob_s
     2740{
     2741  GP<ByteStream> obs;
     2742  virtual ddjvu_status_t run();
     2743  // virtual port functions:
     2744  virtual bool inherits(const GUTF8String&);
     2745  virtual void notify_file_flags_changed(const DjVuFile*, long, long);
     2746  // data
     2747  GMonitor monitor;
     2748};
     2749
     2750bool
     2751ddjvu_savejob_s::inherits(const GUTF8String &classname)
     2752{
     2753  return (classname == "ddjvu_savejob_s")
     2754    || ddjvu_runnablejob_s::inherits(classname);
     2755}
     2756
     2757void
     2758ddjvu_savejob_s::notify_file_flags_changed(const DjVuFile *file, long mask, long)
     2759{
     2760  if (mask & (DjVuFile::ALL_DATA_PRESENT ||
     2761              DjVuFile::DECODE_FAILED || DjVuFile::DECODE_STOPPED ||
     2762              DjVuFile::STOPPED || DjVuFile::DECODE_STOPPED ))
     2763    {
     2764      GMonitorLock lock(&monitor);
     2765      monitor.signal();
     2766    }
     2767}
     2768
     2769ddjvu_status_t
     2770ddjvu_savejob_s::run()
     2771{
     2772  DjVuDocument *doc = mydoc->doc;
     2773  doc->wait_for_complete_init();
     2774  // Determine which components to save
     2775  int ncomp;
     2776  GArray<GUTF8String> comp_ids;
     2777  GPArray<DjVuFile> comp_files;
     2778  if (doc->get_doc_type()==DjVuDocument::BUNDLED ||
     2779      doc->get_doc_type()==DjVuDocument::INDIRECT)
     2780    {
     2781      GP<DjVmDir> dir = doc->get_djvm_dir();
     2782      ncomp = dir->get_files_num();
     2783      comp_ids.resize(ncomp - 1);
     2784      comp_files.resize(ncomp - 1);
     2785      GPList<DjVmDir::File> flist = dir->get_files_list();
     2786      GPosition pos=flist;
     2787      for (int comp=0; comp<ncomp; ++pos, ++comp)
     2788        comp_ids[comp] = flist[pos]->get_load_name();
     2789    }
     2790  else
     2791    {
     2792      ncomp = doc->get_pages_num();
     2793      comp_ids.resize(ncomp - 1);
     2794      comp_files.resize(ncomp - 1);
     2795      { // extra nesting for windows
     2796        for (int comp=0; comp<ncomp; comp++)
     2797          comp_ids[comp] = GUTF8String(comp);
     2798      }
     2799    }
     2800  // Monitoring download progress
     2801  int lo = 0;
     2802  int hi = 0;
     2803  get_portcaster()->add_route(doc, this);
     2804  while (lo < ncomp && !mystop)
     2805    {
     2806      int in_progress = 0;
     2807      GMonitorLock lock(&monitor);
     2808      while (lo<hi && comp_files[lo]->is_data_present())
     2809        lo += 1;
     2810      { // extra nesting for windows
     2811        for (int comp=lo; comp<hi; comp++)
     2812          if (! comp_files[comp]->is_data_present())
     2813            in_progress += 1;
     2814      }
     2815      while (hi<ncomp && in_progress < 2)
     2816        {
     2817          comp_files[hi] = doc->get_djvu_file(comp_ids[hi]);
     2818          in_progress += 1;
     2819          hi += 1;
     2820        }
     2821      if (in_progress > 0)
     2822        monitor.wait();
     2823    }
     2824  if (mystop)
     2825    G_THROW("STOP");
     2826  // Saving!
     2827  doc->write(obs);
     2828  return DDJVU_JOB_OK;
     2829}
     2830
    24782831
    24792832ddjvu_job_t *
     
    24812834                    int optc, const char * const * optv)
    24822835{
    2483   return 0;
    2484 }
     2836  ddjvu_savejob_s *job = 0;
     2837  G_TRY
     2838    {
     2839      job = new ddjvu_savejob_s;
     2840      ref(job);
     2841      job->myctx = document->myctx;
     2842      job->mydoc = document;
     2843      // parse options
     2844      while (optc>0)
     2845        {
     2846          GNativeString narg(optv[0]);
     2847          GUTF8String uarg = narg;
     2848          complain(uarg, "Unrecognized option.");
     2849          optc -= 1;
     2850          optv += 1;
     2851        }
     2852      // go
     2853      job->obs = ByteStream::create(output, "wb", false);
     2854      job->start();
     2855    }
     2856  G_CATCH(ex)
     2857    {
     2858      if (job)
     2859        unref(job);
     2860      job = 0;
     2861      ERROR1(document, ex);
     2862    }
     2863  G_ENDCATCH;
     2864  return job;
     2865}
     2866
    24852867
    24862868
     
    25042886miniexp_protect(ddjvu_document_t *document, miniexp_t expr)
    25052887{
    2506   for(miniexp_t p=document->protect; miniexp_consp(p); p=miniexp_cdr(p))
    2507     if (miniexp_car(p) == expr)
    2508       return;
     2888  { // extra nesting for windows
     2889    for(miniexp_t p=document->protect; miniexp_consp(p); p=miniexp_cdr(p))
     2890      if (miniexp_car(p) == expr)
     2891        return;
     2892  }
    25092893  if (miniexp_consp(expr) || miniexp_objectp(expr))
    25102894    document->protect = miniexp_cons(expr, document->protect);
     
    25762960  G_CATCH(ex)
    25772961    {
    2578       ERROR(document, ex);
     2962      ERROR1(document, ex);
    25792963    }
    25802964  G_ENDCATCH;
     
    26122996  minivar_t a;
    26132997  bool gather = zone.children.isempty();
    2614   for (GPosition pos=zone.children; pos; ++pos)
    2615     if (zone.children[pos].ztype > detail)
    2616       gather = true;
     2998  { // extra nesting for windows
     2999    for (GPosition pos=zone.children; pos; ++pos)
     3000      if (zone.children[pos].ztype > detail)
     3001        gather = true;
     3002  }
    26173003  if (gather)
    26183004    {
     
    26693055          minivar_t result;
    26703056          DjVuTXT::ZoneType detail = DjVuTXT::CHARACTER;
    2671           for (int i=0; zone_names[i].name; i++)
    2672             if (maxdetail && !strcmp(maxdetail, zone_names[i].name))
    2673               detail = zone_names[i].ztype;
     3057          { // extra nesting for windows
     3058            for (int i=0; zone_names[i].name; i++)
     3059              if (maxdetail && !strcmp(maxdetail, zone_names[i].name))
     3060                detail = zone_names[i].ztype;
     3061          }
    26743062          result = pagetext_sub(txt, txt->page_zone, detail);
    26753063          miniexp_protect(document, result);
     
    26793067  G_CATCH(ex)
    26803068    {
    2681       ERROR(document, ex);
     3069      ERROR1(document, ex);
    26823070    }
    26833071  G_ENDCATCH;
     
    27493137      anno_dat.blen--;
    27503138      char c = anno_dat.buf[0];
    2751       for (int i=0; i<anno_dat.blen; i++)
    2752         anno_dat.buf[i] = anno_dat.buf[i+1];
     3139      { // extra nesting for windows
     3140        for (int i=0; i<anno_dat.blen; i++)
     3141          anno_dat.buf[i] = anno_dat.buf[i+1];
     3142      }
    27533143      return c;
    27543144    }
     
    27973187  if (anno_dat.blen>=(int)sizeof(anno_dat.buf))
    27983188    return EOF;
    2799   for (int i=anno_dat.blen; i>0; i--)
    2800     anno_dat.buf[i] = anno_dat.buf[i-1];
     3189  { // extra nesting for windows
     3190    for (int i=anno_dat.blen; i>0; i--)
     3191      anno_dat.buf[i] = anno_dat.buf[i-1];
     3192  }
    28013193  anno_dat.blen += 1;
    28023194  anno_dat.buf[0] = c;
     
    28143206    raw += GUTF8String(buffer, length);
    28153207  // Prepare
    2816   minivar_t a;
     3208  miniexp_t a;
    28173209  anno_dat.s = (const char*)raw;
    28183210  anno_dat.compat = anno_compat(anno_dat.s);
     
    28203212  anno_dat.state = 0;
    28213213  anno_dat.eof = false;
     3214  int (*saved_getc)(void) = minilisp_getc;
     3215  int (*saved_ungetc)(int) = minilisp_ungetc;
     3216  // Process
    28223217  minilisp_getc = anno_getc;
    28233218  minilisp_ungetc = anno_ungetc;
    2824   // Process
    28253219  while (* anno_dat.s )
    28263220    if ((a = miniexp_read()) != miniexp_dummy)
    28273221      result = miniexp_cons(a, result);
     3222  // Restore
     3223  minilisp_getc = saved_getc;
     3224  minilisp_ungetc = saved_ungetc;
    28283225}
    28293226
     
    28753272  G_CATCH(ex)
    28763273    {
    2877       ERROR(document, ex);
     3274      ERROR1(document, ex);
    28783275    }
    28793276  G_ENDCATCH;
     
    29873384  if (! k) return 0;
    29883385  i = 0;
    2989   for (GPosition p=m; p; ++p)
    2990     k[i++] = m.key(p);
     3386  { // extra nesting for windows
     3387    for (GPosition p=m; p; ++p)
     3388      k[i++] = m.key(p);
     3389  }
    29913390  k[i] = 0;
    29923391  return k;
Note: See TracChangeset for help on using the changeset viewer.