xpdfcore.cc

来自「source code: Covert TXT to PDF」· CC 代码 · 共 1,915 行 · 第 1/4 页

void XPDFCore::hScrollChangeCbk(Widget widget, XtPointer ptr,
			     XtPointer callData) {
  XPDFCore *core = (XPDFCore *)ptr;
  XmScrollBarCallbackStruct *data = (XmScrollBarCallbackStruct *)callData;

  core->scrollTo(data->value, core->scrollY);
}

void XPDFCore::hScrollDragCbk(Widget widget, XtPointer ptr,
			      XtPointer callData) {
  XPDFCore *core = (XPDFCore *)ptr;
  XmScrollBarCallbackStruct *data = (XmScrollBarCallbackStruct *)callData;

  core->scrollTo(data->value, core->scrollY);
}

void XPDFCore::vScrollChangeCbk(Widget widget, XtPointer ptr,
			     XtPointer callData) {
  XPDFCore *core = (XPDFCore *)ptr;
  XmScrollBarCallbackStruct *data = (XmScrollBarCallbackStruct *)callData;

  core->scrollTo(core->scrollX, data->value);
}

void XPDFCore::vScrollDragCbk(Widget widget, XtPointer ptr,
			      XtPointer callData) {
  XPDFCore *core = (XPDFCore *)ptr;
  XmScrollBarCallbackStruct *data = (XmScrollBarCallbackStruct *)callData;

  core->scrollTo(core->scrollX, data->value);
}

void XPDFCore::resizeCbk(Widget widget, XtPointer ptr, XtPointer callData) {
  XPDFCore *core = (XPDFCore *)ptr;
  Arg args[2];
  int n;
  Dimension w, h;

  n = 0;
  XtSetArg(args[n], XmNwidth, &w); ++n;
  XtSetArg(args[n], XmNheight, &h); ++n;
  XtGetValues(core->drawArea, args, n);
  core->drawAreaWidth = (int)w;
  core->drawAreaHeight = (int)h;
  if (core->page >= 0 &&
      (core->zoom == zoomPage || core->zoom == zoomWidth)) {
    core->displayPage(core->page, core->zoom, core->rotate,
		      gFalse, gFalse);
  } else {
    core->updateScrollBars();
  }
}

void XPDFCore::redrawCbk(Widget widget, XtPointer ptr, XtPointer callData) {
  XPDFCore *core = (XPDFCore *)ptr;
  XmDrawingAreaCallbackStruct *data = (XmDrawingAreaCallbackStruct *)callData;
  int x, y, w, h;

  if (data->reason == XmCR_EXPOSE) {
    x = core->scrollX + data->event->xexpose.x;
    y = core->scrollY + data->event->xexpose.y;
    w = data->event->xexpose.width;
    h = data->event->xexpose.height;
  } else {
    x = core->scrollX;
    y = core->scrollY;
    w = core->drawAreaWidth;
    h = core->drawAreaHeight;
  }
  core->redrawRectangle(x, y, w, h);
}

void XPDFCore::outputDevRedrawCbk(void *data) {
  XPDFCore *core = (XPDFCore *)data;

  core->redrawRectangle(core->scrollX, core->scrollY,
			core->drawAreaWidth, core->drawAreaHeight);
}

void XPDFCore::inputCbk(Widget widget, XtPointer ptr, XtPointer callData) {
  XPDFCore *core = (XPDFCore *)ptr;
  XmDrawingAreaCallbackStruct *data = (XmDrawingAreaCallbackStruct *)callData;
  LinkAction *action;
  int mx, my;
  double x, y;
  char *s;
  KeySym key;
  char buf[20];
  int n;

  switch (data->event->type) {
  case ButtonPress:
    if (data->event->xbutton.button == 1) {
      core->takeFocus();
      if (core->doc && core->doc->getNumPages() > 0) {
	if (core->selectEnabled) {
	  mx = core->scrollX + data->event->xbutton.x;
	  my = core->scrollY + data->event->xbutton.y;
	  core->setSelection(mx, my, mx, my);
	  core->setCursor(core->selectCursor);
	  core->dragging = gTrue;
	}
      }
    } else if (data->event->xbutton.button == 2) {
      if (!core->fullScreen) {
	core->panning = gTrue;
	core->panMX = data->event->xbutton.x;
	core->panMY = data->event->xbutton.y;
      }
    } else if (data->event->xbutton.button == 4) { // mouse wheel up
      if (core->fullScreen) {
	core->gotoPrevPage(1, gTrue, gFalse);
      } else if (core->scrollY == 0) {
	core->gotoPrevPage(1, gFalse, gTrue);
      } else {
	core->scrollUp(1);
      }
    } else if (data->event->xbutton.button == 5) { // mouse wheel down
      if (core->fullScreen ||
	  core->scrollY >=
	    core->out->getPixmapHeight() - core->drawAreaHeight) {
	core->gotoNextPage(1, gTrue);
      } else {
	core->scrollDown(1);
      }
    } else if (data->event->xbutton.button == 6) { // second mouse wheel right
      if (!core->fullScreen) {
	core->scrollRight(1);
      }
    } else if (data->event->xbutton.button == 7) { // second mouse wheel left
      if (!core->fullScreen) {
	core->scrollLeft(1);
      }
    } else {
      if (*core->mouseCbk) {
	(*core->mouseCbk)(core->mouseCbkData, data->event);
      }
    }
    break;
  case ButtonRelease:
    if (data->event->xbutton.button == 1) {
      if (core->doc && core->doc->getNumPages() > 0) {
	mx = core->scrollX + data->event->xbutton.x;
	my = core->scrollY + data->event->xbutton.y;
	if (core->dragging) {
	  core->dragging = gFalse;
	  core->setCursor(None);
	  core->moveSelection(mx, my);
#ifndef NO_TEXT_SELECT
	  if (core->selectXMin != core->selectXMax &&
	      core->selectYMin != core->selectYMax) {
	    if (core->doc->okToCopy()) {
	      core->copySelection();
	    } else {
	      error(-1, "Copying of text from this document is not allowed.");
	    }
	  }
#endif
	}
	if (core->hyperlinksEnabled) {
	  if (core->selectXMin == core->selectXMax ||
	    core->selectYMin == core->selectYMax) {
	    core->doLink(mx, my);
	  }
	}
      }
    } else if (data->event->xbutton.button == 2) {
      core->panning = gFalse;
    } else {
      if (*core->mouseCbk) {
	(*core->mouseCbk)(core->mouseCbkData, data->event);
      }
    }
    break;
  case MotionNotify:
    if (core->doc && core->doc->getNumPages() > 0) {
      mx = core->scrollX + data->event->xbutton.x;
      my = core->scrollY + data->event->xbutton.y;
      if (core->dragging) {
	core->moveSelection(mx, my);
      } else if (core->hyperlinksEnabled) {
	core->out->cvtDevToUser(mx, my, &x, &y);
	if ((action = core->doc->findLink(x, y))) {
	  core->setCursor(core->linkCursor);
	  if (action != core->linkAction) {
	    core->linkAction = action;
	    if (core->updateCbk) {
	      s = "";
	      switch (action->getKind()) {
	      case actionGoTo:
		s = "[internal link]";
		break;
	      case actionGoToR:
		s = ((LinkGoToR *)action)->getFileName()->getCString();
		break;
	      case actionLaunch:
		s = ((LinkLaunch *)action)->getFileName()->getCString();
		break;
	      case actionURI:
		s = ((LinkURI *)action)->getURI()->getCString();
		break;
	      case actionNamed:
		s = ((LinkNamed *)action)->getName()->getCString();
		break;
	      case actionMovie:
		s = "[movie]";
		break;
	      case actionUnknown:
		s = "[unknown link]";
		break;
	      }
	      (*core->updateCbk)(core->updateCbkData, NULL, -1, -1, s);
	    }
	  }
	} else {
	  core->setCursor(None);
	  if (core->linkAction) {
	    core->linkAction = NULL;
	    if (core->updateCbk) {
	      (*core->updateCbk)(core->updateCbkData, NULL, -1, -1, "");
	    }
	  }
	}
      }
    }
    if (core->panning) {
      core->scrollTo(core->scrollX - (data->event->xbutton.x - core->panMX),
		     core->scrollY - (data->event->xbutton.y - core->panMY));
      core->panMX = data->event->xbutton.x;
      core->panMY = data->event->xbutton.y;
    }
    break;
  case KeyPress:
    n = XLookupString(&data->event->xkey, buf, sizeof(buf) - 1,
		      &key, NULL);
    core->keyPress(buf, key, data->event->xkey.state);
    break;
  }
}

void XPDFCore::keyPress(char *s, KeySym key, Guint modifiers) {
  switch (key) {
  case XK_Home:
  case XK_KP_Home:
    if (modifiers & ControlMask) {
      displayPage(1, zoom, rotate, gTrue, gTrue);
    } else if (!fullScreen) {
      scrollTo(0, 0);
    }
    return;
  case XK_End:
  case XK_KP_End:
    if (modifiers & ControlMask) {
      displayPage(doc->getNumPages(), zoom, rotate, gTrue, gTrue);
    } else if (!fullScreen) {
      scrollTo(out->getPixmapWidth() - drawAreaWidth,
	       out->getPixmapHeight() - drawAreaHeight);
    }
    return;
  case XK_Page_Up:
  case XK_KP_Page_Up:
    if (fullScreen) {
      gotoPrevPage(1, gTrue, gFalse);
    } else {
      scrollPageUp();
    }
    return;
  case XK_Page_Down:
  case XK_KP_Page_Down:
    if (fullScreen) {
      gotoNextPage(1, gTrue);
    } else {
      scrollPageDown();
    }
    return;
  case XK_Left:
  case XK_KP_Left:
    if (!fullScreen) {
      scrollLeft();
    }
    return;
  case XK_Right:
  case XK_KP_Right:
    if (!fullScreen) {
      scrollRight();
    }
    return;
  case XK_Up:
  case XK_KP_Up:
    if (!fullScreen) {
      scrollUp();
    }
    return;
  case XK_Down:
  case XK_KP_Down:
    if (!fullScreen) {
      scrollDown();
    }
    return;
  }

  if (*keyPressCbk) {
    (*keyPressCbk)(keyPressCbkData, s, key, modifiers);
  }
}

void XPDFCore::redrawRectangle(int x, int y, int w, int h) {
  XGCValues gcValues;
  Window drawAreaWin;

  // clip to window
  if (x < scrollX) {
    w -= scrollX - x;
    x = scrollX;
  }
  if (x + w > scrollX + drawAreaWidth) {
    w = scrollX + drawAreaWidth - x;
  }
  if (y < scrollY) {
    h -= scrollY - y;
    y = scrollY;
  }
  if (y + h > scrollY + drawAreaHeight) {
    h = scrollY + drawAreaHeight - y;
  }

  // create a GC for the drawing area
  drawAreaWin = XtWindow(drawArea);
  if (!drawAreaGC) {
    gcValues.foreground = paperColor;
    drawAreaGC = XCreateGC(display, drawAreaWin, GCForeground, &gcValues);
  }

  // draw white background past the edges of the document
  if (x + w > out->getPixmapWidth()) {
    XFillRectangle(display, drawAreaWin, drawAreaGC,
		   out->getPixmapWidth() - scrollX, y - scrollY,
		   x + w - out->getPixmapWidth(), h);
    w = out->getPixmapWidth() - x;
  }
  if (y + h > out->getPixmapHeight()) {
    XFillRectangle(display, drawAreaWin, drawAreaGC,
		   x - scrollX, out->getPixmapHeight() - scrollY,
		   w, y + h - out->getPixmapHeight());
    h = out->getPixmapHeight() - y;
  }

  // redraw (checking to see if pixmap has been allocated yet)
  if (out->getPixmapWidth() > 0) {
    XCopyArea(display, out->getPixmap(), drawAreaWin, drawAreaGC,
	      x, y, w, h, x - scrollX, y - scrollY);
  }
}

void XPDFCore::updateScrollBars() {
  Arg args[20];
  int n;
  int maxPos;

  maxPos = out ? out->getPixmapWidth() : 1;
  if (maxPos < drawAreaWidth) {
    maxPos = drawAreaWidth;
  }
  if (scrollX > maxPos - drawAreaWidth) {
    scrollX = maxPos - drawAreaWidth;
  }
  n = 0;
  XtSetArg(args[n], XmNvalue, scrollX); ++n;
  XtSetArg(args[n], XmNmaximum, maxPos); ++n;
  XtSetArg(args[n], XmNsliderSize, drawAreaWidth); ++n;
  XtSetArg(args[n], XmNincrement, 16); ++n;
  XtSetArg(args[n], XmNpageIncrement, drawAreaWidth); ++n;
  XtSetValues(hScrollBar, args, n);

  maxPos = out ? out->getPixmapHeight() : 1;
  if (maxPos < drawAreaHeight) {
    maxPos = drawAreaHeight;
  }
  if (scrollY > maxPos - drawAreaHeight) {
    scrollY = maxPos - drawAreaHeight;
  }
  n = 0;
  XtSetArg(args[n], XmNvalue, scrollY); ++n;
  XtSetArg(args[n], XmNmaximum, maxPos); ++n;
  XtSetArg(args[n], XmNsliderSize, drawAreaHeight); ++n;
  XtSetArg(args[n], XmNincrement, 16); ++n;
  XtSetArg(args[n], XmNpageIncrement, drawAreaHeight); ++n;
  XtSetValues(vScrollBar, args, n);
}

void XPDFCore::setCursor(Cursor cursor) {
  Window topWin;

  if (cursor == currentCursor) {
    return;
  }
  if (!(topWin = XtWindow(shell))) {
    return;
  }
  if (cursor == None) {
    XUndefineCursor(display, topWin);
  } else {
    XDefineCursor(display, topWin, cursor);
  }
  XFlush(display);
  currentCursor = cursor;
}

GBool XPDFCore::doQuestionDialog(char *title, GString *msg) {
  return doDialog(XmDIALOG_QUESTION, gTrue, title, msg);
}

void XPDFCore::doInfoDialog(char *title, GString *msg) {
  doDialog(XmDIALOG_INFORMATION, gFalse, title, msg);
}

void XPDFCore::doErrorDialog(char *title, GString *msg) {
  doDialog(XmDIALOG_ERROR, gFalse, title, msg);
}

GBool XPDFCore::doDialog(int type, GBool hasCancel,
			 char *title, GString *msg) {
  Widget dialog;
  XtAppContext appContext;
  Arg args[20];
  int n;
  XmString s1, s2;
  XEvent event;

  n = 0;
  XtSetArg(args[n], XmNdialogType, type); ++n;
  XtSetArg(args[n], XmNdialogStyle, XmDIALOG_PRIMARY_APPLICATION_MODAL); ++n;
  s1 = XmStringCreateLocalized(title);
  XtSetArg(args[n], XmNdialogTitle, s1); ++n;
  s2 = XmStringCreateLocalized(msg->getCString());
  XtSetArg(args[n], XmNmessageString, s2); ++n;
  dialog = XmCreateMessageDialog(drawArea, "questionDialog", args, n);
  XmStringFree(s1);
  XmStringFree(s2);
  XtUnmanageChild(XmMessageBoxGetChild(dialog, XmDIALOG_HELP_BUTTON));
  XtAddCallback(dialog, XmNokCallback,
		&dialogOkCbk, (XtPointer)this);
  if (hasCancel) {
    XtAddCallback(dialog, XmNcancelCallback,
		  &dialogCancelCbk, (XtPointer)this);
  } else {
    XtUnmanageChild(XmMessageBoxGetChild(dialog, XmDIALOG_CANCEL_BUTTON));
  }

  XtManageChild(dialog);

  appContext = XtWidgetToApplicationContext(dialog);
  dialogDone = 0;
  do {
    XtAppNextEvent(appContext, &event);
    XtDispatchEvent(&event);
  } while (!dialogDone);

  XtUnmanageChild(dialog);
  XtDestroyWidget(dialog);

  return dialogDone > 0;
}

void XPDFCore::dialogOkCbk(Widget widget, XtPointer ptr,
			   XtPointer callData) {
  XPDFCore *core = (XPDFCore *)ptr;

  core->dialogDone = 1;
}

void XPDFCore::dialogCancelCbk(Widget widget, XtPointer ptr,
			       XtPointer callData) {
  XPDFCore *core = (XPDFCore *)ptr;

  core->dialogDone = -1;
}