gradientview.cpp

学习 open inventor 的例子

  for (; it != tickmarks.end(); ++it) {
    (*it)->setBrush(Qt::black);
  }
  this->currenttick = -1;
}

void
GradientView::setGradient(const Gradient & grad)
{
  this->grad = grad;
  this->currenttick = -1;
  this->segmentidx = -1;
  this->updateTicks();
  emit this->viewChanged();
}

void
GradientView::setDataLimits(float min, float max)
{
  this->min = min;
  this->max = max;
}

const Gradient &
GradientView::getGradient(void) const
{
  return this->grad;
}

void
GradientView::centerTick(void)
{
  assert(this->currenttick > 0);
  assert(this->currenttick < (int)(this->tickmarks.size() - 1));

  const double left = this->tickmarks[this->currenttick - 1]->x();
  const double right = this->tickmarks[this->currenttick + 1]->x();
  const double center = (right - left) / 2.0 + left;

  this->grad.moveTick(this->currenttick, center / this->canvas->width());

  this->updateTicks();
  emit this->viewChanged();
}

TickMark *
GradientView::newTick(int x)
{
  TickMark* i = new TickMark(this->canvas);
  i->setBrush(QColor(0,0,0));
  i->move(0, this->canvas->height()-15-this->statusbar->height());
  i->setZ(3);
  i->setX(x);
  i->show();
  return i;
}

void
GradientView::insertTick(void)
{
  assert(this->segmentidx != -1);
  const float selectStart = this->tickmarks[this->segmentidx]->x();
  const float selectEnd = this->tickmarks[this->segmentidx + 1]->x();

  // x == midpoint of selected section
  const float x = ((selectEnd - selectStart)/2.0f + selectStart);

  const float t = x / (float)this->canvas->width();
  const int i = this->grad.insertTick(t);

  QValueList<TickMark*>::Iterator it = this->tickmarks.begin();
  // the += operator wasn't available until Qt 3.1.0. Just iterate
  // and use ++. pederb, 2003-09-22
  for (int j = 0; j < i; j++) { it++; }
  this->tickmarks.insert(it, this->newTick((int) x));

  this->segmentidx = -1;

  emit this->viewChanged();
}

// FIXME: this is _not_ good design -- it's potentially inefficient
// and bugridden. As an example, consider the synchronization problem
// if some other code adds or removes tickmarks in the Gradient
// object.
//
// We should probably rather just let the tickmarks be stored
// canonically in the Gradient class, and set up what we need to do
// around in the GradientView code on demand.
//
// 20031008 mortene.
void
GradientView::updateTicks(void)
{
  QValueList<TickMark*>::Iterator it = this->tickmarks.begin();
  for (; it != tickmarks.end(); ++it) { delete (*it); }

  this->tickmarks.clear();

  for (unsigned int i = 0; i < this->grad.numTicks(); i++) {
    float t = this->grad.getParameter(i);
    int x = (int) (t * (float)this->canvas->width() + 0.5f);
    TickMark * tick = this->newTick(x);
    this->tickmarks.append(tick);
  }
  this->tickmarks[0]->setVisible(FALSE);
  this->tickmarks[this->tickmarks.size()-1]->setVisible(FALSE);
}

// *************************************************************************

void
GradientView::setGradientColor(unsigned int tickmarkidx, Gradient::TickSide side, QRgb col)
{
  this->grad.setColor(tickmarkidx, side, col);
  emit this->viewChanged();
}

void
GradientView::setGradientColor(unsigned int tickmarkidx, Gradient::TickSide side)
{
  const QRgb initial = this->grad.getColor(tickmarkidx, side);
  const QRgb newcol = QColorDialog::getRgba(initial);
  if (newcol != initial) {
    this->setGradientColor(tickmarkidx, side, newcol);
  }
}

void
GradientView::deleteTick(void)
{
  assert(this->currenttick > 0);
  assert(this->currenttick < (int)(this->tickmarks.size() - 1));

  this->grad.removeTick(this->currenttick);
  this->updateTicks();
  this->segmentidx = -1;
  this->mousepressed = FALSE;
  emit this->viewChanged();
}

void
GradientView::copySegmentColorRight(void)
{
  this->setGradientColor(this->segmentidx + 1, Gradient::LEFT,
                         this->grad.getColor(this->segmentidx + 1, Gradient::RIGHT));
}

void
GradientView::copySegmentColorLeft(void)
{
  this->setGradientColor(this->segmentidx, Gradient::RIGHT,
                         this->grad.getColor(this->segmentidx, Gradient::LEFT));
}

void
GradientView::chooseSegmentColorLeft(void)
{  
  this->setGradientColor(this->segmentidx, Gradient::RIGHT);
}

void
GradientView::chooseSegmentColorRight(void)
{  
  this->setGradientColor(this->segmentidx + 1, Gradient::LEFT);
}

void
GradientView::chooseTickColorLeft(void)
{  
  this->setGradientColor(this->currenttick, Gradient::LEFT);
}

void
GradientView::chooseTickColorRight(void)
{  
  this->setGradientColor(this->currenttick, Gradient::RIGHT);
}

void
GradientView::copyTickColorLeft(void)
{  
  this->setGradientColor(this->currenttick, Gradient::RIGHT,
                         this->grad.getColor(this->currenttick, Gradient::LEFT));
}

void
GradientView::copyTickColorRight(void)
{  
  this->setGradientColor(this->currenttick, Gradient::LEFT,
                         this->grad.getColor(this->currenttick, Gradient::RIGHT));
}

// *************************************************************************

// FIXME: callback is not really used from this class, just passed on
// to the Gradient class. Should look into design to see if we can
// remove this method. 20031008 mortene.
void
GradientView::setChangeCallback(Gradient::ChangeCB * cb, void * userdata)
{
  this->grad.setChangeCallback(cb, userdata);
}

// *************************************************************************

void
GradientView::buildMenu(void)
{
  // FIXME: instead of building the menu each time, simply use
  // QPopupMenu::changeItem to change the color pixmaps. 20030925 frodo.
  assert(!this->menu);
  this->menu = new QPopupMenu(this);

  int id;

  // FIXME: use menu titles. 20031008 mortene.
  
  if (this->segmentidx != -1) {
    QPixmap pm(16,16);
    pm.fill(this->grad.getColor(this->segmentidx, Gradient::RIGHT));
    id = menu->insertItem(pm, "Change left-side color", this, SLOT(chooseSegmentColorLeft()));

    pm.fill(grad.getColor(this->segmentidx, Gradient::LEFT));
    id = menu->insertItem(pm, "Copy color from left neighbor", this, SLOT(copySegmentColorLeft()));
    if (this->grad.leftEqualsRight(this->segmentidx)) menu->setItemEnabled(id, FALSE);

    menu->insertSeparator();

    pm.fill(this->grad.getColor(this->segmentidx + 1, Gradient::LEFT));
    id = menu->insertItem(pm, "Change right-side color", this, SLOT(chooseSegmentColorRight()));

    pm.fill(this->grad.getColor(this->segmentidx + 1, Gradient::RIGHT));
    id = menu->insertItem(pm, "Copy color from right neighbor", this, SLOT(copySegmentColorRight()));
    if (this->grad.leftEqualsRight(this->segmentidx + 1)) menu->setItemEnabled(id, FALSE);

    menu->insertSeparator();

    id = menu->insertItem("Insert new tick", this, SLOT(insertTick()));
  }
  else if (this->currenttick != -1) {
    QPixmap pm(16,16);
    pm.fill(this->grad.getColor(this->currenttick, Gradient::LEFT));
    (void)menu->insertItem(pm, "Change left color", this, SLOT(chooseTickColorLeft()));

    pm.fill(this->grad.getColor(this->currenttick, Gradient::RIGHT));
    (void)menu->insertItem(pm, "Change right color", this, SLOT(chooseTickColorRight()));

    menu->insertSeparator();

    const bool lefteqright = this->grad.leftEqualsRight(this->currenttick);

    pm.fill(this->grad.getColor(this->currenttick, Gradient::LEFT));
    id = menu->insertItem(pm, "Copy left color to right", this, SLOT(copyTickColorLeft()));
    if (lefteqright) { menu->setItemEnabled(id, FALSE); }

    pm.fill(this->grad.getColor(this->currenttick, Gradient::RIGHT));
    id = menu->insertItem(pm, "Copy right color to left", this, SLOT(copyTickColorRight()));
    if (lefteqright) { menu->setItemEnabled(id, FALSE); }

    menu->insertSeparator();

    id = menu->insertItem("Delete tick", this, SLOT(deleteTick()));
    id = menu->insertItem("Center tick", this, SLOT(centerTick()));
  }
}