PSION CD 2/PsionCDVol2.iso/Programs/720/PDF090B4-SorceCode/pdf/Link.h

C/C++ Source or Header | 2000-09-30 | 8.8 KB | 345 lines

//========================================================================
//
// Link.h
//
// Copyright 1996 Derek B. Noonburg
//
//========================================================================
//
// Ported to EPOC by Sander van der Wal
//
// $Id: Link.h 1.2 2000-09-17 13:38:16+02 svdwal Exp svdwal $

#ifndef LINK_H
#define LINK_H

#ifdef __GNUC__
#pragma interface
#endif

#ifndef __E32BASE_H__
#include <e32base.h>
#endif

#include "Object.h"

class GString;
class Array;
class Dict;

//------------------------------------------------------------------------
// LinkAction
//------------------------------------------------------------------------

enum LinkActionKind {
  actionGoTo,            // go to destination
  actionGoToR,            // go to destination in new file
  actionLaunch,            // launch app (or open document)
  actionURI,            // URI
  actionUnknown            // anything else
};

class LinkAction: public CBase {
public:

  // Factory
  static LinkAction* NewL(Object* aActionObj, GString *aBaseURI);

  // Destructor.
  virtual ~LinkAction() {}

  // Was the LinkAction created successfully?
  virtual GBool isOk() = 0;

  // Check link action type.
  virtual LinkActionKind getKind() = 0;
};

//------------------------------------------------------------------------
// LinkDest
//------------------------------------------------------------------------

enum LinkDestKind {
  destXYZ,
  destFit,
  destFitH,
  destFitV,
  destFitR,
  destFitB,
  destFitBH,
  destFitBV
};

class LinkDest {
public:

  // Build a LinkDest from the array.  If <pageIsRef> is true, the
  // page is specified by an object reference; otherwise the page is
  // specified by a (zero-relative) page number.
  LinkDest();
  void ConstructL(Array *a, GBool pageIsRef1);

  // Copy a LinkDest.
  LinkDest *copyL() { return new(ELeave) LinkDest(this); }

  // Was the LinkDest created successfully?
  GBool isOk() { return ok; }

  // Accessors.
  LinkDestKind getKind() { return kind; }
  GBool isPageRef() { return pageIsRef; }
  int getPageNum() { return pageNum; }
  Ref getPageRef() { return pageRef; }
  double getLeft() { return left; }
  double getBottom() { return bottom; }
  double getRight() { return right; }
  double getTop() { return top; }
  double getZoom() { return zoom; }
  GBool getChangeLeft() { return changeLeft; }
  GBool getChangeTop() { return changeTop; }
  GBool getChangeZoom() { return changeZoom; }

private:

  LinkDestKind kind;        // destination type
  GBool pageIsRef;        // is the page a reference or number?
  union {
    Ref pageRef;        // reference to page
    int pageNum;        // one-relative page number
  };
  double left, bottom;        // position
  double right, top;
  double zoom;            // zoom factor
  GBool changeLeft, changeTop;    // for destXYZ links, which position
  GBool changeZoom;        //   components to change
  GBool ok;            // set if created successfully

  LinkDest(LinkDest *dest);
};

//------------------------------------------------------------------------
// LinkGoTo
//------------------------------------------------------------------------

class LinkGoTo: public LinkAction {
public:
  LinkGoTo() {}

  // Build a LinkGoTo from a destination (dictionary, name, or string).
  void ConstructL(Object *destObj);
  static LinkGoTo* NewL(Object *destObj);


  // Destructor.
  virtual ~LinkGoTo();

  // Was the LinkGoTo created successfully?
  virtual GBool isOk() { return dest || namedDest; }

  // Accessors.
  virtual LinkActionKind getKind() { return actionGoTo; }
  LinkDest *getDest() { return dest; }
  GString *getNamedDest() { return namedDest; }

private:

  LinkDest *dest;        // regular destination (NULL for remote
                //   link with bad destination)
  GString *namedDest;        // named destination (only one of dest and
                //   and namedDest may be non-NULL)
};

//------------------------------------------------------------------------
// LinkGoToR
//------------------------------------------------------------------------

class LinkGoToR: public LinkAction {
public:

  LinkGoToR() {}

  // Build a LinkGoToR from a file spec (dictionary) and destination
  // (dictionary, name, or string).
  void ConstructL(Object *fileSpecObj, Object *destObj);
  static LinkGoToR* NewL(Object *fileSpecObj, Object *destObj);

  // Destructor.
  virtual ~LinkGoToR();

  // Was the LinkGoToR created successfully?
  virtual GBool isOk() { return fileName && (dest || namedDest); }

  // Accessors.
  virtual LinkActionKind getKind() { return actionGoToR; }
  TFileName *getFileName() { return fileName; }
  LinkDest *getDest() { return dest; }
  GString *getNamedDest() { return namedDest; }

private:

  TFileName *fileName;        // file name
  LinkDest *dest;        // regular destination (NULL for remote
                //   link with bad destination)
  GString *namedDest;        // named destination (only one of dest and
                //   and namedDest may be non-NULL)
};

//------------------------------------------------------------------------
// LinkLaunch
//------------------------------------------------------------------------

class LinkLaunch: public LinkAction {
public:

  LinkLaunch() {}

  // Build a LinkLaunch from an action dictionary.
  void ConstructL(Object *actionObj);
  static LinkLaunch* NewL(Object *actionObj);

  // Destructor.
  virtual ~LinkLaunch();

  // Was the LinkLaunch created successfully?
  virtual GBool isOk() { return fileName != NULL; }

  // Accessors.
  virtual LinkActionKind getKind() { return actionLaunch; }
  TFileName *getFileName() { return fileName; }
  GString *getParams() { return params; }

private:

  TFileName *fileName;        // file name
  GString *params;        // parameters
};

//------------------------------------------------------------------------
// LinkURI
//------------------------------------------------------------------------

class LinkURI: public LinkAction {
public:

  LinkURI() {}

  // Build a LinkURI given the URI (string) and base URI.
  void ConstructL(Object *uriObj, GString *baseURI);
  static LinkURI* NewL(Object *uriObj, GString *baseURI);

  // Destructor.
  virtual ~LinkURI();

  // Was the LinkURI created successfully?
  virtual GBool isOk() { return uri != NULL; }

  // Accessors.
  virtual LinkActionKind getKind() { return actionURI; }
  GString *getURI() { return uri; }

private:

  GString *uri;            // the URI
};

//------------------------------------------------------------------------
// LinkUnknown
//------------------------------------------------------------------------

class LinkUnknown: public LinkAction {
public:

  LinkUnknown() {}

  // Build a LinkUnknown with the specified action type.
  void ConstructL(char *action1);
  static LinkUnknown* NewL(char *action1);

  // Destructor.
  virtual ~LinkUnknown();

  // Was the LinkUnknown create successfully?
  virtual GBool isOk() { return action != NULL; }

  // Accessors.
  virtual LinkActionKind getKind() { return actionUnknown; }
  GString *getAction() { return action; }

private:

  GString *action;        // action subtype
};

//------------------------------------------------------------------------
// Link
//------------------------------------------------------------------------

class Link: public CBase {
public:

  Link() {}

  // Construct a link, given its dictionary.
  void ConstructL(Dict *dict, GString *baseURI);

  // Destructor.
  ~Link();

  // Was the link created successfully?
  GBool isOk() { return ok; }

  // Check if point is inside the link rectangle.
  GBool inRect(double x, double y)
    { return x1 <= x && x <= x2 && y1 <= y && y <= y2; }

  // Get action.
  LinkAction *getAction() { return action; }

  // Get border corners and width.
  void getBorder(double *xa1, double *ya1, double *xa2, double *ya2,
         double *wa)
    { *xa1 = x1; *ya1 = y1; *xa2 = x2; *ya2 = y2; *wa = borderW; }

private:

  double x1, y1;        // lower left corner
  double x2, y2;        // upper right corner
  double borderW;        // border width
  LinkAction *action;        // action
  GBool ok;            // is link valid?
};

//------------------------------------------------------------------------
// Links
//------------------------------------------------------------------------

class Links: public CBase {
public:

  Links() {}

  // Extract links from array of annotations.
  void ConstructL(Object *annots, GString *baseURI);

  // Destructor.
  ~Links();

  // Iterate through list of links.
  int getNumLinks() { return numLinks; }
  Link *getLink(int i) { return links[i]; }

  // If point <x>,<y> is in a link, return the associated action;
  // else return NULL.
  LinkAction *find(double x, double y);

  // Return true if <x>,<y> is in a link.
  GBool onLink(double x, double y);

private:

  Link **links;
  int numLinks;
};

#endif