Source Code (Use browser search to find items of interest.)

killustrator'Canvas (./koffice/killustrator/share/Canvas.h:48)

class Canvas : public QWidget {
  Q_OBJECT
public:
  Canvas (GDocument* doc, float res, QwViewport* vp, QWidget* parent = 0, 
	  const char* name = 0);
  ~Canvas ();

  void setZoomFactor (float factor);
  float getZoomFactor () const;

  void setHorizHelplines (const vector<float>& lines);
  void setVertHelplines (const vector<float>& lines);
  const vector<float>& getHorizHelplines () const;
  const vector<float>& getVertHelplines () const;
  void alignToHelplines (bool flag);
  bool alignToHelplines ();
  void showHelplines (bool flag);
  bool showHelplines ();

  void showGrid (bool flag);
  bool showGrid () const { return gridIsOn; }

  void snapToGrid (bool flag);
  bool snapToGrid () const { return gridSnapIsOn; }

  void setGridDistance (float hdist, float vdist);
  float getHorizGridDistance () const { return hGridDistance; }
  float getVertGridDistance () const { return vGridDistance; }

  void snapPositionToGrid (float& x, float& y);
  Rect snapTranslatedBoxToGrid (const Rect& r);
  Rect snapScaledBoxToGrid (const Rect& r, int hmask);

  void setToolController (ToolController *tc);
  
  void setDocument (GDocument* doc);
  GDocument* getDocument ();
  
  void printDocument ();

  void zoomIn (int x, int y);
  void zoomOut ();

  void showBasePoints (bool flag = true);
  void setOutlineMode (bool flag);

  float scaleFactor () const;

  static void initZoomFactors (QArray<float>& factors);

protected:
  float snapXPositionToGrid (float pos);
  float snapYPositionToGrid (float pos);

  void saveGridProperties ();
  void readGridProperties ();

  void mousePressEvent (QMouseEvent *e);
  void mouseReleaseEvent (QMouseEvent *e);
  void mouseMoveEvent (QMouseEvent *e);
  void keyPressEvent (QKeyEvent *e);
  void paintEvent (QPaintEvent *e);
  void moveEvent (QMoveEvent *e);

  void addHorizHelpline (float pos);
  void addVertHelpline (float pos);

signals:
  void sizeChanged ();
  void gridStatusChanged ();
  void rightButtonAtObjectClicked (int x, int y, GObject* obj);
  void rightButtonAtSelectionClicked (int x, int y);
  void rightButtonClicked (int x, int y);

  void visibleAreaChanged (int x, int y);
  void zoomFactorChanged (float zoom);

  void mousePositionChanged (int x, int y);

public slots:
  void updateView ();
  void updateRegion (const Rect& r);
  void ensureVisibility (bool flag);
  void calculateSize ();
  void updateGridInfos ();

  void addHelpline (int x, int y, bool horizH);
  void drawTmpHelpline (int x, int y, bool horizH);

private slots:
  void retryUpdateRegion ();

private:
  void propagateMouseEvent (QMouseEvent *e);
  void propagateKeyEvent (QKeyEvent *e);
  void drawGrid (QPainter& p);
  void drawHelplines (QPainter& p);
  void redrawView (bool repaintFlag = true);

  QwViewport* viewport;
  QPixmap* pixmap;
  int width, height;
  float resolution;
  float zoomFactor;
  GDocument* document;
  ToolController* toolController;
  bool gridIsOn;
  bool gridSnapIsOn;
  bool dragging, ensureVisibilityFlag;
  float hGridDistance, vGridDistance;
  bool drawBasePoints;
  bool outlineMode;
  int pendingRedraws;
  Rect regionForUpdate, region;
  vector<float> horizHelplines, vertHelplines;
  bool helplinesAreOn, helplinesSnapIsOn;
  float tmpHorizHelpline, tmpVertHelpline;

  static QArray<float> zoomFactors;
};

killustrator'Canvas::Canvas() (./koffice/killustrator/share/Canvas.cc:49)

Canvas::Canvas (GDocument* doc, float res, QwViewport* vp, QWidget* parent,
		const char* name) : QWidget (parent, name) {
  document = doc;
  resolution = res;
  zoomFactor = 1.0;
  drawBasePoints = false;
  viewport = vp;

  connect (document, SIGNAL (changed ()), this, SLOT (updateView ()));
  connect (document, SIGNAL (changed (const Rect&)),
	   this, SLOT (updateRegion (const Rect&)));
  connect (document, SIGNAL (sizeChanged ()), this, SLOT (calculateSize ()));
  connect (&(document->handle ()), SIGNAL (handleChanged ()),
	   this, SLOT (updateView ()));
  connect (document, SIGNAL (gridChanged ()), this, SLOT (updateGridInfos ()));

  pixmap = 0L;

  helplinesAreOn = helplinesSnapIsOn = false;
  tmpHorizHelpline = tmpVertHelpline = -1;

  readGridProperties ();
  updateGridInfos ();

  calculateSize ();
  setFocusPolicy (StrongFocus);
  setMouseTracking (true);
  setBackgroundMode (NoBackground);

  dragging = false;
  ensureVisibilityFlag = false;
  outlineMode = false;
  pendingRedraws = 0;
}

killustrator'Canvas::~Canvas() (./koffice/killustrator/share/Canvas.cc:84)

Canvas::~Canvas () {
  if (pixmap != 0L)
    delete pixmap;
}

killustrator'Canvas::ensureVisibility() (./koffice/killustrator/share/Canvas.cc:89)

void Canvas::ensureVisibility (bool flag) {
  ensureVisibilityFlag = flag;
}

killustrator'Canvas::calculateSize() (./koffice/killustrator/share/Canvas.cc:93)

void Canvas::calculateSize () {
  width = (int) (document->getPaperWidth () * resolution *
		 zoomFactor / 72.0) + 4;
  height = (int) (document->getPaperHeight () * resolution *
		  zoomFactor / 72.0 + 4);
  resize (width, height);

  if (pixmap != 0L)
    delete pixmap;
  pixmap = 0L;
  if (zoomFactor < 3.0)
    pixmap = new QPixmap (width, height);
  viewport->recalculateChildPosition (this);
  updateView ();
  emit sizeChanged ();
}

killustrator'Canvas::initZoomFactors() (./koffice/killustrator/share/Canvas.cc:110)

void Canvas::initZoomFactors (QArray<float>& factors) {
  zoomFactors.duplicate (factors);
}

killustrator'Canvas::setZoomFactor() (./koffice/killustrator/share/Canvas.cc:115)

void Canvas::setZoomFactor (float factor) {
  zoomFactor = factor;
  calculateSize ();
  // recompute pixmaps of fill areas
  document->invalidateClipRegions ();
  updateView ();
  emit sizeChanged ();
  emit zoomFactorChanged (zoomFactor);
}

killustrator'Canvas::getZoomFactor() (./koffice/killustrator/share/Canvas.cc:125)

float Canvas::getZoomFactor () const {
  return zoomFactor;
}

killustrator'Canvas::showGrid() (./koffice/killustrator/share/Canvas.cc:129)

void Canvas::showGrid (bool flag) {
  if (gridIsOn != flag) {
    gridIsOn = flag;
    updateView ();
    emit gridStatusChanged ();
    saveGridProperties ();
  }
}

killustrator'Canvas::snapToGrid() (./koffice/killustrator/share/Canvas.cc:138)

void Canvas::snapToGrid (bool flag) {
  if (gridSnapIsOn != flag) {
    gridSnapIsOn = flag;
    saveGridProperties ();
    emit gridStatusChanged ();
    document->setGrid (hGridDistance, vGridDistance, gridSnapIsOn);
  }
}

killustrator'Canvas::setGridDistance() (./koffice/killustrator/share/Canvas.cc:147)

void Canvas::setGridDistance (float hdist, float vdist) {
  hGridDistance = hdist;
  vGridDistance = vdist;
  saveGridProperties ();
  document->setGrid (hGridDistance, vGridDistance, gridSnapIsOn);
}

killustrator'Canvas::snapTranslatedBoxToGrid() (./koffice/killustrator/share/Canvas.cc:154)

Rect Canvas::snapTranslatedBoxToGrid (const Rect& r) {
  float x1, x2, y1, y2;

  if (helplinesSnapIsOn || gridSnapIsOn) {
    x1 = snapXPositionToGrid (r.left ());
    x2 = snapXPositionToGrid (r.right ());
    y1 = snapYPositionToGrid (r.top ());
    y2 = snapYPositionToGrid (r.bottom ());

    float x = 0, y = 0;
    if (fabs (r.left () - x1) < fabs (r.right () - x2))
      x = x1;
    else
      x = x2 - r.width ();

    if (fabs (r.top () - y1) < fabs (r.bottom () - y2))
      y = y1;
    else
      y = y2 - r.height ();
    return Rect (x, y, r.width (), r.height ());
  }
  else
    return r;
}

killustrator'Canvas::snapScaledBoxToGrid() (./koffice/killustrator/share/Canvas.cc:179)

Rect Canvas::snapScaledBoxToGrid (const Rect& r, int hmask) {
  float x1, x2, y1, y2;

  if (helplinesSnapIsOn || gridSnapIsOn) {
    x1 = snapXPositionToGrid (r.left ());
    x2 = snapXPositionToGrid (r.right ());
    y1 = snapYPositionToGrid (r.top ());
    y2 = snapYPositionToGrid (r.bottom ());

    Rect retval (r);
    if (hmask & Handle::HPos_Left)
      retval.left (x1);
    if (hmask & Handle::HPos_Top)
      retval.top (y1);
    if (hmask & Handle::HPos_Right)
      retval.right (x2);
    if (hmask & Handle::HPos_Bottom)
      retval.bottom (y2);
    return retval;
  }
  else
    return r;
}

killustrator'Canvas::snapXPositionToGrid() (./koffice/killustrator/share/Canvas.cc:203)

float Canvas::snapXPositionToGrid (float pos) {
  bool snap = false;

  if (helplinesSnapIsOn) {
    // try to snap to help lines
    vector<float>::iterator i;
    for (i = vertHelplines.begin (); i != vertHelplines.end (); i++) {
      if (fabs (*i - pos) <= 10.0) {
	pos = *i;
	snap = true;
	break;
      }
    }
  }
  if (gridSnapIsOn && ! snap) {
    int n = (int) (pos / hGridDistance);
    float r = fmod (pos, hGridDistance);
    if (r > (hGridDistance / 2.0))
      n++;
    pos = hGridDistance * n;
  }
  return pos;
}

killustrator'Canvas::snapYPositionToGrid() (./koffice/killustrator/share/Canvas.cc:227)

float Canvas::snapYPositionToGrid (float pos) {
  bool snap = false;

  if (helplinesSnapIsOn) {
    // try to snap to help lines
    vector<float>::iterator i;
    for (i = horizHelplines.begin (); i != horizHelplines.end (); i++) {
      if (fabs (*i - pos) <= 10.0) {
	pos = *i;
	snap = true;
	break;
      }
    }
  }
  if (gridSnapIsOn && ! snap) {
    int n = (int) (pos / vGridDistance);
    float r = fmod (pos, vGridDistance);
    if (r > (vGridDistance / 2.0))
      n++;
    pos = vGridDistance * n;
  }
  return pos;
}

killustrator'Canvas::snapPositionToGrid() (./koffice/killustrator/share/Canvas.cc:251)

void Canvas::snapPositionToGrid (float& x, float& y) {
  bool snap = false;

  if (helplinesSnapIsOn) {
    // try to snap to help lines
    vector<float>::iterator i;
    for (i = horizHelplines.begin (); i != horizHelplines.end (); i++) {
      if (fabs (*i - y) <= 10.0) {
	y = *i;
	snap = true;
	break;
      }
    }
    for (i = vertHelplines.begin (); i != vertHelplines.end (); i++) {
      if (fabs (*i - x) <= 10.0) {
	x = *i;
	snap = true;
	break;
      }
    }
  }
  if (gridSnapIsOn && ! snap) {
    int n = (int) (x / hGridDistance);
    float r = fmod (x, hGridDistance);
    if (r > (hGridDistance / 2.0))
      n++;
    x = hGridDistance * n;

    n = (int) (y / vGridDistance);
    r = fmod (y, vGridDistance);
    if (r > (vGridDistance / 2.0))
      n++;
    y = vGridDistance * n;
  }
}

killustrator'Canvas::setToolController() (./koffice/killustrator/share/Canvas.cc:287)

void Canvas::setToolController (ToolController* tc) {
  toolController = tc;
}

killustrator'Canvas::propagateMouseEvent() (./koffice/killustrator/share/Canvas.cc:291)

void Canvas::propagateMouseEvent (QMouseEvent *e) {
  // transform position of the mouse pointer according to current
  // zoom factor
  QPoint new_pos (qRound (e->x () * 72 / (resolution * zoomFactor)) - 1,
		  qRound (e->y () * 72 / (resolution * zoomFactor)) - 1);
  QMouseEvent new_ev (e->type (), new_pos, e->button (), e->state ());

  emit mousePositionChanged (new_pos.x (), new_pos.y ());

  // ensure visibility
  if (ensureVisibilityFlag) {
    if (e->type () ==
#if QT_VERSION >= 199
	QEvent::MouseButtonPress
#else
	Event_MouseButtonPress
#endif
	&& e->button () == LeftButton)
      dragging = true;
    else if (e->type () ==
#if QT_VERSION >= 199
	     QEvent::MouseButtonRelease
#else
	     Event_MouseButtonRelease
#endif
	     &&
	     e->button () == LeftButton)
      dragging = false;
    else if (e->type () ==
#if QT_VERSION >= 199
	     QEvent::MouseMove
#else
	     Event_MouseMove
#endif
	     && dragging)
      viewport->ensureVisible (e->x (), e->y (), 10, 10);
  }

  if (e->button () == RightButton &&
      e->type () ==
#if QT_VERSION >= 199
      QEvent::MouseButtonPress
#else
      Event_MouseButtonPress
#endif
      && ! toolController->getActiveTool ()->consumesRMBEvents ()) {
    if (document->selectionIsEmpty ()) {
      GObject* obj = document->findContainingObject (new_pos.x (),
						     new_pos.y ());
      if (obj) {
	// pop up menu for the picked object
	emit rightButtonAtObjectClicked (e->x (), e->y (), obj);
      }
      else {
	emit rightButtonClicked (e->x (), e->y ());
      }
    }
    else {
      // pop up menu for the current selection
      emit rightButtonAtSelectionClicked (e->x (), e->y ());
    }
    return;
  }
  else
    if (toolController) {
      // the tool controller processes the event
      toolController->delegateEvent (&new_ev, document, this);
    }
}

killustrator'Canvas::propagateKeyEvent() (./koffice/killustrator/share/Canvas.cc:361)

void Canvas::propagateKeyEvent (QKeyEvent *e) {
  if (toolController) {
    toolController->delegateEvent (e, document, this);
  }
}

killustrator'Canvas::mousePressEvent() (./koffice/killustrator/share/Canvas.cc:367)

void Canvas::mousePressEvent (QMouseEvent* e) {
  propagateMouseEvent (e);
}

killustrator'Canvas::mouseReleaseEvent() (./koffice/killustrator/share/Canvas.cc:371)

void Canvas::mouseReleaseEvent (QMouseEvent* e) {
  propagateMouseEvent (e);
}

killustrator'Canvas::mouseMoveEvent() (./koffice/killustrator/share/Canvas.cc:375)

void Canvas::mouseMoveEvent (QMouseEvent* e) {
  propagateMouseEvent (e);
}

killustrator'Canvas::keyPressEvent() (./koffice/killustrator/share/Canvas.cc:379)

void Canvas::keyPressEvent (QKeyEvent* e) {
  propagateKeyEvent (e);
}

killustrator'Canvas::paintEvent() (./koffice/killustrator/share/Canvas.cc:383)

void Canvas::paintEvent (QPaintEvent* e) {
  const QRect& rect = e->rect ();
  if (pixmap != 0L)
    bitBlt (this, rect.x (), rect.y (), pixmap,
	    rect.x (), rect.y (), rect.width (), rect.height ());
  else
    // For large zoom levels there is no pixmap to copy. So we
    // have to redraw the whole document, but without to call
    // repaint !!!
    redrawView (false);
}

killustrator'Canvas::moveEvent() (./koffice/killustrator/share/Canvas.cc:395)

void Canvas::moveEvent (QMoveEvent *e) {
    emit visibleAreaChanged (e->pos ().x (), e->pos ().y ());
}

killustrator'Canvas::setDocument() (./koffice/killustrator/share/Canvas.cc:399)

void Canvas::setDocument (GDocument* doc) {
  document = doc;
  updateGridInfos ();
  connect (document, SIGNAL (changed ()), this, SLOT (updateView ()));
  connect (document, SIGNAL (gridChanged ()), this, SLOT (updateGridInfos ()));
}

killustrator'Canvas::getDocument() (./koffice/killustrator/share/Canvas.cc:406)

GDocument* Canvas::getDocument () {
  return document;
}

killustrator'Canvas::showBasePoints() (./koffice/killustrator/share/Canvas.cc:410)

void Canvas::showBasePoints (bool flag) {
  drawBasePoints = flag;
  updateView ();
}

killustrator'Canvas::setOutlineMode() (./koffice/killustrator/share/Canvas.cc:415)

void Canvas::setOutlineMode (bool flag) {
  if (outlineMode != flag) {
    outlineMode = flag;
    updateView ();
  }
}

killustrator'Canvas::scaleFactor() (./koffice/killustrator/share/Canvas.cc:422)

float Canvas::scaleFactor () const {
  return resolution * zoomFactor / 72.0;
}

killustrator'Canvas::updateView() (./koffice/killustrator/share/Canvas.cc:426)

void Canvas::updateView () {
  redrawView (true);
}

killustrator'Canvas::redrawView() (./koffice/killustrator/share/Canvas.cc:430)

void Canvas::redrawView (bool repaintFlag) {
  QPaintDevice *pdev;
  pendingRedraws = 0;

  QPainter p;
  float s = scaleFactor ();
  int w = document->getPaperWidth (), h = document->getPaperHeight ();

  // setup the painter
  pdev = (pixmap ? (QPaintDevice *) pixmap : (QPaintDevice *) this);
  p.begin (pdev);
  p.setBackgroundColor (white);
  if (pixmap)
    pixmap->fill (backgroundColor ());

  p.scale (s, s);

  // clear the canvas
  //  p.translate (1, 1);
  p.eraseRect (0, 0, w, h);

  p.setPen (black);
  p.drawRect (0, 0, w - 2, h - 2);
  p.setPen (QPen (darkGray, 2));
  p.moveTo (w - 1, 2);
  p.lineTo (w - 1, h - 1);
  p.lineTo (2, h - 1);
  p.setPen (black);


  // draw the grid
  if (gridIsOn)
    drawGrid (p);

  // draw the help lines
  if (helplinesAreOn)
    drawHelplines (p);

  // next the document contents
  document->drawContents (p, drawBasePoints, outlineMode);

  // and finally the handle
  if (! document->selectionIsEmpty ())
    document->handle ().draw (p);

  p.end ();
  // Don't repaint if called form paintEvent () !!
  if (repaintFlag)
    repaint ();
}

killustrator'Canvas::retryUpdateRegion() (./koffice/killustrator/share/Canvas.cc:481)

void Canvas::retryUpdateRegion () {
  updateRegion (region);
}

killustrator'Canvas::updateRegion() (./koffice/killustrator/share/Canvas.cc:485)

void Canvas::updateRegion (const Rect& reg) {
  if (pendingRedraws == 0 && document->selectionCount () > 1) {
    // we have to update a multiple selection, so we collect
    // the update regions and redraw it in one call
    pendingRedraws = document->selectionCount () - 1;
    regionForUpdate = reg;
    return;
  }

  Rect r = reg;

  if (pendingRedraws > 0) {
    regionForUpdate = regionForUpdate.unite (r);
    pendingRedraws--;
    if (pendingRedraws > 0)
      // not the last redraw call
      return;
    else
      r = regionForUpdate;
  }

  QPainter p;
  float s = scaleFactor ();

  // compute the clipping region
  QWMatrix m;
  m.scale (s, s);

  QRect clip = m.map (QRect (int (r.left ()), int (r.top ()),
			     int (r.width ()), int (r.height ())));

  QPaintDevice *pdev = (pixmap ? (QPaintDevice *) pixmap : (QPaintDevice *) this);
  if (pdev->paintingActive ()) {
    // this occurs only in KOffice, when a embedded part tries
    // to draw in our canvas
    region = reg;
    QTimer::singleShot (50, this, SLOT(retryUpdateRegion ()));
    return;
  }

  // setup the painter
  p.begin (pdev);
  p.setBackgroundColor (white);
  // setup the clip region
  if (clip.x () <= 1) clip.setX (1);
  if (clip.y () <= 1) clip.setY (1);

  int mw = (int) ((float) document->getPaperWidth () * s);
  int mh = (int) ((float) document->getPaperHeight () * s);

  if (clip.right () >= mw)
    clip.setRight (mw);
  if (clip.bottom () >= mh)
    clip.setBottom (mh);

  //  cout << "clip: " << clip.left () << ", " << clip.top ()
  //       << ", " << clip.width () << ", " << clip.height () << endl;

  p.setClipRect (clip);

  // clear the canvas
  p.scale (s, s);
  //  p.translate (1, 1);
  p.eraseRect (r.left (), r.top (), r.width (), r.height ());

  // draw the grid
  if (gridIsOn)
    drawGrid (p);

  // draw the help lines
  if (helplinesAreOn)
    drawHelplines (p);

  // next the document contents
  document->drawContentsInRegion (p, r, drawBasePoints, outlineMode);

  // and finally the handle
  if (! document->selectionIsEmpty ())
    document->handle ().draw (p);

  p.end ();
  repaint (clip, false);
}

killustrator'Canvas::drawHelplines() (./koffice/killustrator/share/Canvas.cc:569)

void Canvas::drawHelplines (QPainter& p) {
  int pw = document->getPaperWidth ();
  int ph = document->getPaperHeight ();
  unsigned int i;

  QPen pen (blue, 0, DashLine);

  p.save ();
  p.setPen (pen);
  for (i = 0; i < horizHelplines.size (); i++) {
    int hi = qRound (horizHelplines[i]);
    p.drawLine (0, hi, pw, hi);
  }
  for (i = 0; i < vertHelplines.size (); i++) {
    int vi = qRound (vertHelplines[i]);
    p.drawLine (vi, 0, vi, ph);
  }

  if (tmpHorizHelpline != -1) {
    int hi = qRound (tmpHorizHelpline);
    p.drawLine (0, hi, pw, hi);
  }

  if (tmpVertHelpline != -1) {
    int vi = qRound (tmpVertHelpline);
    p.drawLine (vi, 0, vi, ph);
  }

  p.restore ();
}

killustrator'Canvas::drawGrid() (./koffice/killustrator/share/Canvas.cc:600)

void Canvas::drawGrid (QPainter& p) {
  int pw = document->getPaperWidth ();
  int ph = document->getPaperHeight ();
  float h, v;

  QPen pen1 (blue, 0, DotLine);

  p.save ();
  p.setPen (pen1);
  for (h = hGridDistance; h < pw; h += hGridDistance) {
    int hi = qRound (h);
    p.drawLine (hi, 0, hi, ph);
  }
  for (v = vGridDistance; v < ph; v += vGridDistance) {
    int vi = qRound (v);
    p.drawLine (0, vi, pw, vi);
  }
  p.restore ();
}

killustrator'Canvas::printDocument() (./koffice/killustrator/share/Canvas.cc:620)

void Canvas::printDocument () {
  QPrinter printer;
  printer.setDocName (document->fileName ());
  printer.setCreator ("KIllustrator");
  switch (document->pageLayout ().format) {
  case PG_DIN_A4:
    printer.setPageSize (QPrinter::A4);
    break;
  case PG_DIN_A5:
    printer.setPageSize (QPrinter::B5);
    break;
  case PG_US_LETTER:
    printer.setPageSize (QPrinter::Letter);
    break;
  case PG_US_LEGAL:
    printer.setPageSize (QPrinter::Legal);
    break;
  default:
    break;
  }
  printer.setOrientation (document->pageLayout ().orientation == PG_PORTRAIT ?
			  QPrinter::Portrait : QPrinter::Landscape);
  if (printer.setup (this)) {
    QPainter paint;
    paint.begin (&printer);
    paint.setClipping (false);
    document->drawContents (paint);
    paint.end ();
  }
}

killustrator'Canvas::zoomIn() (./koffice/killustrator/share/Canvas.cc:651)

void Canvas::zoomIn (int x, int y) {
  int pos = zoomFactors.find (getZoomFactor ());
  assert (pos != -1);
  if (pos < (int) zoomFactors.size () - 1) {
    setZoomFactor (zoomFactors[pos + 1]);
    viewport->centerOn (x, y);
    emit zoomFactorChanged (zoomFactors[pos + 1]);
  }
}

killustrator'Canvas::zoomOut() (./koffice/killustrator/share/Canvas.cc:661)

void Canvas::zoomOut () {
  int pos = zoomFactors.find (getZoomFactor ());
  assert (pos != -1);
  if (pos > 0)
    setZoomFactor (zoomFactors[pos - 1]);
}

killustrator'Canvas::readGridProperties() (./koffice/killustrator/share/Canvas.cc:668)

void Canvas::readGridProperties () {
#if NEWKDE
  KConfig* config = kapp->config ();
#else
  KConfig* config = kapp->getConfig ();
#endif
  QString oldgroup = config->group ();

  config->setGroup ("Grid");

  vGridDistance = (float) config->readDoubleNumEntry ("vGridDistance", 50.0);
  hGridDistance = (float) config->readDoubleNumEntry ("hGridDistance", 50.0);
  gridIsOn = config->readBoolEntry ("showGrid", false);
  gridSnapIsOn = config->readBoolEntry ("snapTopGrid", false);

  config->setGroup ("Helplines");
  helplinesAreOn = config->readBoolEntry ("showHelplines");
  helplinesSnapIsOn = config->readBoolEntry ("snapTopHelplines");

  config->setGroup (oldgroup);
}

killustrator'Canvas::saveGridProperties() (./koffice/killustrator/share/Canvas.cc:690)

void Canvas::saveGridProperties () {
#if NEWKDE
  KConfig* config = kapp->config ();
#else
  KConfig* config = kapp->getConfig ();
#endif
  QString oldgroup = config->group ();

  config->setGroup ("Grid");

  config->writeEntry ("vGridDistance", (double) vGridDistance);
  config->writeEntry ("hGridDistance", (double) hGridDistance);
  config->writeEntry ("showGrid", gridIsOn);
  config->writeEntry ("snapTopGrid", gridSnapIsOn);

  config->setGroup ("Helplines");
  config->writeEntry ("showHelplines", helplinesAreOn);
  config->writeEntry ("snapTopHelplines", helplinesSnapIsOn);

  config->setGroup (oldgroup);
  config->sync ();
}

killustrator'Canvas::drawTmpHelpline() (./koffice/killustrator/share/Canvas.cc:713)

void Canvas::drawTmpHelpline (int x, int y, bool horizH) {
  float pos = -1;
  // convert into document coordinates
  // and add helpline
  if (horizH) {
    pos = (float) y / zoomFactor - this->y ();
    tmpHorizHelpline = pos;
  }
  else {
    pos = (float) x / zoomFactor - this->x ();
    tmpVertHelpline = pos;
  }
  if (helplinesAreOn)
    updateView ();
}

killustrator'Canvas::addHelpline() (./koffice/killustrator/share/Canvas.cc:729)

void Canvas::addHelpline (int x, int y, bool horizH) {
  float pos = -1;
  tmpHorizHelpline = tmpVertHelpline = -1;
  // convert into document coordinates
  // and add helpline
  if (horizH) {
    pos = (float) y / zoomFactor - this->y ();
    addHorizHelpline (pos);
  }
  else {
    pos = (float) x / zoomFactor - this->x ();
    addVertHelpline (pos);
  }
}

killustrator'Canvas::addHorizHelpline() (./koffice/killustrator/share/Canvas.cc:744)

void Canvas::addHorizHelpline  (float pos) {
  horizHelplines.push_back (pos);
  if (helplinesAreOn)
    updateView ();
  document->setHelplines (horizHelplines, vertHelplines, helplinesSnapIsOn);
}

killustrator'Canvas::addVertHelpline() (./koffice/killustrator/share/Canvas.cc:751)

void Canvas::addVertHelpline  (float pos) {
  vertHelplines.push_back (pos);
  if (helplinesAreOn)
    updateView ();
  document->setHelplines (horizHelplines, vertHelplines, helplinesSnapIsOn);
}

killustrator'Canvas::setHorizHelplines() (./koffice/killustrator/share/Canvas.cc:758)

void Canvas::setHorizHelplines (const vector<float>& lines) {
  horizHelplines = lines;
  if (helplinesAreOn)
    updateView ();
  document->setHelplines (horizHelplines, vertHelplines, helplinesSnapIsOn);
}

killustrator'Canvas::setVertHelplines() (./koffice/killustrator/share/Canvas.cc:765)

void Canvas::setVertHelplines (const vector<float>& lines) {
  vertHelplines = lines;
  if (helplinesAreOn)
    updateView ();
  document->setHelplines (horizHelplines, vertHelplines, helplinesSnapIsOn);
}

killustrator'Canvas::getHorizHelplines() (./koffice/killustrator/share/Canvas.cc:772)

const vector<float>& Canvas::getHorizHelplines () const {
  return horizHelplines;
}

killustrator'Canvas::getVertHelplines() (./koffice/killustrator/share/Canvas.cc:776)

const vector<float>& Canvas::getVertHelplines () const {
  return vertHelplines;
}

killustrator'Canvas::alignToHelplines() (./koffice/killustrator/share/Canvas.cc:780)

void Canvas::alignToHelplines (bool flag) {
  helplinesSnapIsOn = flag;
  emit gridStatusChanged ();
  document->setHelplines (horizHelplines, vertHelplines, helplinesSnapIsOn);
}

killustrator'Canvas::alignToHelplines() (./koffice/killustrator/share/Canvas.cc:786)

bool Canvas::alignToHelplines () {
  return helplinesSnapIsOn;
}

killustrator'Canvas::showHelplines() (./koffice/killustrator/share/Canvas.cc:790)

void Canvas::showHelplines (bool flag) {
  if (helplinesAreOn != flag) {
    helplinesAreOn = flag;
    updateView ();
    emit gridStatusChanged ();
    saveGridProperties ();
  }
}

killustrator'Canvas::showHelplines() (./koffice/killustrator/share/Canvas.cc:799)

bool Canvas::showHelplines () {
  return helplinesAreOn;
}

killustrator'Canvas::updateGridInfos() (./koffice/killustrator/share/Canvas.cc:803)

void Canvas::updateGridInfos () {
  document->getGrid (hGridDistance, vGridDistance, gridSnapIsOn);
  document->getHelplines (horizHelplines, vertHelplines, helplinesSnapIsOn);
  saveGridProperties ();
  emit gridStatusChanged ();
}