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/DjVuImage.cpp

    r15 r17  
    5252//C- +------------------------------------------------------------------
    5353//
    54 // $Id: DjVuImage.cpp,v 1.10 2005/04/27 16:34:13 leonb Exp $
    55 // $Name: release_3_5_16 $
     54// $Id: DjVuImage.cpp,v 1.13 2006/01/19 15:20:41 leonb Exp $
     55// $Name: $
    5656
    5757#ifdef HAVE_CONFIG_H
     
    10751075    GRect rect=inrect;
    10761076    GRect all=inall;
    1077 ///* rotate code
    1078     if( dimg.get_rotate()%4 )
     1077    if( dimg.get_rotate() )
    10791078    {
    10801079        GRectMapper mapper;
    1081         mapper.rotate((4-dimg.get_rotate())%4);
     1080        mapper.rotate(-dimg.get_rotate());
    10821081        mapper.map(rect);
    10831082        mapper.map(all);
    10841083    }
    1085 ///* rotate code ends
    10861084
    10871085  // Sanity
     
    11031101        GP<GBitmap> bm=(dimg.*get)(zrect, red, align);
    11041102        if(bm)
    1105             return bm->rotate((4-dimg.get_rotate())%4);
     1103            return bm->rotate(dimg.get_rotate());
    11061104        else
    11071105                return NULL;
     
    11131111      break;
    11141112  // Setup bitmap scaler
    1115   if (! (w && h)) return 0;
     1113  if (w<=0 || h<=0) return 0;
    11161114  GP<GBitmapScaler> gbs=GBitmapScaler::create();
    11171115  GBitmapScaler &bs=*gbs;
     
    11291127  bs.scale(srect, *sbm, zrect, *bm);
    11301128  if( bm )
    1131       return bm->rotate((4-dimg.get_rotate())%4);
     1129      return bm->rotate(dimg.get_rotate());
    11321130  else
    11331131      return NULL;
     
    11381136          const GRect &inrect, const GRect &inall, double gamma )
    11391137{
    1140 
    11411138    GRect rect=inrect;
    11421139    GRect all=inall;
    1143 ///* rotate code
    11441140    if( dimg.get_rotate()%4 )
    11451141    {
    11461142        GRectMapper mapper;
    1147         mapper.rotate((4-dimg.get_rotate())%4);
     1143      mapper.rotate(-dimg.get_rotate());
    11481144        mapper.map(rect);
    11491145        mapper.map(all);
    11501146    }
    1151 ///* rotate code ends
    11521147
    11531148  // Sanity
     
    11701165        GP<GPixmap> pm = (dimg.*get)(zrect, red, gamma);
    11711166        if( pm )
    1172             return pm->rotate((4-dimg.get_rotate())%4);
     1167            return pm->rotate(dimg.get_rotate());
    11731168        else
    11741169            return NULL;
     
    11821177      break;
    11831178  // Setup pixmap scaler
    1184   if (w<0 || h<0) return 0;
     1179  if (w<=0 || h<=0) return 0;
    11851180  GP<GPixmapScaler> gps=GPixmapScaler::create();
    11861181  GPixmapScaler &ps=*gps;
     
    11971192  ps.scale(srect, *spm, zrect, *pm);
    11981193  if(pm)
    1199       return pm->rotate((4-dimg.get_rotate())%4);
     1194      return pm->rotate(dimg.get_rotate());
    12001195  else
    12011196      return NULL;
     
    12291224DjVuImage::get_rotate() const
    12301225{
    1231   return (rotate_count<0)?0:rotate_count;
     1226  return (rotate_count<0) ? 0 : rotate_count;
    12321227}
    12331228
     
    12351230DjVuImage::init_rotate(const DjVuInfo &info)
    12361231{
    1237   rotate_count=((360-GRect::findangle(info.orientation))/90)%4;
     1232  rotate_count = info.orientation;
    12381233}
    12391234
    12401235void DjVuImage::set_rotate(int count)
    12411236{
    1242   rotate_count=((count%4)+4)%4;
     1237  rotate_count = count % 4;
    12431238}
    12441239
     
    12461241DjVuImage::get_decoded_anno()
    12471242{
     1243    GP<DjVuInfo> djvuinfo = get_info();
    12481244    GP<DjVuAnno> djvuanno = DjVuAnno::create();
    12491245    GP<ByteStream> bs=get_anno();
    12501246    if( bs )
    12511247    {
     1248      int rotate_count=get_rotate();
     1249      /// Brain damaged adjustment of annotation
     1250      /// coordinates that reflect the orientation
     1251      /// flag in the info chunk....
     1252      if (djvuinfo)
     1253        rotate_count = rotate_count - djvuinfo->orientation;
     1254      ///decode
    12521255        djvuanno->decode(bs);
    1253        
    1254         const int rotate_count=get_rotate();
    1255         if( rotate_count % 4 )
     1256            ///map hyperlinks correctly for rotation           
     1257      if( rotate_count & 3 )
    12561258        {   
    1257             ///map hyperlinks correctly for rotation           
    12581259            GRect input, output;
    1259             input = GRect(0,0,get_width(), get_height());
    1260             output = GRect(0,0,  get_real_width(), get_real_height());
    1261 
     1260          input = GRect(0,0,get_width(),get_height());
     1261          if (rotate_count & 1)
     1262            output = GRect(0,0,get_height(),get_width());
     1263          else
     1264            output = GRect(0,0,get_width(),get_height());
    12621265            GRectMapper mapper;
    12631266            mapper.clear();
    12641267            mapper.set_input(input);
    12651268            mapper.set_output(output);               
    1266             mapper.rotate((4-rotate_count)%4);
    1267 
     1269          mapper.rotate(-rotate_count);
    12681270            GPList<GMapArea> &list=djvuanno->ant->map_areas;
    12691271            for(GPosition pos=list;pos;++pos)
    1270             {
    12711272                list[pos]->unmap(mapper);
    12721273            }
    1273         }
    12741274        return djvuanno;
    12751275    }
     
    12841284    GRect input, output;
    12851285    const int rotate_count=get_rotate();
    1286     if(rotate_count%4)
     1286    if(rotate_count>0)
    12871287    { 
    12881288        input = GRect(0,0,get_width(), get_height());
     
    12931293        mapper.set_input(input);
    12941294        mapper.set_output(output);               
    1295         mapper.rotate((4-rotate_count)%4);
     1295        mapper.rotate(-rotate_count);
    12961296        mapper.map(rect);
    12971297    }
     
    13031303    GRect input, output;
    13041304    const int rotate_count=get_rotate();
    1305     if(rotate_count%4)
     1305    if(rotate_count>0)
    13061306    { 
    13071307        input = GRect(0,0,get_width(), get_height());
     
    13121312        mapper.set_input(input);
    13131313        mapper.set_output(output);               
    1314         mapper.rotate((4-rotate_count)%4);
     1314        mapper.rotate(-rotate_count);
    13151315        mapper.unmap(rect);
    13161316    }
     
    13221322    GRect input, output;
    13231323    const int rotate_count=get_rotate();
    1324     if(rotate_count%4)
     1324    if(rotate_count>0)
    13251325    { 
    13261326        input = GRect(0,0,get_width(), get_height());
     
    13311331        mapper.set_input(input);
    13321332        mapper.set_output(output);               
    1333         mapper.rotate((4-rotate_count)%4);
     1333        mapper.rotate(-rotate_count);
    13341334        mapper.map(x, y);
    13351335    }
     
    13411341    GRect input, output;
    13421342    const int rotate_count=get_rotate();
    1343     if(rotate_count%4)
     1343    if(rotate_count>0)
    13441344    { 
    13451345        input = GRect(0,0,get_width(), get_height());
     
    13501350        mapper.set_input(input);
    13511351        mapper.set_output(output);               
    1352         mapper.rotate((4-rotate_count)%4);
     1352        mapper.rotate(-rotate_count);
    13531353        mapper.unmap(x, y);
    13541354    }
Note: See TracChangeset for help on using the changeset viewer.