vpdf/mcc/pageview_class.c

   1 /*
   2
   3         This is a simple version of the preview class. No subtasks,
   4         and no context menu. It also keeps it's copy of passed image,
   5         so no need to keep if for yourself.
   6
   7
   8 */
   9
  10 #define AROS_ALMOST_COMPATIBLE
  11
  12 #include <proto/muimaster.h>
  13 #include <libraries/mui.h>
  14
  15 #include <proto/exec.h>
  16 #include <proto/utility.h>
  17 #include <exec/libraries.h>
  18 #include <graphics/gfx.h>
  19 #include <proto/alib.h>
  20 #include <proto/graphics.h>
  21 #include <graphics/rpattr.h>
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <math.h>
  26 #include <limits.h>
  27 #include <constructor.h>
  28 #include <intuition/pointerclass.h>
  29
  30 #define  SYSTEM_PRIVATE
  31 #include <proto/cybergraphics.h>
  32 #include <cybergraphx/cybergraphics.h>
  33 #undef   SYSTEM_PRIVATE
  34
  35 #include <private/vapor/vapor.h>
  36 #include "pageview_class.h"
  37 #include "documentview_class.h"
  38 #include "documentlayout_class.h"
  39 #include "annotation_class.h"
  40
  41 #include "system/chunky.h"
  42 #include "system/memory.h"
  43 #include "system/functions.h"
  44
  45 #include "util.h"
  46 #include "poppler.h"
  47
  48 typedef struct ThbImage_s
  49 {
  50         unsigned char *data;
  51         int width;
  52         int height;
  53         int bpp;                                // can be 1 or 4
  54 } ThbImage;
  55
  56 struct markernode {
  57         struct MinNode n;
  58         float x1, y1, x2, y2;   // pdf document device coordinates
  59         int ux1, uy1, ux2, uy2; // user space coordinates
  60         int valid, id;
  61         unsigned int color;
  62 };
  63
  64 struct annotationnode {
  65         struct MinNode n;
  66         float x1, y1, x2, y2;
  67         int ux1, uy1, ux2, uy2;
  68         Object *obj;
  69 };
  70
  71 struct lasso {
  72         int enabled;
  73         struct markernode marker;
  74         struct pdfSelectionRegion *oldregion;
  75 };
  76
  77 struct Data
  78 {
  79         ThbImage *image;
  80         void *parent;
  81         struct MUI_EventHandlerNode eh;
  82         struct PageViewRegion region;
  83         int mx, my;
  84         int moveregion;
  85         int offsetx, offsety;
  86         int markmx, markmy;
  87         int pointertype;
  88         int mousedown;
  89         int markAspect;
  90         struct Rect32 refreshrect;
  91         int layoutwidth;
  92         int layoutheight;
  93
  94         void *doc;
  95         int page;
  96         int ready;
  97         int prevwidth, prevheight;
  98         int mediawidth, mediaheight;
  99         int invalid;
 100         int flushmethodid;
 101         int information;
 102         int ispreview;
 103         int rotation;
 104
 105         int quiet;
 106
 107         struct lasso lasso;
 108         struct MinList markerlist;
 109         struct MinList annotationlist;
 110
 111         struct SignalSemaphore sema;
 112 };
 113
 114 #define D(x) x
 115
 116 /*
 117  * MUI Standard methods
 118  */
 119
 120 ///     dispose
 121
 122 DEFDISP
 123 {
 124         GETDATA;
 125
 126         ObtainSemaphore(&data->sema);
 127         if (data->image != NULL)
 128                 mfree(data->image->data);
 129         free(data->image);
 130         ReleaseSemaphore(&data->sema);
 131
 132         if (data->lasso.oldregion != NULL)
 133                 pdfDisposeRegionForSelection(data->doc, data->lasso.oldregion);
 134
 135         /* remove all markers and annotations (only links to annotation objects!) */
 136
 137         while(!ISLISTEMPTY(&data->markerlist))
 138         {
 139                 struct markernode *mn = (struct markernode*)GetHead(&data->markerlist);
 140         REMOVE(mn);
 141                 free(mn);
 142         }
 143
 144         while(!ISLISTEMPTY(&data->annotationlist))
 145         {
 146                 struct annotationnode *an = (struct annotationnode*)GetHead(&data->annotationlist);
 147                 REMOVE(an);
 148                 free(an);
 149         }
 150
 151         /* dispose parent class */
 152
 153         return(DOSUPER);
 154 }
 155
 156 ////
 157
 158 ///     askminmax
 159
 160 static int getinformationspace(Object *obj, struct Data *data)
 161 {
 162         int space = 0;
 163         if (data->information & MUIV_PageView_Information_Number)
 164                 space += _font(obj)->tf_YSize + 2;
 165
 166         return space;
 167 }
 168
 169 METHOD ThbAskMinMax(struct IClass *cl,Object *obj,struct MUIP_AskMinMax *msg)
 170 {
 171         GETDATA;
 172
 173         /*
 174          let our superclass first fill in what it thinks about sizes.
 175          this will e.g. add the size of frame and inner spacing.
 176         */
 177
 178         DOSUPER;
 179
 180         /*
 181          now add the values specific to our object. note that we
 182          indeed need to *add* these values, not just set them!
 183         */
 184
 185         msg->MinMaxInfo->MinWidth  += data->layoutwidth;
 186         msg->MinMaxInfo->DefWidth  += data->layoutwidth;
 187         msg->MinMaxInfo->MaxWidth  = MUI_MAXMAX;
 188
 189         msg->MinMaxInfo->MinHeight += data->layoutheight + getinformationspace(obj, data);
 190         msg->MinMaxInfo->DefHeight += data->layoutheight + getinformationspace(obj, data);
 191         msg->MinMaxInfo->MaxHeight = MUI_MAXMAX;
 192
 193         return(0);
 194 }
 195
 196 ////
 197
 198 ///     new
 199
 200 DEFNEW
 201 {
 202         obj = DoSuperNew(cl, obj, MUIA_FillArea, FALSE,
 203                                                         //        MUIA_CustomBackfill, TRUE,
 204                                                         //      MUIA_Background, MUII_SHADOW,
 205                                                                 TAG_MORE, INITTAGS);
 206
 207         if (obj != NULL)
 208         {
 209                 GETDATA;
 210
 211                 memset(data, 0, sizeof(struct Data));
 212
 213                 InitSemaphore(&data->sema);
 214                 NEWLIST(&data->markerlist);
 215                 NEWLIST(&data->annotationlist);
 216
 217                 /* get properties */
 218
 219                 data->refreshrect.MinX = -1;
 220                 data->layoutwidth = 128;
 221                 data->layoutheight = 128;
 222                 data->information = MUIV_PageView_Information_None;
 223
 224                 FORTAG(INITTAGS)
 225                 {
 226                                 case MUIA_PageView_Rotation:
 227                                         data->rotation = tag->ti_Data;
 228                                         break;
 229
 230                                 case MUIA_PageView_PDFDocument:
 231                                         data->doc = (void*)tag->ti_Data;
 232                                         break;
 233                                 case MUIA_PageView_Page:
 234                                         data->page = tag->ti_Data;
 235                                         break;
 236                                 case MUIA_PageView_MediaWidth:
 237                                         data->mediawidth = tag->ti_Data;
 238                                         break;
 239                                 case MUIA_PageView_MediaHeight:
 240                                         data->mediaheight = tag->ti_Data;
 241                                         break;
 242                                 case MUIA_PageView_Information:
 243                                         data->information = tag->ti_Data;
 244                                         break;
 245                                 case MUIA_PageView_IsPreview:
 246                                         data->ispreview= tag->ti_Data;
 247                                         break;
 248                 }
 249                 NEXTTAG
 250
 251         }
 252
 253         return (ULONG)obj;
 254
 255 }
 256
 257 ////
 258
 259 ///     setup
 260
 261 METHOD riSetup(struct IClass *cl, Object *obj, struct MUIP_Setup *msg)
 262 {
 263         GETDATA;
 264
 265         if (!(DOSUPER))
 266                 return(FALSE);
 267
 268         return TRUE;
 269 }
 270
 271 ////
 272
 273 ///     cleanup
 274
 275 METHOD riCleanup(struct IClass *cl,Object *obj,Msg msg)
 276 {
 277         GETDATA;
 278
 279         if (data->flushmethodid != 0)
 280         {
 281                 DoMethod(_app(obj), MUIM_Application_UnpushMethod, NULL, data->flushmethodid, 0);
 282                 data->flushmethodid = 0;
 283         }
 284
 285         DoMethod(obj, MUIM_PageView_Flush);
 286
 287         return(DOSUPER);
 288 }
 289
 290 ////
 291
 292 ///     draw
 293
 294 void kprintf(char *fmt,...);
 295
 296 static void rendermarker(struct Data *data, struct RastPort *rp, struct markernode *mn, int x0, int y0)
 297 {
 298         int x1 = mn->ux1, y1 = mn->uy1;
 299         int x2 = mn->ux2, y2 = mn->uy2;
 300
 301         SetRPAttrs(rp, RPTAG_PenMode, FALSE, RPTAG_FgColor, 0xffff0000, TAG_DONE);
 302         RectFill(rp, x0 + x1 - 2, y0 + y2 - 2, x0 + x2 + 2, y0 + y2 - 1);
 303         RectFill(rp, x0 + x1 - 2, y0 + y1 + 1, x0 + x2 + 2, y0 + y1 + 2);
 304         RectFill(rp, x0 + x1 - 2, y0 + y2, x0 + x1 - 1, y0 + y1);
 305         RectFill(rp, x0 + x2 + 1, y0 + y2, x0 + x2 + 2, y0 + y1);
 306
 307         ProcessPixelArray(rp, x0 + x1 - 1, y0 + y2 - 1, x2 - x1, y1 - y2, POP_DARKEN, 10, NULL);
 308 }
 309
 310 METHOD riDraw(struct IClass *cl,Object *obj,struct MUIP_Draw *msg)
 311 {
 312         unsigned int rc = DOSUPER;
 313         //return rc;
 314         /* If MADF_DRAWOBJECT is not set then we shoulnt draw anything */
 315
 316         if (msg->flags & (MADF_DRAWOBJECT | MADF_DRAWUPDATE))
 317     {
 318                 GETDATA;
 319                 int activepage;
 320
 321                 ObtainSemaphore(&data->sema);
 322
 323                 if (data->parent == NULL)
 324                         data->parent = (void*)xget(obj, MUIA_Parent);
 325
 326                 activepage = xget(data->parent, MUIA_DocumentLayout_Page);
 327
 328                 if (data->image && data->image->data)
 329                 {
 330                         /* write image */
 331
 332                         int     width, height;
 333                         int     x0, y0;
 334                         int     prvwidth, prvheight;
 335
 336                         ThbImage *image = data->image;
 337
 338                         x0 = _mleft(obj);
 339                         y0 = _mtop(obj);
 340                         prvwidth = _mwidth(obj);
 341                         prvheight = _mheight(obj) - getinformationspace(obj, data);
 342
 343                         /* calculate placement */
 344
 345                         if (image->height < prvheight)
 346                         {
 347                                 y0 += (prvheight - image->height) / 2;
 348                                 height = image->height;
 349                         }
 350                         else
 351                                 height = prvheight;
 352
 353                         if (image->width < prvwidth)
 354                         {
 355                                 x0 += (prvwidth - image->width) / 2;
 356                                 width = image->width;
 357                         }
 358                         else
 359                                 width = prvwidth;
 360
 361                         /* store offset for eventhandler */
 362
 363                         data->offsetx = x0 - _mleft(obj);
 364                         data->offsety = y0 - _mtop(obj);
 365
 366                         /* install cliprect and draw */
 367
 368                         if (data->quiet == FALSE)
 369                         {
 370                                 if (0 && data->refreshrect.MinX != -1)
 371                                 {
 372                                         width = data->refreshrect.MaxX - data->refreshrect.MinX;
 373                                         height = data->refreshrect.MaxY - data->refreshrect.MinY;
 374                                         WritePixelArray(image->data, data->refreshrect.MinX, data->refreshrect.MinY, image->width * image->bpp, _rp(obj), x0 + data->refreshrect.MinX, y0 + data->refreshrect.MinY, width, height, image->bpp == 4 ? RECTFMT_ARGB : RECTFMT_GREY8);
 375                                 }
 376                                 else
 377                                         WritePixelArray(image->data, 0, 0, image->width * image->bpp, _rp(obj), x0, y0, width, height, data->image->bpp == 4 ? RECTFMT_ARGB : RECTFMT_GREY8);
 378
 379                                 /* draw remaining area with background */
 380
 381                                 if ((image->width < _mwidth(obj) || image->height < _mheight(obj)))
 382                                 {
 383                                         int lb = x0 - _mleft(obj);
 384                                         int rb = _mwidth(obj) - image->width - lb;
 385                                         int tb = y0 - _mtop(obj);
 386                                         int bb = _mheight(obj) - image->height - tb;
 387                                         #if 1
 388                                         if (lb > 0)
 389                                                 DoMethod(obj, MUIM_DrawBackground, _mleft(obj), _mtop(obj), lb, _mheight(obj), 0, 0, 0);
 390                                         if (rb > 0)
 391                                                 DoMethod(obj, MUIM_DrawBackground, _mright(obj) - rb + 1, _mtop(obj), rb, _mheight(obj), 0, 0, 0);
 392
 393                                         lb = max(0, lb);
 394                                         rb = max(0, rb);
 395
 396                                         if (tb > 0)
 397                                                 DoMethod(obj, MUIM_DrawBackground, _mleft(obj) + lb, _mtop(obj), _mwidth(obj) - lb - rb, tb, 0, 0, 0);
 398                                         if (bb > 0)
 399                                                 DoMethod(obj, MUIM_DrawBackground, _mleft(obj) + lb, _mbottom(obj) - bb + 1, _mwidth(obj) - lb - rb, bb, 0, 0, 0);
 400                                         #endif
 401                                 }
 402
 403                                 /* render page number if requested */
 404
 405                                 if (data->information & MUIV_PageView_Information_Number)
 406                                 {
 407                                         char buff[32];
 408                                         int informationspace = getinformationspace(obj, data);
 409                                         int textwidth, textpos;
 410                                         unsigned int textdim;
 411
 412                                         snprintf(buff, sizeof(buff), "%d", data->page);
 413
 414                                         textdim = DoMethod(obj, MUIM_TextDim, buff, strlen(buff), 0, 0);
 415                                         textwidth = textdim & 0xffff;
 416                                         textpos = _mwidth(obj) /2 - textwidth / 2;
 417                                         DoMethod(obj, MUIM_Text, _mleft(obj) + textpos, _mbottom(obj) - informationspace, _mwidth(obj), informationspace, buff, strlen(buff), 0, 0);
 418
 419                                 }
 420
 421                                 /* draw active page marker (TODO: make it flickerfree) */
 422
 423                                 if (data->page == activepage)
 424                                 {
 425                                         SetRPAttrs(_rp(obj), RPTAG_PenMode, FALSE, RPTAG_FgColor, 0xffff0000, TAG_DONE);
 426                                         RectFill(_rp(obj), x0, y0, x0 + width - 1, y0 + 1);
 427                                         RectFill(_rp(obj), x0, y0 + height - 2, x0 + width - 1, y0 + height - 1);
 428                                         RectFill(_rp(obj), x0, y0, x0 + 1, y0 + height - 1);
 429                                         RectFill(_rp(obj), x0 + width - 2, y0, x0 + width - 1, y0 + height - 1);
 430                                 }
 431
 432                                 /* draw selection markers (TODO: make it flickerfree) */
 433
 434                                 if (!ISLISTEMPTY(&data->markerlist))
 435                                 {
 436                                         struct markernode *mn;
 437
 438                                         ITERATELIST(mn, &data->markerlist)
 439                                         {
 440                                                 rendermarker(data, _rp(obj), mn, x0, y0);
 441                                         }
 442                                 }
 443
 444                                 /* render lasso */
 445
 446                                 if (data->lasso.enabled)
 447                                 {
 448                                         rendermarker(data, _rp(obj), &data->lasso.marker, x0, y0);
 449                                 }
 450                         }
 451
 452                 }
 453                 else if (data->quiet == FALSE)
 454                 {
 455                         DoMethod(obj, MUIM_DrawBackground, _mleft(obj), _mtop(obj), _mwidth(obj), _mheight(obj), 0, 0, 0);
 456                 }
 457
 458                 if (data->image == NULL || data->image->data == NULL || data->invalid /*|| data->prevwidth != _mwidth(obj) || data->prevheight != _mheight(obj)*/)
 459                 {
 460                         /* setup needrefresh param so the main app can rerender page */
 461                         //data->prevwidth = _mwidth(obj);
 462                         //data->prevheight = _mheight(obj);
 463                         data->invalid = FALSE;
 464                         SetAttrs(_parent(obj), MUIA_Group_Forward, FALSE, MUIA_PageView_NeedRefresh, data->page, TAG_DONE);
 465                 }
 466
 467                 ReleaseSemaphore(&data->sema);
 468         }
 469
 470         return rc;
 471 }
 472
 473 ////
 474
 475 /// render selection region
 476
 477 static void renderselectionregion(Object *obj, struct Data *data, struct pdfSelectionRegion *selection)
 478 {
 479         if (selection != NULL && data->image != NULL && data->image->data != NULL)
 480         {
 481                 int i;
 482                 for(i=0; i<selection->numrects; i++)
 483                 {
 484                         int px, py;
 485                         int pw, ph;
 486
 487                         int x, y;
 488                         struct pdfSelectionRectangle *rect = &selection->rectangles[i];
 489
 490                         if (1)
 491                         for(y=rect->y1 * data->image->height; y<=rect->y2 * data->image->height; y++)
 492                         {
 493                                 if (data->image->bpp == 4)
 494                                 {
 495                                         unsigned int *img = (unsigned int*)data->image->data;
 496                                         int width = data->image->width;
 497
 498                                         for(x=rect->x1 * data->image->width; x<=rect->x2 * data->image->width; x++)
 499                                         {
 500                                                 if (x >= 0 && y >= 0 && x < data->image->width && y < data->image->height)
 501                                                         img[x + width * y] = 0x00ffffff ^ img[x + width * y];
 502                                         }
 503                                 }
 504                                 else if (data->image->bpp == 1)
 505                                 {
 506                                         unsigned char *img = (unsigned char*)data->image->data;
 507                                         int width = data->image->width;
 508
 509                                         for(x=rect->x1 * data->image->width; x<=rect->x2 * data->image->width; x++)
 510                                         {
 511                                                 if (x >= 0 && y >= 0 && x < data->image->width && y < data->image->height)
 512                                                         img[x + width * y] = 0xff ^ img[x + width * y];
 513                                         }
 514                                 }
 515                         }
 516                 }
 517         }
 518 }
 519
 520 ////
 521
 522 ///     updatemarkers (resize to device coords)
 523
 524 static void updatemarkers(Object *obj, struct Data *data, int all)
 525 {
 526         struct markernode *mn;
 527         struct annotationnode *an;
 528         //pdfLock(data->doc);
 529
 530         if (data->image != NULL && data->image->data != NULL)
 531         {
 532
 533                 ITERATELIST(mn, &data->markerlist)
 534                 {
 535                         //pdfConvertDeviceToUser(data->doc, data->page, mn->x1, mn->y1, &mn->ux1, &mn->uy1);
 536                         //pdfConvertDeviceToUser(data->doc, data->page, mn->x2, mn->y2, &mn->ux2, &mn->uy2);
 537
 538                         float ox1 = mn->x1 - 0.5f, oy1 = mn->y1 - 0.5f;
 539                         float ox2 = mn->x2 - 0.5f, oy2 = mn->y2 - 0.5f;
 540                         float x1, x2, y1, y2;
 541                         float t;
 542
 543                         if (data->rotation == 0)
 544                         {
 545                                 x1 = ox1; y1 = oy1;
 546                                 x2 = ox2; y2 = oy2;
 547                         }
 548                         else if (data->rotation == 1)
 549                         {
 550                                 x1 = -oy1; y1 = ox1;
 551                                 x2 = -oy2; y2 = ox2;
 552                         }
 553                         else if (data->rotation == 2)
 554                         {
 555                                 x1 = -ox1; y1 = -oy1;
 556                                 x2 = -ox2; y2 = -oy2;
 557                         }
 558                         else /*(data->rotation == 3)*/
 559                         {
 560                                 x1 = oy1; y1 = -ox1;
 561                                 x2 = oy2; y2 = -ox2;
 562                         }
 563
 564                         if (x1 > x2) /*can happen after rotation */
 565                         {
 566                                 t = x1;
 567                                 x1 = x2;
 568                                 x2 = t;
 569                         }
 570                         if (y1 < y2)
 571                         {
 572                                 t = y1;
 573                                 y1 = y2;
 574                                 y2 = t;
 575                         }
 576
 577                         x1 += 0.5f; y1 += 0.5f;
 578                         x2 += 0.5f; y2 += 0.5f;
 579
 580                         mn->ux1 = x1 * data->image->width;
 581                         mn->uy1 = y1 * data->image->height;
 582                         mn->ux2 = x2 * data->image->width;
 583                         mn->uy2 = y2 * data->image->height;
 584                         mn->valid = TRUE;
 585                 }
 586
 587                 ITERATELIST(an, &data->annotationlist)
 588                 {
 589                         //pdfConvertDeviceToUser(data->doc, data->page, mn->x1, mn->y1, &mn->ux1, &mn->uy1);
 590                         //pdfConvertDeviceToUser(data->doc, data->page, mn->x2, mn->y2, &mn->ux2, &mn->uy2);
 591
 592                         float ox1 = an->x1 - 0.5f, oy1 = an->y1 - 0.5f;
 593                         float ox2 = an->x2 - 0.5f, oy2 = an->y2 - 0.5f;
 594                         float x1, x2, y1, y2;
 595                         float t;
 596
 597                         if (data->rotation == 0)
 598                         {
 599                                 x1 = ox1; y1 = oy1;
 600                                 x2 = ox2; y2 = oy2;
 601                         }
 602                         else if (data->rotation == 1)
 603                         {
 604                                 x1 = -oy1; y1 = ox1;
 605                                 x2 = -oy2; y2 = ox2;
 606                         }
 607                         else if (data->rotation == 2)
 608                         {
 609                                 x1 = -ox1; y1 = -oy1;
 610                                 x2 = -ox2; y2 = -oy2;
 611                         }
 612                         else /*(data->rotation == 3)*/
 613                         {
 614                                 x1 = oy1; y1 = -ox1;
 615                                 x2 = oy2; y2 = -ox2;
 616                         }
 617
 618                         if (x1 > x2) /*can happen after rotation */
 619                         {
 620                                 t = x1;
 621                                 x1 = x2;
 622                                 x2 = t;
 623                         }
 624                         if (y1 < y2)
 625                         {
 626                                 t = y1;
 627                                 y1 = y2;
 628                                 y2 = t;
 629                         }
 630
 631                         x1 += 0.5f; y1 += 0.5f;
 632                         x2 += 0.5f; y2 += 0.5f;
 633
 634                         an->ux1 = x1 * data->image->width;
 635                         an->uy1 = y1 * data->image->height;
 636                         an->ux2 = x2 * data->image->width;
 637                         an->uy2 = y2 * data->image->height;
 638
 639
 640                         SetAttrs(an->obj, MUIA_Annotation_PosX, an->ux1, MUIA_Annotation_PosY, an->uy1, TAG_DONE);
 641                 }
 642
 643                 /* lasso. ignore page rotation as it can't change when marker is enabled */
 644
 645                 {
 646                         struct markernode *mn = &data->lasso.marker;
 647                         //pdfConvertDeviceToUser(data->doc, data->page, mn->x1, mn->y1, &mn->ux1, &mn->uy1);
 648                         //pdfConvertDeviceToUser(data->doc, data->page, mn->x2, mn->y2, &mn->ux2, &mn->uy2);
 649
 650                         float ox1 = mn->x1 - 0.5f, oy1 = mn->y1 - 0.5f;
 651                         float ox2 = mn->x2 - 0.5f, oy2 = mn->y2 - 0.5f;
 652                         float x1, x2, y1, y2;
 653                         float t;
 654
 655                         x1 = ox1; y1 = oy1;
 656                         x2 = ox2; y2 = oy2;
 657
 658                         if (x1 > x2) /*can happen for lasso */
 659                         {
 660                                 t = x1;
 661                                 x1 = x2;
 662                                 x2 = t;
 663                         }
 664                         if (y1 < y2)
 665                         {
 666                                 t = y1;
 667                                 y1 = y2;
 668                                 y2 = t;
 669                         }
 670
 671                         x1 += 0.5f; y1 += 0.5f;
 672                         x2 += 0.5f; y2 += 0.5f;
 673
 674                         mn->ux1 = x1 * data->image->width;
 675                         mn->uy1 = y1 * data->image->height;
 676                         mn->ux2 = x2 * data->image->width;
 677                         mn->uy2 = y2 * data->image->height;
 678                         mn->valid = TRUE;
 679                 }
 680
 681         }
 682         //pdfRelease(data->doc);
 683 }
 684
 685 ////
 686
 687 ///     set
 688
 689 DEFSET
 690 {
 691         GETDATA;
 692
 693         FORTAG(INITTAGS)
 694         {
 695
 696                 case MUIA_PageView_LayoutWidth:
 697                         data->layoutwidth = tag->ti_Data;
 698                         data->invalid = TRUE;
 699                         break;
 700
 701                 case MUIA_PageView_LayoutHeight:
 702                         data->layoutheight = tag->ti_Data;
 703                         data->invalid = TRUE;
 704                         break;
 705
 706                 case MUIA_PageView_Page:
 707                         data->page = tag->ti_Data;
 708                         break;
 709
 710                 case MUIA_PageView_PDFReady:
 711                         data->ready = tag->ti_Data;
 712                         break;
 713
 714                 case MUIA_PageView_Quiet:
 715                         data->quiet = tag->ti_Data;
 716                         break;
 717
 718                 case MUIA_PageView_PDFBitmap:
 719
 720                         /* delete old image if present and create new. can NOT refresh display! */
 721
 722                         ObtainSemaphore(&data->sema);
 723
 724                         if (tag->ti_Data == NULL)
 725                         {
 726                                 if (data->image != NULL)
 727                                 {
 728                                         mfree(data->image->data);
 729                                         data->image->data = NULL;
 730                                 }
 731                         }
 732                         else
 733                         {
 734                                 if (data->image == NULL)
 735                                 {
 736                                         struct pdfBitmap *bm = (struct pdfBitmap*)tag->ti_Data;
 737
 738                                         data->image = calloc(1, sizeof(ThbImage));
 739
 740                                         data->region.x1 = 0;
 741                                         data->region.y1 = 0;
 742                                         data->region.x2 = bm->width - 1;
 743                                         data->region.y2 = bm->height - 1;
 744                                 }
 745
 746                                 if (data->image != NULL)
 747                                 {
 748                                         struct pdfBitmap *bm = (struct pdfBitmap*)tag->ti_Data;
 749                                         int isgrayscale = TRUE;
 750                                         int x, y;
 751
 752                                         for(y=0; y<bm->height; y++)
 753                                         {
 754                                                 unsigned char *src = bm->data + bm->stride * y;
 755                                                 unsigned int rowdiff = 0;
 756                                                 for(x=bm->width; x>0; x--)
 757                                                 {
 758                                                         int r = src[1];
 759                                                         int g = src[2];
 760                                                         int b = src[3];
 761                                                         int different = (r | g | b)  - (r & g & b);     // hopefuly this works and is faster than two conditions
 762                                                                                                                                                 // when equal both terms should be equal so diff == 0
 763                                                                                                                                                 // also, when different it will always be > 0
 764
 765                                                         rowdiff += different;
 766                                                         src += 4;
 767                                                 }
 768
 769                                                 if (rowdiff != 0)
 770                                                 {
 771                                                         isgrayscale = FALSE;
 772                                                         break;
 773                                                 }
 774                                         }
 775
 776                                         D(kprintf("image is grayscale:%d\n", isgrayscale));
 777
 778                                         data->image->width = bm->width;
 779                                         data->image->height = bm->height;
 780                                         data->image->bpp = isgrayscale ? 1 : 4;
 781                                         data->image->data = mmalloc(bm->width * bm->height * data->image->bpp);
 782                                         if (data->image->data != NULL)
 783                                         {
 784                                                 int i, j;
 785                                                 for(i=0; i<bm->height; i++)
 786                                                 {
 787                                                         unsigned char *src = bm->data + bm->stride * i;
 788                                                         if (isgrayscale == FALSE)
 789                                                                 memcpy((unsigned int*)data->image->data + i * bm->width, src, bm->width * 4);
 790                                                         else
 791                                                         {
 792                                                                 unsigned char *dst = data->image->data + data->image->width * i;
 793                                                                 for(j=bm->width; j>0; j--)
 794                                                                 {
 795                                                                         *dst++ = src[1];
 796                                                                         src += 4;
 797                                                                 }
 798                                                         }
 799                                                 }
 800                                         }
 801                                 }
 802
 803                                 updatemarkers(obj, data, TRUE);
 804                                 renderselectionregion(obj, data, data->lasso.oldregion);
 805                         }
 806
 807                         ReleaseSemaphore(&data->sema);
 808
 809                         break;
 810
 811                 case MUIA_PageView_Rotation:
 812
 813                         data->rotation = tag->ti_Data;
 814                         data->invalid = TRUE;
 815                         break;
 816
 817         }
 818         NEXTTAG;
 819
 820         return(DOSUPER);
 821 }
 822
 823 ////
 824
 825 ///     get
 826
 827 DEFGET
 828 {
 829         GETDATA;
 830
 831         switch (msg->opg_AttrID)
 832         {
 833                 case MUIA_PageView_Width:
 834                         *(msg->opg_Storage) = (ULONG)(data->image ? data->image->width : 0);
 835                         return TRUE;
 836
 837                 case MUIA_PageView_Height:
 838                         *(msg->opg_Storage) = (ULONG)(data->image ? data->image->height : 0);
 839                         return TRUE;
 840
 841                 case MUIA_PageView_LayoutWidth:
 842                         *(msg->opg_Storage) = (ULONG)(data->layoutwidth);
 843                         return TRUE;
 844
 845                 case MUIA_PageView_LayoutHeight:
 846                         *(msg->opg_Storage) = (ULONG)(data->layoutheight);
 847                         return TRUE;
 848
 849                 case MUIA_PageView_Region:
 850                         *(msg->opg_Storage) = (ULONG)&data->region;
 851                         return TRUE;
 852
 853                 case MUIA_PageView_Page:
 854                         *(msg->opg_Storage) = (ULONG)data->page;
 855                         return TRUE;
 856
 857                 case MUIA_PageView_MediaWidth:
 858                         *(msg->opg_Storage) = (ULONG)data->mediawidth;
 859                         return TRUE;
 860
 861                 case MUIA_PageView_MediaHeight:
 862                         *(msg->opg_Storage) = (ULONG)data->mediaheight;
 863                         return TRUE;
 864
 865                 case MUIA_PageView_RedirectPage:
 866                         return TRUE;
 867
 868                 case MUIA_PageView_NeedRefresh:
 869                         return TRUE;
 870
 871                 case MUIA_PageView_RenderWidth:
 872                         *(msg->opg_Storage) = xget(obj, MUIA_Width);
 873                         return TRUE;
 874
 875                 case MUIA_PageView_RenderHeight:
 876                         *(msg->opg_Storage) = xget(obj, MUIA_Height) - getinformationspace(obj, data);
 877                         return TRUE;
 878
 879                 case MUIA_PageView_Rotation:
 880                         *(msg->opg_Storage) = data->rotation;
 881                         return TRUE;
 882
 883         }
 884
 885         return(DOSUPER);
 886 }
 887
 888 ////
 889
 890 ///     update
 891
 892 DEFMMETHOD(PageView_Update)
 893 {
 894         GETDATA;
 895
 896         data->refreshrect.MinX = msg->x;
 897         data->refreshrect.MaxX = msg->x + msg->width;
 898         data->refreshrect.MinY = msg->y;
 899         data->refreshrect.MaxY = msg->y + msg->height;
 900
 901         MUI_Redraw(obj, MADF_DRAWUPDATE);
 902
 903         data->refreshrect.MinX = -1;
 904         return 0;
 905 }
 906
 907 ////
 908
 909 ///     handleevent
 910
 911 METHOD riHandleEvent(struct IClass *cl,Object *obj,struct MUIP_HandleEvent *msg)
 912 {
 913         #define _between(a,x,b) ((x)>=(a) && (x)<=(b))
 914         #define _isinobject(obj,x,y) (_between(vl,(x),vl+vw) && _between(vt,(y),vt+vh))
 915         #define _isinimage(obj,x,y) (_between(vl + data->offsetx, (x), vl + vw - data->offsetx) && _between(vt + data->offsety,(y), vt + vh - data->offsety))
 916
 917         GETDATA;
 918         int vl = _mleft(obj);
 919         int vt = _mtop(obj);
 920         int vw = _mwidth(obj);
 921         int vh = _mheight(obj);
 922
 923         if (msg->imsg != NULL && _isinobject(obj, msg->imsg->MouseX, msg->imsg->MouseY)/* || data->eh.ehn_Events & IDCMP_MOUSEMOVE*/)
 924         {
 925                 if (msg->imsg != NULL)
 926                 {
 927                         switch (msg->imsg->Class)
 928                         {
 929                                 case IDCMP_MOUSEBUTTONS:
 930                                 {
 931                                         int mx = max(0, msg->imsg->MouseX - _left(obj) - data->offsetx);
 932                                         int my = max(0, msg->imsg->MouseY - _top(obj) - data->offsety);
 933
 934                                         if (msg->imsg->Code == SELECTDOWN)
 935                                         {
 936                                                 if (_isinimage(obj, msg->imsg->MouseX, msg->imsg->MouseY))
 937                                                 {
 938                                                         data->mousedown = TRUE;
 939                                                         if (data->ispreview == FALSE && data->lasso.enabled == FALSE && xget(objFindContainerByAttribute(obj, MUIA_DocumentView_DragAction), MUIA_DocumentView_DragAction) == MUIV_DocumentView_DragAction_Mark) /* first coord */
 940                                                         {
 941                                                                 /* clear selection on all previous pages */
 942
 943                                                                 DoMethod(objFindContainerByAttribute(obj, MUIA_DocumentView_DragAction), MUIM_DocumentView_ClearSelection);
 944
 945                                                                 data->lasso.marker.x1 = data->lasso.marker.x2 = (float)mx / data->image->width;
 946                                                                 data->lasso.marker.y1 = data->lasso.marker.y2 = (float)my / data->image->height;
 947                                                                 data->lasso.enabled = TRUE;
 948                                                         }
 949                                                 }
 950                                         }
 951                                         else if (msg->imsg->Code == SELECTUP)
 952                                         {
 953                                                 if (data->lasso.enabled)
 954                                                 {
 955                                                         data->lasso.enabled = FALSE;
 956                                                 }
 957                                                 else if (data->ready && !data->ispreview)
 958                                                 {
 959                                                         double x = mx;
 960                                                         double y = my;
 961                                                         void *link = pdfFindLink(data->doc, data->page, x, y);
 962                                                         if (link != NULL)
 963                                                         {
 964                                                                 int page = pdfGetActionPageFromLink(data->doc, link);
 965                                                                 //printf("find page:%d\n", page);
 966                                                                 //char *url = linkGetActionURL(link);
 967                                                                 if (page > 0)
 968                                                                         set(_parent(obj), MUIA_PageView_RedirectPage, page);
 969                                                         }
 970
 971                                                         /* lookup annotation and toggle */
 972                                                         if (!ISLISTEMPTY(&data->annotationlist))
 973                                                         {
 974                                                                 struct annotationnode *an;
 975                                                                 ITERATELIST(an, &data->annotationlist)
 976                                                                 {
 977                                                                         //printf("checking %d, %d vs %d,%d  %d,%d\n", mx, my, an->ux1, an->uy1, an->ux2, an->uy2);
 978                                                                         if (_between(an->ux1, mx, an->ux2) && _between(an->uy2, my, an->uy1))
 979                                                                         {
 980                                                                                 DoMethod(an->obj, MUIM_Annotation_Toggle);
 981                                                                                 break;
 982                                                                         }
 983                                                                 }
 984                                                         }
 985
 986                                                 }
 987                                                 else if (data->ispreview && data->mousedown) /* for page preview, like in outlines */
 988                                                 {
 989                                                         set(_parent(obj), MUIA_PageView_RedirectPage, data->page);
 990                                                 }
 991
 992                                                 data->mousedown = TRUE;
 993                                         }
 994                                         break;
 995                                 }
 996
 997                                 case IDCMP_MOUSEMOVE:
 998                                 {
 999                                         int mx = max(0, msg->imsg->MouseX - _left(obj) - data->offsetx);
1000                                         int my = max(0, msg->imsg->MouseY - _top(obj) - data->offsety);
1001
1002                                         if (data->lasso.enabled)
1003                                         {
1004                                                 struct pdfSelectionRegion *selection;
1005
1006                                                 data->lasso.marker.x2 = min(1.0, (float)mx / data->image->width);
1007                                                 data->lasso.marker.y2 = min(1.0, (float)my / data->image->height);
1008
1009                                                 /* fetch selection from pdf document */
1010
1011                                                 if (data->lasso.oldregion != NULL)
1012                                                 {
1013                                                         renderselectionregion(obj, data, data->lasso.oldregion);
1014                                                         pdfDisposeRegionForSelection(data->doc, data->lasso.oldregion);
1015                                                 }
1016
1017                                                 selection = pdfBuildRegionForSelection(data->doc, data->page, data->lasso.marker.x1, data->lasso.marker.y1, data->lasso.marker.x2, data->lasso.marker.y2, NULL);
1018                                                 if (selection != NULL)
1019                                                 {
1020                                                         renderselectionregion(obj, data, selection);
1021                                                         data->lasso.oldregion = selection;
1022                                                 }
1023
1024                                                 updatemarkers(obj, data, TRUE);
1025                                                 MUI_Redraw(obj, MADF_DRAWUPDATE);
1026                                                 return MUI_EventHandlerRC_Eat;
1027                                         }
1028                                         #if 0
1029                                         /* find area over which we are and setup appropriate pointer */
1030                                         if (data->hasregion && data->moveregion == 0)
1031                                         {
1032                                                 int handle = rectFindClosestHandle(data, &data->region, mx, my, 0);
1033                                                 int cursormapping[9] = {
1034                                                         POINTERTYPE_DIAGONALRESIZE2,
1035                                                         POINTERTYPE_DIAGONALRESIZE1,
1036                                                         POINTERTYPE_DIAGONALRESIZE2,
1037                                                         POINTERTYPE_DIAGONALRESIZE1,
1038                                                         POINTERTYPE_VERTICALRESIZE,
1039                                                         POINTERTYPE_HORIZONTALRESIZE,
1040                                                         POINTERTYPE_VERTICALRESIZE,
1041                                                         POINTERTYPE_HORIZONTALRESIZE,
1042                                                         POINTERTYPE_MOVE};
1043
1044                                                 if (_isinimage(obj, msg->imsg->MouseX, msg->imsg->MouseY))
1045                                                 {
1046                                                         if (data->pointertype != cursormapping[handle - 1])
1047                                                                 SetWindowPointer(_window(obj), WA_PointerType, data->pointertype = cursormapping[handle - 1], TAG_DONE);
1048                                                 }
1049                                                 else
1050                                                         SetWindowPointer(_window(obj), WA_PointerType, data->pointertype = POINTERTYPE_NORMAL, TAG_DONE);
1051                                         }
1052                                         else if (data->hasregion)
1053                                         {
1054                                                 rectSetCorner(data, &data->region, data->moveregion, mx, my, 0);
1055                                                 set(obj, MUIA_PageView_Region, (ULONG)&data->region);
1056                                         }
1057                                         else if (!data->hasregion && data->ready)
1058                                         {
1059                                                 double x = mx;
1060                                                 double y = my;
1061                                                 void *link = NULL;
1062
1063                                                 //link = pdfFindLink(data->doc, data->page, x, y);
1064
1065                                                 if (link != NULL)
1066                                                 {
1067                                                         //char *description = linkGetDescription(link);
1068                                                 }
1069                                                 else
1070                                                 {
1071                                                         //kprintf("mouse:%d,%d\n", (int)x, (int)y);
1072                                                 }
1073                                         }
1074                                         #endif
1075                                         break;
1076                                 }
1077                         }
1078                 }
1079         }
1080
1081         return(DOSUPER);
1082 }
1083
1084 ////
1085
1086 ///     backfill
1087
1088 DEFMMETHOD(Backfill)
1089 {
1090         //printf("%d, %d, %d, %d\n", msg->left, msg->top, msg->right, msg->bottom);
1091         return 0;//DOSUPER;
1092 }
1093
1094 ////
1095
1096 ///     hide
1097
1098 DEFMMETHOD(Hide)
1099 {
1100         GETDATA;
1101
1102         /* hide is a bit tricky in virtgroups. it is called while scrolling so
1103            we just push the method and if show is called right after it then flush
1104            is canceled.*/
1105
1106 #if defined(__AROS__)
1107     kprintf("[Pageview::Hide] not implemented\n");
1108     // FIXME: implement MUIV_PushMethod_Delay in Zune/AROS
1109         data->flushmethodid = DoMethod(_app(obj), MUIM_Application_PushMethod, obj, 1, MUIM_PageView_Flush);
1110 #else
1111         data->flushmethodid = DoMethod(_app(obj), MUIM_Application_PushMethod, obj, 1 | MUIV_PushMethod_Delay(150), MUIM_PageView_Flush);
1112 #endif
1113         D(kprintf("cleanup:%d\n", data->page));
1114         return DOSUPER;
1115 }
1116
1117 ////
1118
1119 ///     show
1120
1121 DEFMMETHOD(Show)
1122 {
1123         GETDATA;
1124
1125         if (data->flushmethodid != 0)
1126         {
1127                 DoMethod(_app(obj), MUIM_Application_UnpushMethod, NULL, data->flushmethodid, 0);
1128                 data->flushmethodid = 0;
1129         }
1130
1131         if ((1) && data->eh.ehn_Object == NULL)
1132         {
1133                 data->eh.ehn_Object = obj;
1134                 data->eh.ehn_Class  = cl;
1135                 data->eh.ehn_Events = IDCMP_MOUSEBUTTONS | IDCMP_MOUSEMOVE;
1136                 data->eh.ehn_Priority = 100;
1137                 data->eh.ehn_Flags = MUI_EHF_GUIMODE;
1138
1139                 DoMethod(_win(obj), MUIM_Window_AddEventHandler, &data->eh);
1140         }
1141
1142         return DOSUPER;
1143 }
1144
1145 ////
1146
1147 ///     flush
1148
1149 DEFMMETHOD(PageView_Flush)
1150 {
1151         GETDATA;
1152
1153         ObtainSemaphore(&data->sema);
1154
1155         if (data->image != NULL)
1156         {
1157                 mfree(data->image->data);
1158                 data->image->data = NULL;
1159         }
1160
1161         if (data->eh.ehn_Object != NULL)
1162         {
1163                 DoMethod(_win(obj), MUIM_Window_RemEventHandler, &data->eh);
1164                 data->eh.ehn_Object = NULL;
1165         }
1166
1167         data->flushmethodid = 0;
1168         ReleaseSemaphore(&data->sema);
1169
1170         return 0;
1171 }
1172
1173 ////
1174
1175 ///     addmarker
1176
1177 DEFMMETHOD(PageView_AddMarker)
1178 {
1179         GETDATA;
1180         unsigned int id = 0;
1181
1182         struct markernode *mn;
1183
1184         if (msg->id != MUIV_PageView_AddMarker_New)
1185         {
1186                 int found = FALSE;
1187                 ITERATELIST(mn, &data->markerlist)
1188                 {
1189                         if (mn->id == msg->id)
1190                         {
1191                                 found = TRUE;
1192                                 id = msg->id;
1193                                 break;
1194                         }
1195                 }
1196
1197                 if (found == FALSE)
1198                         mn = NULL;
1199         }
1200         else
1201         {
1202                 mn = calloc(1, sizeof(*mn));
1203         }
1204
1205         if (mn != NULL)
1206         {
1207                 mn->x1 = msg->coords[0];
1208                 mn->y1 = msg->coords[1];
1209                 mn->x2 = msg->coords[2];
1210                 mn->y2 = msg->coords[3];
1211                 mn->color = msg->color;
1212                 mn->id = id;
1213                 ADDTAIL(&data->markerlist, mn);
1214                 updatemarkers(obj, data, FALSE);
1215         }
1216
1217         return id;
1218 }
1219
1220 ////
1221
1222 ///     removemarker
1223
1224 DEFMMETHOD(PageView_RemoveMarker)
1225 {
1226         GETDATA;
1227
1228         /* TODO: add single marker removal */
1229
1230         while(!ISLISTEMPTY(&data->markerlist))
1231         {
1232                 struct markernode *mn = (struct markernode*)GetHead(&data->markerlist);
1233                 REMOVE(mn);
1234                 free(mn);
1235         }
1236
1237         return 0;
1238 }
1239
1240 ////
1241
1242 ///     addannotation
1243
1244 DEFMMETHOD(PageView_AddAnnotation)
1245 {
1246         GETDATA;
1247
1248         struct annotationnode *an;
1249         an = calloc(1, sizeof(*an));
1250
1251         if (an != NULL)
1252         {
1253                 an->x1 = msg->coords[0];
1254                 an->y1 = msg->coords[1];
1255                 an->x2 = msg->coords[2];
1256                 an->y2 = msg->coords[3];
1257                 an->obj = msg->obj;
1258                 ADDTAIL(&data->annotationlist, an);
1259                 updatemarkers(obj, data, FALSE);
1260         }
1261
1262         return an != NULL;
1263 }
1264
1265 ////
1266
1267 /// removeannotation
1268
1269 DEFMMETHOD(PageView_RemoveAnnotation)
1270 {
1271         GETDATA;
1272         struct annotationnode *an;
1273
1274         ITERATELIST(an, &data->annotationlist)
1275         {
1276                 if (an->obj == msg->obj)
1277                 {
1278                         REMOVE(an);
1279                         free(an);
1280                         break;
1281                 }
1282         }
1283
1284         return TRUE;
1285 }
1286
1287 ////
1288
1289 /// clearselection
1290
1291 DEFMMETHOD(PageView_ClearSelection)
1292 {
1293         GETDATA;
1294
1295         if (data->lasso.oldregion != NULL)
1296         {
1297                 renderselectionregion(obj, data, data->lasso.oldregion);
1298                 pdfDisposeRegionForSelection(data->doc, data->lasso.oldregion);
1299
1300                 if (data->image != NULL && data->image->data != NULL) /* also have to refresh here! */
1301                         MUI_Redraw(obj, MADF_DRAWUPDATE);
1302         }
1303         data->lasso.oldregion = NULL;
1304         data->lasso.marker.x2 = data->lasso.marker.x1;
1305         data->lasso.marker.y2 = data->lasso.marker.y1;
1306
1307
1308         return TRUE;
1309 }
1310
1311 ////
1312
1313 /// clearselection
1314
1315 DEFMMETHOD(PageView_GetSelection)
1316 {
1317         GETDATA;
1318
1319         if (data->lasso.oldregion == NULL)
1320                 return FALSE;
1321
1322         msg->region.x1 = data->lasso.marker.x1; msg->region.y1 = data->lasso.marker.y1;
1323         msg->region.x2 = data->lasso.marker.x2; msg->region.y2 = data->lasso.marker.y2;
1324
1325         return TRUE;
1326 }
1327
1328 ////
1329
1330 BEGINMTABLE
1331         case MUIM_Draw:                         return(riDraw(cl,obj,(APTR)msg));
1332         case MUIM_Setup:                        return(riSetup(cl,obj,(APTR)msg));
1333         case MUIM_Cleanup:                      return(riCleanup(cl,obj,(APTR)msg));
1334         case MUIM_HandleEvent:          return(riHandleEvent(cl,obj,(APTR)msg));
1335         case MUIM_AskMinMax:            return(ThbAskMinMax(cl,obj,(APTR)msg));
1336         DECSET
1337         DECGET
1338         DECNEW
1339         DECDISP
1340         DECMMETHOD(Hide)
1341         DECMMETHOD(Show)
1342         DECMMETHOD(Backfill)
1343         DECMMETHOD(PageView_AddMarker)
1344         DECMMETHOD(PageView_AddAnnotation)
1345         DECMMETHOD(PageView_RemoveMarker)
1346         DECMMETHOD(PageView_RemoveAnnotation)
1347         DECMMETHOD(PageView_Update)
1348         DECMMETHOD(PageView_Flush)
1349         DECMMETHOD(PageView_ClearSelection)
1350         DECMMETHOD(PageView_GetSelection)
1351 ENDMTABLE
1352
1353 DECSUBCLASS_NC(MUIC_Area, PageViewClass)
1354