/*!
  Expand the selected rectangle to minZoomSize() and zoom in
  if accepted.

  \sa accept(), minZoomSize()
*/
bool QwtPlotZoomer::end(bool ok)
{
    ok = QwtPlotPicker::end(ok);
    if (!ok)
        return false;

    QwtPlot *plot = QwtPlotZoomer::plot();
    if ( !plot )
        return false;

    const QwtPolygon &pa = selection();
    if ( pa.count() < 2 )
        return false;

    QRect rect = QRect(pa[0], pa[int(pa.count() - 1)]);
#if QT_VERSION < 0x040000
    rect = rect.normalize();
#else
    rect = rect.normalized();
#endif


    QwtDoubleRect zoomRect = invTransform(rect).normalized();

    const QwtDoublePoint center = zoomRect.center();
    zoomRect.setSize(zoomRect.size().expandedTo(minZoomSize()));
    zoomRect.moveCenter(center);

    zoom(zoomRect);

    return true;
}
예제 #2
0
JulyUrl::JulyUrl(QWidget *parent, int x, int y, int w, int h, QString link)
	: QLabel(parent)
{
	startRect=QRect(x,y,w,h);
	setGeometry(startRect);
	zoomTimer = new QTimer(this);
	connect(zoomTimer,SIGNAL(timeout()),this,SLOT(zoom()));
	udNormalFont=0;
	isAnimating=false;
	add=2;
	text=link;;
	QFont font;
	font.setFamily("Arial");
	font.setPixelSize(46);
	font.setStretch(60);
	double textWidth=QFontMetrics(font).width(link);
	pixmap1 = QPixmap(400,100);
	pixmap1.fill(Qt::transparent);
	QPainter painter(&pixmap1);
	painter.setPen(Qt::blue);
	painter.setFont(font);
	painter.drawText(QRectF(0,0,400,100),Qt::AlignCenter,text);
	pixmap2=pixmap1;
	QPixmap line(textWidth,4);
	line.fill(Qt::blue);
	painter.drawPixmap((400-textWidth)/2,84,line);
	setPixmap(pixmap1);
	notPressing=true;
	setScaledContents(true);	
}
/**
 * Mouse active motion callback (when button is pressed)
 */
void MouseMotionCallback(int x, int y)
{
    if (gPreviousMouseX >= 0 && gPreviousMouseY >= 0)
    {
        //compute delta
        float deltaX = x-gPreviousMouseX;
        float deltaY = y-gPreviousMouseY;
        gPreviousMouseX = x;
        gPreviousMouseY = y;
        
        float zoomSensitivity = 0.2f;
        float rotateSensitivity = 0.5f;
        
        //orbit or zoom
        if (gMouseButton == GLUT_LEFT_BUTTON)
        {
            AdjustCameraAzimuthBy(-deltaX*rotateSensitivity);
            AdjustCameraElevationBy(-deltaY*rotateSensitivity);
            
        } else if (gMouseButton == GLUT_RIGHT_BUTTON)
        {
            STVector3 zoom(0,0,deltaX);
            AdjustCameraTranslationBy(zoom * zoomSensitivity);
        }
        
    } else
    {
        gPreviousMouseX = x;
        gPreviousMouseY = y;
    }
    
}
예제 #4
0
QUndoCommand* Navigator::mouseMoveEvent(QMouseEvent* e)
{
  switch (m_currentAction) {
    case Rotation: {
      QPoint delta = e->pos() - m_lastMousePosition;
      rotate(m_renderer->scene().center(), delta.y(), delta.x(), 0);
      e->accept();
      break;
    }
    case Translation: {
      Vector2f fromScreen(m_lastMousePosition.x(), m_lastMousePosition.y());
      Vector2f toScreen(e->localPos().x(), e->localPos().y());
      translate(m_renderer->scene().center(), fromScreen, toScreen);
      e->accept();
      break;
    }
    case ZoomTilt: {
      QPoint delta = e->pos() - m_lastMousePosition;
      // Tilt
      rotate(m_renderer->scene().center(), 0, 0, delta.x());
      // Zoom
      zoom(m_renderer->scene().center(), delta.y());
      e->accept();
      break;
    }
    default:;
  }

  m_lastMousePosition = e->pos();

  if (e->isAccepted())
    emit updateRequested();

  return nullptr;
}
예제 #5
0
/** We received a request to paint the drawing area.
 */
void CSailDispLabel::paintEvent( QPaintEvent * )
{
    // erase viewport
    CSailPainter painter( this );
    QRect rect = painter.viewport();
    painter.eraseRect(rect);

    // check if the window was resized since last redraw
    if ( wasResized )
    {
        setViewRect(painter.viewRect());
        wasResized = 0;
    }

    // set coordinate system to match the logical viewport
    painter.setWindow(logicalRect());
    painter.setFontSize(8, zoom());
    painter.setPenWidth();

    // draw the sail
    const CPanelGroup obj = dispObject();
    painter.draw(obj);

    // optionally draw labels
    if (drawLabels)
    {
        painter.drawLabels(obj);
        /*/ draw markers on edges for test purpose
        painter.setFontSize(10, zoom/10);
        painter.drawMarkers(obj);
        */
    }
    //
    painter.end();
}
예제 #6
0
int
ged_zoom(struct ged *gedp, int argc, const char *argv[])
{
    int ret;
    double sf = 1.0;

    GED_CHECK_VIEW(gedp, GED_ERROR);
    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);

    /* initialize result */
    bu_vls_trunc(gedp->ged_result_str, 0);

    /* must be wanting help */
    if (argc != 2) {
	bu_vls_printf(gedp->ged_result_str, "Usage: %s scale_factor", argv[0]);
	return (argc == 1) ? GED_HELP : GED_ERROR;
    }

    /* get the scale factor */
    ret = sscanf(argv[1], "%lf", &sf);
    if (ret != 1 || sf < SMALL_FASTF || sf > INFINITY) {
	bu_vls_printf(gedp->ged_result_str, "ERROR: bad scale factor [%s]", argv[1]);
	return GED_ERROR;
    }

    return zoom(gedp, sf);
}
예제 #7
0
void CommandInterpreter::handleCommand(TACommand command)
{
	XTestGrabControl(display, True);

    printf("COMMAND: %i, %i, %i, %i, %f\n", command.type, command.touch, command.xDifference, command.yDifference, command.zoomValue);
	switch(command.type)
	{		
		case TACommandTypeZoom:
			zoom(command);
			break;
		case TACommandTypePan:
			pan(command);
			break;
		case TACommandTypeRotate:
			rotate(command);
			break;
		default:
		break;
	}
	
	XSync(display, 0);
	
	XTestGrabControl(display, False);
	usleep(100);
}
예제 #8
0
파일: Dessin.cpp 프로젝트: alhajjar/PFE
/**
 * \fn bool Dessin::on_event_happend (GdkEvent* event)
 * \brief Méthode gérant les évènements de la souris
 * \param event Evènement (appui souris, mouvement en restant appuyé ou relâchement de la souris) ayant provoqué l'instanciation de la méthode
 * \return Indicateur de bon deroulement de la méthode
 */
bool Dessin::on_event_happend(GdkEvent* event){
	if (event->type == GDK_BUTTON_PRESS) {
		x = event->button.x;
		y = event->button.y;
		type_bouton = event->button.button;
	}
	if (event->type == GDK_MOTION_NOTIFY) {
		dessiner_cadre_selection_zoom(event->button.x, event->button.y);
	}
	if (event->type == GDK_BUTTON_RELEASE) {
		switch (type_bouton){
			case 1:
				zoom(event->button.x, event->button.y);
				break;
			case 2:
				dezoom();
				break;
			case 3:
				dezoom();
				break;
			default: 
				break;
		}
		type_bouton = 0;
	}
	return false;
}
예제 #9
0
void Camera::mouseInput( int x, int y, int Button, int State)
{
    if(State == GLUT_DOWN)
    {
        if(m_LastMouseX==-1) m_LastMouseX = x;
        if(m_LastMouseY==-1) m_LastMouseY = y;
        
        if( Button == GLUT_LEFT_BUTTON )
        {
            rotate((float)x, (float)y );
        }
        else if( Button == GLUT_RIGHT_BUTTON)
        {
            pan( (float)(m_LastMouseX-x)*0.01f, (float)(m_LastMouseY-y)*0.01f );
        }
        else if( Button == GLUT_MIDDLE_BUTTON)
        {
            zoom( (float)(m_LastMouseY-y)*0.01f );
            
        }
    }
    else
    {
        m_Position += m_Panning + m_Zoom + m_Rotation;
        m_Target += m_Panning;
        m_Panning = Vector(0,0,0);
        m_Zoom = Vector(0,0,0);
        m_Rotation = Vector(0,0,0);
        m_LastMouseX = -1;
        m_LastMouseY = -1;

    }
}
예제 #10
0
SlippyCoordinates SlippyCoordinates::operator+(QPoint offset)
{
    SlippyCoordinates res(zoom(), x(), y());

    res.settilePos(res.tilePos()+ offset);
    return res;
}
void
GUIDanielPerspectiveChanger::onMouseMove(void*data) {
    FXEvent* e = (FXEvent*) data;
    myCallback.setWindowCursorPosition(e->win_x, e->win_y);
    int xdiff = myMouseXPosition - e->win_x;
    int ydiff = myMouseYPosition - e->win_y;
    switch (myMouseButtonState) {
    case MOUSEBTN_LEFT:
        move(xdiff, ydiff);
        if (xdiff!=0||ydiff!=0) {
            myMoveOnClick = true;
        }
        break;
    case MOUSEBTN_RIGHT:
        zoom(ydiff);
        rotate(xdiff);
        if (xdiff!=0||ydiff!=0) {
            myMoveOnClick = true;
        }
        break;
    default:
        if (xdiff!=0||ydiff!=0) {
            myCallback.updateToolTip();
        }
        break;
    }
    myMouseXPosition = e->win_x;
    myMouseYPosition = e->win_y;
}
예제 #12
0
void TWindow::handleEvent(TEvent &event) {
   TRect  limits;
   TPoint min, max;

   TGroup::handleEvent(event);
   if (event.what== evCommand)
      switch (event.message.command) {
         case  cmResize:
            if ((flags & (wfMove | wfGrow)) != 0) {
               limits = owner->getExtent();
               sizeLimits(min, max);
               dragView(event, dragMode | (flags & (wfMove | wfGrow)),
                        limits, min, max);
               clearEvent(event);
            }
            break;
         case  cmClose:
            if ((flags & wfClose) != 0 &&
               (event.message.infoPtr == 0 || event.message.infoPtr == this))
            {
               clearEvent(event);
               if ((state & sfModal) == 0)
                  close();
               else {
                  event.what = evCommand;
                  event.message.command = cmCancel;
                  putEvent(event);
                  clearEvent(event);
               }
            }
            break;
         case  cmZoom:
            if ((flags & wfZoom) != 0 &&
               (event.message.infoPtr == 0 || event.message.infoPtr == this))
            {
               zoom();
               clearEvent(event);
            }
            break;
      }
   else if (event.what == evKeyDown)
      switch (event.keyDown.keyCode) {
         case  kbTab:
            focusNext(False);
            clearEvent(event);
            break;
         case  kbShiftTab:
            focusNext(True);
            clearEvent(event);
            break;
      }
   else if (event.what == evBroadcast &&
            event.message.command == cmSelectWindowNum &&
            event.message.infoInt == number &&
            (options & ofSelectable) != 0
           ) {
      select();
      clearEvent(event);
   }
}
예제 #13
0
/*!
  Expand the selected rectangle to minZoomSize() and zoom in
  if accepted.

  \sa accept(), minZoomSize()
*/
bool QwtPlotZoomer::end( bool ok )
{
    ok = QwtPlotPicker::end( ok );
    if ( !ok )
        return false;

    QwtPlot *plot = QwtPlotZoomer::plot();
    if ( !plot )
        return false;

    const QPolygon &pa = selection();
    if ( pa.count() < 2 )
        return false;

    QRect rect = QRect( pa[0], pa[int( pa.count() - 1 )] );
    rect = rect.normalized();

    QRectF zoomRect = invTransform( rect ).normalized();

    const QSizeF minSize = minZoomSize();
    if ( minSize.isValid() )
    {
        const QPointF center = zoomRect.center();
        zoomRect.setSize( zoomRect.size().expandedTo( minZoomSize() ) );
        zoomRect.moveCenter( center );
    }

    zoom( zoomRect );

    return true;
}
예제 #14
0
파일: myApp.cpp 프로젝트: hmpbmp/CGLabs
//Update frame
void myApp::update()
{
  // Call predecessor update
  cglApp::update();

  // Process keyboard
  float dx = 0.0f;
  float dy = 0.0f;
  float dr = 0.0f;
  if (m_keysPressed[VK_LEFT])
    dx -= s_rKbd2Rotate * m_timer.getDelta();
  if (m_keysPressed[VK_RIGHT])
    dx += s_rKbd2Rotate * m_timer.getDelta();
  if (m_keysPressed[VK_UP])
    dy -= s_rKbd2Rotate * m_timer.getDelta();
  if (m_keysPressed[VK_DOWN])
    dy += s_rKbd2Rotate * m_timer.getDelta();
  if (m_keysPressed[VK_SUBTRACT])
    dr -= s_rKbd2Zoom * m_timer.getDelta();
  if (m_keysPressed[VK_ADD])
    dr += s_rKbd2Zoom * m_timer.getDelta();

  rotateObject(dx, dy);
  zoom(dr);

  /*
  float rI = 0.0f;
  for (int i = 0; i < 10000000;i++)
  rI += sin(i);*/
}
예제 #15
0
void
GUIDanielPerspectiveChanger::onMouseMove(void* data) {
    FXEvent* e = (FXEvent*) data;
    myCallback.setWindowCursorPosition(e->win_x, e->win_y);
    const int xdiff = myMouseXPosition - e->win_x;
    const int ydiff = myMouseYPosition - e->win_y;
    const bool moved = xdiff != 0 || ydiff != 0;
    const bool pastDelay = !gSchemeStorage.getDefault().gaming && FXThread::time() > (myMouseDownTime + myDragDelay);
    switch (myMouseButtonState) {
        case MOUSEBTN_LEFT:
            if (pastDelay) {
                move(xdiff, ydiff);
                if (moved) {
                    myMoveOnClick = true;
                }
            }
            break;
        case MOUSEBTN_RIGHT:
            if (pastDelay) {
                zoom(1 + 10.0 * ydiff / myCallback.getWidth());
                rotate(xdiff);
                if (moved) {
                    myMoveOnClick = true;
                }
            }
            break;
        default:
            if (moved) {
                myCallback.updateToolTip();
            }
            break;
    }
    myMouseXPosition = e->win_x;
    myMouseYPosition = e->win_y;
}
예제 #16
0
KPrView::~KPrView()
{
    saveZoomConfig(zoomMode(), zoom());
    delete m_presentationMode;
    delete m_notesMode;
    delete m_slidesSorterMode;
}
예제 #17
0
void PlotZoomer::zoomSync(const QRectF &rect)
{
  if (!_ignoreSync)
  {
//    if (QwtPlotZoomer *zoomer = qobject_cast<QwtPlotZoomer *>(sender()))
//    {
//      setZoomStack(zoomer->zoomStack(), zoomer->zoomRectIndex());
//    }
//    else
//    {
//      zoom(rect);
//    }
    // Adjust the zoom rect according to the zoom mode.
    QRectF adjustedRect = rect;
    switch (_zoomMode)
    {
    default:
    case ZoomBoth:
      break;
    case ZoomX:
      adjustedRect.setY(zoomRect().y());
      adjustedRect.setHeight(zoomRect().height());
      break;
    case ZoomY:
      adjustedRect.setX(zoomRect().x());
      adjustedRect.setWidth(zoomRect().width());
      break;
    }
    zoom(adjustedRect);
  }
}
예제 #18
0
void		Camera::update(UNUSED gdl::Clock const& clock, Binput& input)
{
  bomber::Event event;

  if (input._default.getMouseWheel().y)
    zoom(0.05 * input._default.getMouseWheel().y);
  if (input._default.getKey(SDL_BUTTON_LEFT))
    rotate(glm::vec3(0, 1, 0), static_cast<float>(input._default.getMouseDelta().x));
  if (input._default.getKey(SDL_BUTTON_RIGHT))
    {
      glm::vec3	delta(input._default.getMouseDelta().x * -0.1, input._default.getMouseDelta().y * 0.1, 0);
      _target += delta;
    }
  if (input._default.getKey(SDLK_KP_PLUS) || input.handleEvent(event, bomber::Event::TriggerLT))
    rotate(glm::vec3(-1, 0, 0), 0.10f);
  if (input._default.getKey(SDLK_KP_MINUS) || input.handleEvent(event, bomber::Event::TriggerRT))
    rotate(glm::vec3(1, 0, 0), 0.10f);
  if (input._default.getKey(SDLK_UP) || input.handleEvent(event, bomber::Event::JoyRightUp))
    move(glm::vec3(0, 0, 1));
  if (input._default.getKey(SDLK_DOWN) || input.handleEvent(event, bomber::Event::JoyRightDown))
    move(glm::vec3(0, 0, -1));
  if (input._default.getKey(SDLK_LEFT) || input.handleEvent(event, bomber::Event::JoyRightLeft))
    move(glm::vec3(1, 0, 0));
  if (input._default.getKey(SDLK_RIGHT) || input.handleEvent(event, bomber::Event::JoyRightRight))
    move(glm::vec3(-1, 0, 0));
  if (_position == _target)
    _target += glm::vec3(1, 1, 1);
  refreshPosition();
}
예제 #19
0
파일: stoi.c 프로젝트: hikkary/fdf_final
t_p		*ft_posxy(t_p *f, char ***t, int l, int h)
{
	int i;

	i = 0;
	f = zoom(f);
	while (t[h])
	{
		while (t[h][l])
		{
			if (!(f->m[h][l] = (int *)malloc(sizeof(int) * 1)))
				exit(EXIT_FAILURE);
			if (ft_atoi(t[h][l]) > 100)
				ft_big();
			isdig(t[h][l]);
			f->m[h][l][0] = ft_atoi(t[h][l]);
			f->pos[h][l] = (int *)malloc(sizeof(int) * 1);
			f->posy[h][l] = (int *)malloc(sizeof(int) * 1);
			f->pos[h][l][0] = l * f->zoom + f->h / 25 + h * f->zoom;
			f->posy[h][l][0] = h * f->zoomy + f->l / 4 - f->m[h][l][0] * 5;
			l++;
			i++;
		}
		l = 0;
		h++;
	}
	return (f);
}
/* Function: keyboardKeys
 * Description: Reads keyboard input from user.
 * Input: unsigned char key - ASCII value of the key pressed.
 *		  int x - X-position
 *		  int y - Y-position
 * Output: None
 */
void keyboardKeys(unsigned char key, int x, int y) 
{
	switch(tolower(key))
	{
		case 27:
			exit(0);
			break;
		case 'z':
			zoom(-1, camFol);
			break;
		case 'x':
			zoom(1, camFol);
			break;
		case ' ':
			saveScreenToFile = 1 - saveScreenToFile;
		case 'w':
			if (camFol == 0)
				cameraFreeMove(0);
			break;
		case 's':
			if (camFol == 0)
				cameraFreeMove(1);
			break;
		case 'q':
			if (camFol == 0)
				cameraFreeMove(2);
			break;
		case 'e':
			if (camFol == 0)
				cameraFreeMove(3);
			break;
		case 'd':
			if (camFol == 0)
				cameraFreeMove(4);
			break;
		case 'a':
			if (camFol == 0)
				cameraFreeMove(5);
			break;
		case 'f':
			camFol = 1 - camFol;
			break;
		case 'p':
			saveScreenToFile = 1 - saveScreenToFile;
				break;
	} //end switch
} //end keyboardKeys
예제 #21
0
bool PlotZoomer::end(bool ok)
{
  // Code here is taken from QwtPlotZoomer. The only modification is around the _zoomMode handling.
  ok = QwtPlotPicker::end(ok);
  if (!ok)
  {
    return false;
  }

  QwtPlot *plot = QwtPlotZoomer::plot();
  if (!plot)
  {
    return false;
  }

  const QPolygon &pa = selection();
  if (pa.count() < 2)
  {
    return false;
  }

  QRect rect = QRect(pa[0], pa[int(pa.count() - 1)]);
  rect = rect.normalized();

  QRectF currentZoomRect = zoomRect();
  QRectF zoomRect = invTransform(rect).normalized();

  switch (_zoomMode)
  {
  default:
  case ZoomBoth:
    // nothing.
    break;

  case ZoomX:
    // Maintain current zoom y and height.
    zoomRect.setY(currentZoomRect.y());
    zoomRect.setHeight(currentZoomRect.height());
    break;

  case ZoomY:
    // Maintain current zoom x and width.
    zoomRect.setX(currentZoomRect.x());
    zoomRect.setWidth(currentZoomRect.width());
    break;
  }

  const QSizeF minSize = minZoomSize();
  if (minSize.isValid())
  {
    const QPointF center = zoomRect.center();
    zoomRect.setSize(zoomRect.size().expandedTo(minZoomSize()));
    zoomRect.moveCenter(center);
  }

  zoom(zoomRect);

  return true;
}
예제 #22
0
/**
  * Process the mouse button release event.
  */
void InputControllerMoveUnwrapped::mouseReleaseEvent(QMouseEvent *)
{
    if ( m_isButtonPressed )
    {
        emit zoom();
    }
    m_isButtonPressed = false;
}
예제 #23
0
bool uiGeoscapeNode::onScroll (uiNode_t* node, int deltaX, int deltaY)
{
    bool down = deltaY > 0;
    if (deltaY == 0)
        return false;
    zoom(node, down);
    return true;
}
예제 #24
0
void GraphicsView::wheelEvent( QWheelEvent *event )
{
	QPoint numDegrees = event->angleDelta()/8;
	QPoint numSteps = numDegrees/15;
	QPoint hoverPos = event->pos();
	QPointF scenePos = mapToScene(hoverPos);
	emit zoom(numSteps.y(), scenePos);
}
예제 #25
0
void PlotZoomer::widgetWheelEvent(QWheelEvent *event)
{
  if (event->delta())
  {
    int numSteps = event->delta() > 0 ? 1 : -1;
    zoom(numSteps);
  }
}
예제 #26
0
 void TOPPASWidget::keyPressEvent(QKeyEvent * e)
 {
   if (e->key() == Qt::Key_C && e->modifiers() == Qt::ControlModifier)
   {
     scene_->copySelected();
     e->accept();
   }
   else if (e->key() == Qt::Key_X && e->modifiers() == Qt::ControlModifier)
   {
     scene_->copySelected();
     scene_->removeSelected();
     e->accept();
   }
   else if (e->key() == Qt::Key_V && e->modifiers() == Qt::ControlModifier)
   {
     scene_->paste();
     e->accept();
   }
   else if (e->key() == Qt::Key_Control)
   {
     setDragMode(QGraphicsView::RubberBandDrag);
     //color of hovering edge may change
     TOPPASEdge* hover_edge = scene_->getHoveringEdge();
     if (hover_edge) hover_edge->update();
     e->accept();
   }
   else if (e->key() == Qt::Key_Delete || e->key() == Qt::Key_Backspace)
   {
     scene_->removeSelected();
     e->accept();
   }
   else if (e->key() == Qt::Key_Plus)
   {
     zoom(false);
     e->accept();
   }
   else if (e->key() == Qt::Key_Minus)
   {
     zoom(true);
     e->accept();
   }
   else
   {
     e->ignore();
   }
 }
예제 #27
0
void wxFrameworkGLCanvas::OnMouseWheel(wxMouseEvent &event)
{
	float dY;

	dY = -(event.m_wheelRotation / 120.);

	zoom((dY / 160.0), (dY * 5.0));
}
lib_test_client::lib_test_client(const string &filename, visualizer *pvis, draw_scope *pscope)
  : base_visualizer_client(pvis, pscope)
  , r(filename)
{
    pgraph_ = &r.get_graph();
    g_desc = upload_graph(*pgraph_);
    zoom(r.get_mins(), r.get_maxs());
}
int QwtPlotZoomer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QwtPlotPicker::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: zoomed((*reinterpret_cast< const QwtDoubleRect(*)>(_a[1]))); break;
        case 1: moveBy((*reinterpret_cast< double(*)>(_a[1])),(*reinterpret_cast< double(*)>(_a[2]))); break;
        case 2: move((*reinterpret_cast< double(*)>(_a[1])),(*reinterpret_cast< double(*)>(_a[2]))); break;
        case 3: zoom((*reinterpret_cast< const QwtDoubleRect(*)>(_a[1]))); break;
        case 4: zoom((*reinterpret_cast< int(*)>(_a[1]))); break;
        }
        _id -= 5;
    }
    return _id;
}
예제 #30
0
void TopLevel::zoomout()
{
  if (oz < MAXZOOM && Image->width >= 256)
  {
    ++oz;
    zoom( oz );
  }
}