C++ composition函数代码示例

void QgsComposerView::selectInvert()
{
  if ( !composition() )
  {
    return;
  }

  //check all items in composer
  QList<QGraphicsItem *> itemList = composition()->items();
  QList<QGraphicsItem *>::iterator itemIt = itemList.begin();
  for ( ; itemIt != itemList.end(); ++itemIt )
  {
    QgsComposerItem* mypItem = dynamic_cast<QgsComposerItem *>( *itemIt );
    QgsPaperItem* paperItem = dynamic_cast<QgsPaperItem*>( *itemIt );
    if ( mypItem && !paperItem )
    {
      //flip selected state for items (and deselect any locked items)
      if ( mypItem->selected() || mypItem->positionLock() )
      {

        mypItem->setSelected( false );
      }
      else
      {
        mypItem->setSelected( true );
        emit selectedItemChanged( mypItem );
      }
    }
  }
}

void QgsComposerView::pasteItems( PasteMode mode )
{
  if ( !composition() )
  {
    return;
  }

  QDomDocument doc;
  QClipboard *clipboard = QApplication::clipboard();
  if ( doc.setContent( clipboard->mimeData()->data( "text/xml" ) ) )
  {
    QDomElement docElem = doc.documentElement();
    if ( docElem.tagName() == "ComposerItemClipboard" )
    {
      if ( composition() )
      {
        QPointF pt;
        if ( mode == PasteModeCursor )
        {
          // place items at cursor position
          pt = mapToScene( mapFromGlobal( QCursor::pos() ) );
        }
        else
        {
          // place items in center of viewport
          pt = mapToScene( viewport()->rect().center() );
        }
        bool pasteInPlace = ( mode == PasteModeInPlace );
        composition()->addItemsFromXML( docElem, doc, 0, true, &pt, pasteInPlace );
      }
    }
  }
}

void QgsComposerLegend::doUpdateFilterByMap()
{
  if ( mComposerMap )
    mLegendModel2->setLayerStyleOverrides( mComposerMap->layerStyleOverrides() );
  else
    mLegendModel2->setLayerStyleOverrides( QMap<QString, QString>() );


  bool filterByExpression = QgsLayerTreeUtils::hasLegendFilterExpression( *( mCustomLayerTree ? mCustomLayerTree : QgsProject::instance()->layerTreeRoot() ) );

  if ( mComposerMap && ( mLegendFilterByMap || filterByExpression || mInAtlas ) )
  {
    int dpi = mComposition->printResolution();

    QgsRectangle requestRectangle;
    mComposerMap->requestedExtent( requestRectangle );

    QSizeF theSize( requestRectangle.width(), requestRectangle.height() );
    theSize *= mComposerMap->mapUnitsToMM() * dpi / 25.4;

    QgsMapSettings ms = mComposerMap->mapSettings( requestRectangle, theSize, dpi );

    QgsGeometry filterPolygon;
    if ( mInAtlas )
    {
      filterPolygon = composition()->atlasComposition().currentGeometry( composition()->mapSettings().destinationCrs() );
    }
    mLegendModel2->setLegendFilter( &ms, /* useExtent */ mInAtlas || mLegendFilterByMap, filterPolygon, /* useExpressions */ true );
  }
  else
    mLegendModel2->setLegendFilterByMap( 0 );
}

void QgsComposerView::addShape( Tool currentTool )
{
  QgsComposerShape::Shape shape = QgsComposerShape::Ellipse;

  if ( currentTool == AddRectangle )
    shape = QgsComposerShape::Rectangle;
  else if ( currentTool == AddTriangle )
    shape = QgsComposerShape::Triangle;

  if ( !mRubberBandItem || mRubberBandItem->rect().width() < 0.1 || mRubberBandItem->rect().width() < 0.1 )
  {
    scene()->removeItem( mRubberBandItem );
    delete mRubberBandItem;
    mRubberBandItem = 0;
    return;
  }
  if ( composition() )
  {
    QgsComposerShape* composerShape = new QgsComposerShape( mRubberBandItem->transform().dx(), mRubberBandItem->transform().dy(), mRubberBandItem->rect().width(), mRubberBandItem->rect().height(), composition() );
    composerShape->setShapeType( shape );
    composition()->addComposerShape( composerShape );
    scene()->removeItem( mRubberBandItem );
    delete mRubberBandItem;
    mRubberBandItem = 0;
    emit actionFinished();
    composition()->pushAddRemoveCommand( composerShape, tr( "Shape added" ) );
  }
}

QPointF QgsComposerItem::pagePos() const
{
  QPointF p = pos();
  double h = composition()->paperHeight() + composition()->spaceBetweenPages();
  p.ry() -= ( page() - 1 ) * h;
  return p;
}

void QgsComposerView::addShape( Tool currentTool )
{
  QgsComposerShape::Shape shape = QgsComposerShape::Ellipse;

  if ( currentTool == AddRectangle )
    shape = QgsComposerShape::Rectangle;
  else if ( currentTool == AddTriangle )
    shape = QgsComposerShape::Triangle;

  if ( !mRubberBandItem || ( mRubberBandItem->rect().width() < 0.1 && mRubberBandItem->rect().height() < 0.1 ) )
  {
    removeRubberBand();
    return;
  }
  if ( composition() )
  {
    QgsComposerShape* composerShape = new QgsComposerShape( mRubberBandItem->transform().dx(), mRubberBandItem->transform().dy(), mRubberBandItem->rect().width(), mRubberBandItem->rect().height(), composition() );
    composerShape->setShapeType( shape );
    //new shapes use symbol v2 by default
    composerShape->setUseSymbolV2( true );
    composition()->addComposerShape( composerShape );
    removeRubberBand();

    composition()->clearSelection();
    composerShape->setSelected( true );
    emit selectedItemChanged( composerShape );

    emit actionFinished();
    composition()->pushAddRemoveCommand( composerShape, tr( "Shape added" ) );
  }
}

void QgsComposerItem::setItemPosition( double x, double y, double width, double height, ItemPositionMode itemPoint, bool posIncludesFrame, int page )
{
  double upperLeftX = x;
  double upperLeftY = y;

  if ( page > 0 )
  {
    double h = composition()->paperHeight() + composition()->spaceBetweenPages();
    upperLeftY += ( page - 1 ) * h;
  }

  //store the item position mode
  mLastUsedPositionMode = itemPoint;

  //adjust x-coordinate if placement is not done to a left point
  if ( itemPoint == UpperMiddle || itemPoint == Middle || itemPoint == LowerMiddle )
  {
    upperLeftX -= width / 2.0;
  }
  else if ( itemPoint == UpperRight || itemPoint == MiddleRight || itemPoint == LowerRight )
  {
    upperLeftX -= width;
  }

  //adjust y-coordinate if placement is not done to an upper point
  if ( itemPoint == MiddleLeft || itemPoint == Middle || itemPoint == MiddleRight )
  {
    upperLeftY -= height / 2.0;
  }
  else if ( itemPoint == LowerLeft || itemPoint == LowerMiddle || itemPoint == LowerRight )
  {
    upperLeftY -= height;
  }

  if ( posIncludesFrame )
  {
    //adjust position to account for frame size

    if ( mItemRotation == 0 )
    {
      upperLeftX += estimatedFrameBleed();
      upperLeftY += estimatedFrameBleed();
    }
    else
    {
      //adjust position for item rotation
      QLineF lineToItemOrigin = QLineF( 0, 0, estimatedFrameBleed(), estimatedFrameBleed() );
      lineToItemOrigin.setAngle( -45 - mItemRotation );
      upperLeftX += lineToItemOrigin.x2();
      upperLeftY += lineToItemOrigin.y2();
    }

    width -= 2 * estimatedFrameBleed();
    height -= 2 * estimatedFrameBleed();
  }

  setSceneRect( QRectF( upperLeftX, upperLeftY, width, height ) );
}

void float2_param_t::set_value( const Imath::V2f& x)
{
    float time = 1.0f;

    if( composition())
	time = composition()->frame();

    set_value_at_time( x, time);
}

void QgsComposerView::setCurrentTool( QgsComposerView::Tool t )
{
  mCurrentTool = t;

  //update mouse cursor for current tool
  if ( !composition() )
  {
    return;
  }
  switch ( t )
  {
    case QgsComposerView::Pan:
    {
      //lock cursor to prevent composer items changing it
      composition()->setPreventCursorChange( true );
      viewport()->setCursor( Qt::OpenHandCursor );
      break;
    }
    case QgsComposerView::Zoom:
    {
      //lock cursor to prevent composer items changing it
      composition()->setPreventCursorChange( true );
      //set the cursor to zoom in
      QPixmap myZoomQPixmap = QPixmap(( const char ** )( zoom_in ) );
      QCursor zoomCursor = QCursor( myZoomQPixmap, 7, 7 );
      viewport()->setCursor( zoomCursor );
      break;
    }
    case QgsComposerView::AddArrow:
    case QgsComposerView::AddHtml:
    case QgsComposerView::AddMap:
    case QgsComposerView::AddLegend:
    case QgsComposerView::AddLabel:
    case QgsComposerView::AddScalebar:
    case QgsComposerView::AddPicture:
    case QgsComposerView::AddRectangle:
    case QgsComposerView::AddEllipse:
    case QgsComposerView::AddTriangle:
    case QgsComposerView::AddTable:
    {
      //using a drawing tool
      //lock cursor to prevent composer items changing it
      composition()->setPreventCursorChange( true );
      QPixmap myCrosshairQPixmap = QPixmap(( const char ** )( cross_hair_cursor ) );
      QCursor crosshairCursor = QCursor( myCrosshairQPixmap, 8, 8 );
      viewport()->setCursor( crosshairCursor );
      break;
    }
    default:
    {
      //not using pan tool, composer items can change cursor
      composition()->setPreventCursorChange( false );
      viewport()->setCursor( Qt::ArrowCursor );
    }
  }
}

void QgsComposerView::keyPressEvent( QKeyEvent * e )
{
  if ( !composition() )
  {
    return;
  }

  QList<QgsComposerItem*> composerItemList = composition()->selectedComposerItems();
  QList<QgsComposerItem*>::iterator itemIt = composerItemList.begin();

  // increment used for cursor key item movement
  double increment = 1.0;
  if ( e->modifiers() & Qt::ShiftModifier )
  {
    //holding shift while pressing cursor keys results in a big step
    increment = 10.0;
  }

  if ( e->key() == Qt::Key_Left )
  {
    for ( ; itemIt != composerItemList.end(); ++itemIt )
    {
      ( *itemIt )->beginCommand( tr( "Item moved" ), QgsComposerMergeCommand::ItemMove );
      ( *itemIt )->move( -1 * increment, 0.0 );
      ( *itemIt )->endCommand();
    }
  }
  else if ( e->key() == Qt::Key_Right )
  {
    for ( ; itemIt != composerItemList.end(); ++itemIt )
    {
      ( *itemIt )->beginCommand( tr( "Item moved" ), QgsComposerMergeCommand::ItemMove );
      ( *itemIt )->move( increment, 0.0 );
      ( *itemIt )->endCommand();
    }
  }
  else if ( e->key() == Qt::Key_Down )
  {
    for ( ; itemIt != composerItemList.end(); ++itemIt )
    {
      ( *itemIt )->beginCommand( tr( "Item moved" ), QgsComposerMergeCommand::ItemMove );
      ( *itemIt )->move( 0.0, increment );
      ( *itemIt )->endCommand();
    }
  }
  else if ( e->key() == Qt::Key_Up )
  {
    for ( ; itemIt != composerItemList.end(); ++itemIt )
    {
      ( *itemIt )->beginCommand( tr( "Item moved" ), QgsComposerMergeCommand::ItemMove );
      ( *itemIt )->move( 0.0, -1 * increment );
      ( *itemIt )->endCommand();
    }
  }
}

void QgsComposerView::pushAddRemoveCommand( QgsComposerItem* item, const QString& text, QgsAddRemoveItemCommand::State state )
{
  if ( !composition() )
  {
    return;
  }

  QgsAddRemoveItemCommand* c = new QgsAddRemoveItemCommand( state, item, composition(), text );
  connectAddRemoveCommandSignals( c );
  composition()->undoStack()->push( c );
}

void QgsComposerView::setCurrentTool( QgsComposerView::Tool t )
{
  mCurrentTool = t;

  //update mouse cursor for current tool
  if ( !composition() )
  {
    return;
  }
  switch ( t )
  {
    case QgsComposerView::Pan:
    {
      //lock cursor to prevent composer items changing it
      composition()->setPreventCursorChange( true );
      viewport()->setCursor( defaultCursorForTool( Pan ) );
      break;
    }
    case QgsComposerView::Zoom:
    {
      //lock cursor to prevent composer items changing it
      composition()->setPreventCursorChange( true );
      //set the cursor to zoom in
      viewport()->setCursor( defaultCursorForTool( Zoom ) );
      break;
    }
    case QgsComposerView::AddArrow:
    case QgsComposerView::AddHtml:
    case QgsComposerView::AddMap:
    case QgsComposerView::AddLegend:
    case QgsComposerView::AddLabel:
    case QgsComposerView::AddScalebar:
    case QgsComposerView::AddPicture:
    case QgsComposerView::AddRectangle:
    case QgsComposerView::AddEllipse:
    case QgsComposerView::AddTriangle:
    case QgsComposerView::AddTable:
    {
      //using a drawing tool
      //lock cursor to prevent composer items changing it
      composition()->setPreventCursorChange( true );
      viewport()->setCursor( defaultCursorForTool( mCurrentTool ) );
      break;
    }
    default:
    {
      //not using pan tool, composer items can change cursor
      composition()->setPreventCursorChange( false );
      viewport()->setCursor( Qt::ArrowCursor );
    }
  }
}

void QgsLayoutView::deleteSelectedItems()
{
  if ( !currentLayout() )
  {
    return;
  }

#if 0 //TODO
  if ( mCurrentTool == QgsComposerView::EditNodesItem )
  {
    if ( mNodesItemIndex != -1 )
    {
      composition()->beginCommand( mNodesItem, tr( "Remove item node" ) );
      if ( mNodesItem->removeNode( mNodesItemIndex ) )
      {
        composition()->endCommand();
        if ( mNodesItem->nodesSize() > 0 )
        {
          mNodesItemIndex = mNodesItem->selectedNode();
          // setSelectedNode( mNodesItem, mNodesItemIndex );
        }
        else
        {
          mNodesItemIndex = -1;
          mNodesItem = nullptr;
        }
        scene()->update();
      }
      else
      {
        composition()->cancelCommand();
      }
    }
  }
  else
  {
#endif
    const QList<QgsLayoutItem *> selectedItems = currentLayout()->selectedLayoutItems();

    currentLayout()->undoStack()->beginMacro( tr( "Delete Items" ) );
    //delete selected items
    for ( QgsLayoutItem *item : selectedItems )
    {
      currentLayout()->removeLayoutItem( item );
    }
    currentLayout()->undoStack()->endMacro();
    currentLayout()->project()->setDirty( true );

#if 0
  }
#endif
}

void QgsComposerView::keyReleaseEvent( QKeyEvent * e )
{
  if ( e->key() == Qt::Key_Space && !e->isAutoRepeat() && mPanning )
  {
    //end of panning with space key
    mPanning = false;

    //reset cursor
    if ( mCurrentTool == Pan )
    {
      viewport()->setCursor( Qt::OpenHandCursor );
    }
    else
    {
      if ( composition() )
      {
        //allow cursor changes again
        composition()->setPreventCursorChange( false );
      }
      viewport()->setCursor( Qt::ArrowCursor );
    }
    return;
  }
  else if ( e->key() == Qt::Key_Space && !e->isAutoRepeat() && mTemporaryZoomStatus != QgsComposerView::Inactive )
  {
    //temporary keyboard-based zoom tool is active and space key has been released
    if ( mMarqueeZoom )
    {
      //currently in the middle of a marquee operation, so don't switch tool back immediately
      //instead, wait until mouse button has been released before switching tool back
      mTemporaryZoomStatus = QgsComposerView::ActiveUntilMouseRelease;
    }
    else
    {
      //switch tool back
      mTemporaryZoomStatus = QgsComposerView::Inactive;
      setCurrentTool( mPreviousTool );
    }
  }
  else if ( mCurrentTool == QgsComposerView::Zoom )
  {
    //if zoom tool is active, respond to changes in the shift key status and update cursor accordingly
    if ( ! e->isAutoRepeat() )
    {
      QPixmap myZoomQPixmap = QPixmap(( const char ** )( e->modifiers() & Qt::ShiftModifier ? zoom_out : zoom_in ) );
      QCursor zoomCursor = QCursor( myZoomQPixmap, 7, 7 );
      viewport()->setCursor( zoomCursor );
    }
    return;
  }
}

void corner_pin_node_t::param_changed( param_t *p, param_t::change_reason reason)
{
	RAMEN_ASSERT( composition());
	
	if( reason == param_t::user_edited && p == &param( "apply_track"))
	{		
		const tracker_node_t *tracker = ui::apply_corner_track_dialog_t::instance().exec();
		
		if( tracker)
		{
			float2_param_t *topleft		= dynamic_cast<float2_param_t*>( &param( "topleft"));
			float2_param_t *topright	= dynamic_cast<float2_param_t*>( &param( "topright"));
			float2_param_t *botleft		= dynamic_cast<float2_param_t*>( &param( "botleft"));
			float2_param_t *botright	= dynamic_cast<float2_param_t*>( &param( "botright"));
			
			float start_frame = composition()->start_frame();
			float end_frame = composition()->end_frame();
			
			param_set().begin_edit();
			
			for( float frame = start_frame; frame <= end_frame; frame += 1.0f)
			{
				boost::optional<Imath::V2f> p = tracker->tracker_pos( 0, frame);
				
				if( p)
					topleft->set_absolute_value_at_frame( p.get(), frame);

				p = tracker->tracker_pos( 1, frame);
				
				if( p)
					topright->set_absolute_value_at_frame( p.get(), frame);
				
				p = tracker->tracker_pos( 2, frame);

				if( p)
					botright->set_absolute_value_at_frame( p.get(), frame);
				
				p = tracker->tracker_pos( 3, frame);
				
				if( p)
					botleft->set_absolute_value_at_frame( p.get(), frame);
			}
			
			param_set().end_edit();
			update_widgets();
		}
	}
}