C++ calculateSize函数代码示例

void UIFont::setText(const char* text)
{
	m_Text.assign(text);
	//Calculate the text's size based on the font data
	calculateSize();

}

int PacketHandler::calculateCryptedSize(int dataLen)
{
	int align = dataLen % 8;
	if (align)
		dataLen = dataLen + 8 - align;
	return (calculateSize(dataLen));
}

void ewol::widget::Container::setOffset(const vec2& _newVal) {
	if (m_offset != _newVal) {
		ewol::Widget::setOffset(_newVal);
		// recalculate the new sise and position of sub widget ...
		calculateSize(m_size);
	}
}

void CTECList<Type>:: addToFront(const Type& value)
{
	ArrayNode<Type> * newNode = new ArrayNode<Type>(value, head);
	head = newNode;

	calculateSize();
}

    //-----------------------------------------------------------------------------
    Image& Image::loadDynamicImage( uchar* pData, uint32 uWidth, uint32 uHeight,
        uint32 depth,
        PixelFormat eFormat, bool autoDelete, 
        size_t numFaces, uint8 numMipMaps)
    {

        freeMemory();
        // Set image metadata
        mWidth = uWidth;
        mHeight = uHeight;
        mDepth = depth;
        mFormat = eFormat;
        mPixelSize = static_cast<uchar>(PixelUtil::getNumElemBytes( mFormat ));
        mNumMipmaps = numMipMaps;
        mFlags = 0;
        // Set flags
        if (PixelUtil::isCompressed(eFormat))
            mFlags |= IF_COMPRESSED;
        if (mDepth != 1)
            mFlags |= IF_3D_TEXTURE;
        if(numFaces == 6)
            mFlags |= IF_CUBEMAP;
        if(numFaces != 6 && numFaces != 1)
            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, 
            "Number of faces currently must be 6 or 1.", 
            "Image::loadDynamicImage");

        mBufSize = calculateSize(numMipMaps, numFaces, uWidth, uHeight, depth, eFormat);
        mBuffer = pData;
        mAutoDelete = autoDelete;

        return *this;

    }

Type CTECList<Type>::removeFromEnd()
{
	//defencive code
	assert(this->size > 0);
	Type returnValue;
	ArrayNode<Type> * newTail = new ArrayNode<Type>();
	ArrayNode<Type> * current = ArrayNode<Type>();

	if(size == 1)
	{
		ArrayNode<Type> * toRemove = tail;
		returnValue = removeFromFront();
		tail = nullptr;
	}

	else
	{
ArrayNode<Type> * current = head;
for(int index = 0; index < size-1; index ++)
{
	current = current->getNext();
}


	returnValue = tail->getValue();
		delete tail;
		current = newTail;
		calculateSize();
	current->setNext(nullptr);
	}



	return returnValue;
}

void QgsEllipseSymbolLayerV2::preparePath( const QString& symbolName, QgsSymbolV2RenderContext& context, double* scaledWidth, double* scaledHeight, const QgsFeature* )
{
  mPainterPath = QPainterPath();

  QSizeF size = calculateSize( context, scaledWidth, scaledHeight );

  if ( symbolName == "circle" )
  {
    mPainterPath.addEllipse( QRectF( -size.width() / 2.0, -size.height() / 2.0, size.width(), size.height() ) );
  }
  else if ( symbolName == "rectangle" )
  {
    mPainterPath.addRect( QRectF( -size.width() / 2.0, -size.height() / 2.0, size.width(), size.height() ) );
  }
  else if ( symbolName == "cross" )
  {
    mPainterPath.moveTo( 0, -size.height() / 2.0 );
    mPainterPath.lineTo( 0, size.height() / 2.0 );
    mPainterPath.moveTo( -size.width() / 2.0, 0 );
    mPainterPath.lineTo( size.width() / 2.0, 0 );
  }
  else if ( symbolName == "triangle" )
  {
    mPainterPath.moveTo( 0, -size.height() / 2.0 );
    mPainterPath.lineTo( -size.width() / 2.0, size.height() / 2.0 );
    mPainterPath.lineTo( size.width() / 2.0, size.height() / 2.0 );
    mPainterPath.lineTo( 0, -size.height() / 2.0 );
  }
}

QPoint Legend::positionToDeviceCoord(QPaintDevice *pd)
{
    QSize legendSize = calculateSize();

    switch(m_Position)
    {
    case LP_UPPER_LEFT: // position: upper left corner
        {
            return QPoint(0, 0);
        }

    case LP_UPPER_RIGHT: // position: upper right corner
        {
            return QPoint(pd->width() - legendSize.width(), 0);
        }

    case LP_LOWER_LEFT: // position: lower left corner
        {
            return QPoint(0, pd->height() - legendSize.height());
        }

    case LP_LOWER_RIGHT: // position: lower right corner
        {
            return QPoint(pd->width() - legendSize.width(), pd->height() - legendSize.height());
        }

    default: // legend is floating
        {
            return QPoint();
        }
    }
}

	//-----------------------------------------------------------------------------
	Image & Image::loadRawData(
		DataStreamPtr& stream, 
		size_t uWidth, size_t uHeight, size_t uDepth,
		PixelFormat eFormat,
		size_t numFaces, size_t numMipMaps)
	{
		OgreGuard( "Image::loadRawData" );

		size_t size = calculateSize(numMipMaps, numFaces, uWidth, uHeight, uDepth, eFormat);
		if (size + stream->tell() != stream->size())
		{
			OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, 
				"Stream size does not match calculated image size", 
				"Image::loadRawData");
		}

		uchar *buffer = new uchar[ size ];
		stream->read(buffer, size);

		loadDynamicImage(buffer,
			uWidth, uHeight, uDepth,
			eFormat, true, numFaces, numMipMaps);

		OgreUnguardRet( *this );
	}

Type CTECList<Type>::removeFromBack()
{
	assert(size > 0);
	Type returnValue;

	if(size == 1)
	{
		ArrayNode<Type> * toRemove = end;
		returnValue = removeFromFront();
		end = nullptr;
		head = nullptr;
		delete toRemove;

	}
	else
	{
		ArrayNode<Type> * current = head;
		for(int index = 0; index < size - 1; index++)
		{
			current = current->getNext();
		}

		returnValue = end->getValue();
		delete end;
		current = end;
		current->setNext(nullptr);
	}

	calculateSize();

	return returnValue;


}

Vec2 MCGUILayoutComponent::getPos(MCGUIContext *context) {
    Vec2 parentSize = context->getParentComponentSize();
    Vec2 off = offset.get(context).get(parentSize);
    Vec2 size = calculateSize(context);
    Vec2 parentAnchorPos = MCGUIGetAnchorPoint(parentSize, anchorFrom.get(context));
    Vec2 myAnchorPos = MCGUIGetAnchorPoint(size, anchorTo.get(context));
    return parentAnchorPos - myAnchorPos + off;
}

/**
 * Constructor for Regular segments
 * @param extents: extents used for the segment
 * @param segId: id of the segment
 * @param bm: buffer manager for writing to disk
 */
Segment::Segment(std::vector<uint64_t> extents, uint64_t segId, FSISegment * fsi, BufferManager * bm) {

	Segment::segId = segId;
	Segment::extents = extents;
	Segment::fsi = fsi;
	Segment::bm = bm;
	size = calculateSize(extents);
	//Segment::expandExtents(extents);
}

    MeshObject::MeshObject(const String& name, const String& meshname)
    {
		if (meshname.length() > 0)
		{
			mMovableObject = CoreSubsystem::getSingletonPtr()->getWorld()
				->getSceneManager()->createEntity(name, meshname);
			calculateSize();
		}
    }

QRectF QgsEllipseSymbolLayer::bounds( QPointF point, QgsSymbolRenderContext &context )
{
  QSizeF size = calculateSize( context );

  bool hasDataDefinedRotation = false;
  QPointF offset;
  double angle = 0;
  calculateOffsetAndRotation( context, size.width(), size.height(), hasDataDefinedRotation, offset, angle );

  QMatrix transform;

  // move to the desired position
  transform.translate( point.x() + offset.x(), point.y() + offset.y() );

  if ( !qgsDoubleNear( angle, 0.0 ) )
    transform.rotate( angle );

  double penWidth = 0.0;
  if ( mDataDefinedProperties.isActive( QgsSymbolLayer::PropertyStrokeWidth ) )
  {
    context.setOriginalValueVariable( mStrokeWidth );
    QVariant exprVal = mDataDefinedProperties.value( QgsSymbolLayer::PropertyStrokeWidth, context.renderContext().expressionContext() );

    if ( exprVal.isValid() )
    {
      bool ok;
      double strokeWidth = exprVal.toDouble( &ok );
      if ( ok )
      {
        penWidth = context.renderContext().convertToPainterUnits( strokeWidth, mStrokeWidthUnit, mStrokeWidthMapUnitScale );
      }
    }
  }
  if ( mDataDefinedProperties.isActive( QgsSymbolLayer::PropertyStrokeStyle ) )
  {
    context.setOriginalValueVariable( QgsSymbolLayerUtils::encodePenStyle( mStrokeStyle ) );
    QVariant exprVal = mDataDefinedProperties.value( QgsSymbolLayer::PropertyStrokeStyle, context.renderContext().expressionContext() );
    if ( exprVal.isValid() && exprVal.toString() == QLatin1String( "no" ) )
    {
      penWidth = 0.0;
    }
  }

  //antialiasing, add 1 pixel
  penWidth += 1;

  QRectF symbolBounds = transform.mapRect( QRectF( -size.width() / 2.0,
                        -size.height() / 2.0,
                        size.width(),
                        size.height() ) );

  //extend bounds by pen width / 2.0
  symbolBounds.adjust( -penWidth / 2.0, -penWidth / 2.0,
                       penWidth / 2.0, penWidth / 2.0 );

  return symbolBounds;
}

void CTECList<Type>:: addToEnd(const Type& value)
{
	ArrayNode<Type> * newNode = new ArrayNode<Type>(value);
	end -> setNext(newNode);
	end = newNode;

	calculateSize();

}