graphicscontext.cpp

来自「这是VCF框架的代码」· C++ 代码 · 共 1,799 行 · 第 1/4 页

	contextPeer_->drawThemeHeader( rect, state );
}

void GraphicsContext::drawThemeEdge( Rect* rect, DrawUIState& state, const long& edgeSides, const long& edgeStyle )
{
	contextPeer_->drawThemeEdge( rect, state, edgeSides, edgeStyle );
}

void GraphicsContext::drawThemeSizeGripper( Rect* rect, DrawUIState& state )
{
	contextPeer_->drawThemeSizeGripper( rect, state );
}

void GraphicsContext::drawThemeBackground( Rect* rect, BackgroundState& state )
{
	contextPeer_->drawThemeBackground( rect, state );
}

void GraphicsContext::drawThemeMenuItem( Rect* rect, MenuState& state )
{
	contextPeer_->drawThemeMenuItem( rect, state );
}

void GraphicsContext::drawThemeText( Rect* rect, TextState& state )
{
	contextPeer_->drawThemeText( rect, state );
}

void GraphicsContext::setStrokeWidth( const double& width )
{
	currentGraphicsState_->strokeWidth_ = width;
}

double GraphicsContext::getStrokeWidth()
{
	return currentGraphicsState_->strokeWidth_;
}

void GraphicsContext::execPathOperations()
{
	currentDrawingState_ = GraphicsContext::gsExecutingGraphicsOps;

	std::vector<PointOperation>::iterator it = pathOperations_.begin();

	double tmpX;
	double tmpY;


	Matrix2D& transform = currentGraphicsState_->transformMatrix_;

	while ( it != pathOperations_.end() ) {
		PointOperation& pointOp = *it;

		switch ( pointOp.primitive ){
			case PointOperation::ptMoveTo : {
				currentGraphicsState_->currentMoveTo_.x_ = pointOp.x;
				currentGraphicsState_->currentMoveTo_.y_ = pointOp.y;

				tmpX = pointOp.x * (transform[Matrix2D::mei00]) +
							pointOp.y * (transform[Matrix2D::mei10]) +
								(transform[Matrix2D::mei20]);

				tmpY = pointOp.x * (transform[Matrix2D::mei01]) +
							pointOp.y * (transform[Matrix2D::mei11]) +
								(transform[Matrix2D::mei21]);



				contextPeer_->moveTo( tmpX, tmpY );
				++it;
			}
			break;

			case PointOperation::ptLineTo :{
				tmpX = pointOp.x * (transform[Matrix2D::mei00]) +
							pointOp.y * (transform[Matrix2D::mei10]) +
								(transform[Matrix2D::mei20]);

				tmpY = pointOp.x * (transform[Matrix2D::mei01]) +
							pointOp.y * (transform[Matrix2D::mei11]) +
								(transform[Matrix2D::mei21]);

				contextPeer_->lineTo( tmpX, tmpY );
				++it;
			}
			break;

			case PointOperation::ptPolyLine :{
				std::vector<Point> tmpPts;
				PointOperation::PrimitiveType type = pointOp.primitive;

				while ( (it != pathOperations_.end()) && (type == PointOperation::ptPolyLine) ) {
					PointOperation& pt = *it;
					type = pt.primitive;
					tmpX = pt.x * (transform[Matrix2D::mei00]) +
							pt.y * (transform[Matrix2D::mei10]) +
								(transform[Matrix2D::mei20]);

					tmpY = pt.x * (transform[Matrix2D::mei01]) +
							pt.y * (transform[Matrix2D::mei11]) +
								(transform[Matrix2D::mei21]);

					tmpPts.push_back( Point(tmpX,tmpY) );
					++it;
				}

				contextPeer_->polyline( tmpPts );
			}
			break;

			case PointOperation::ptBezier :{
				/*
				if ( (remaingOps - 3) < 0 ){
					//throw exception !!
				}
				*/
				if ( (pathOperations_.end() - it) < 4 ) {
					throw RuntimeException( MAKE_ERROR_MSG_2("Not enough path operations left to complete the bezier curve") );
				}

				Point p1;
				Point p2;
				Point p3;
				Point p4;

				PointOperation& pt1 = *it;
				p1.x_ = pt1.x * (transform[Matrix2D::mei00]) +
							pt1.y * (transform[Matrix2D::mei10]) +
								(transform[Matrix2D::mei20]);

				p1.y_ = pt1.x * (transform[Matrix2D::mei01]) +
							pt1.y * (transform[Matrix2D::mei11]) +
								(transform[Matrix2D::mei21]);

				++it;

				PointOperation& pt2 = *it;
				p2.x_ = pt2.x * (transform[Matrix2D::mei00]) +
							pt2.y * (transform[Matrix2D::mei10]) +
								(transform[Matrix2D::mei20]);

				p2.y_ = pt2.x * (transform[Matrix2D::mei01]) +
							pt2.y * (transform[Matrix2D::mei11]) +
								(transform[Matrix2D::mei21]);

				++it;

				PointOperation& pt3 = *it;
				p3.x_ = pt3.x * (transform[Matrix2D::mei00]) +
							pt3.y * (transform[Matrix2D::mei10]) +
								(transform[Matrix2D::mei20]);

				p3.y_ = pt3.x * (transform[Matrix2D::mei01]) +
							pt3.y * (transform[Matrix2D::mei11]) +
								(transform[Matrix2D::mei21]);

				++it;

				PointOperation& pt4 = *it;
				p4.x_ = pt4.x * (transform[Matrix2D::mei00]) +
							pt4.y * (transform[Matrix2D::mei10]) +
								(transform[Matrix2D::mei20]);

				p4.y_ = pt4.x * (transform[Matrix2D::mei01]) +
							pt4.y * (transform[Matrix2D::mei11]) +
								(transform[Matrix2D::mei21]);

				++it;

				contextPeer_->curve( p1.x_, p1.y_, p2.x_, p2.y_,
										p3.x_, p3.y_, p4.x_, p4.y_ );


			}
			break;

			case PointOperation::ptRect:{

				PointOperation& pt1 = *it;
				++it;

				PointOperation& pt2 = *it;
				++it;


				std::vector<Point> tmpPts(5);
				tmpPts[0].x_ = pt1.x;
				tmpPts[0].y_ = pt1.y;
				tmpPts[1].x_ = pt2.x;
				tmpPts[1].y_ = pt1.y;
				tmpPts[2].x_ = pt2.x;
				tmpPts[2].y_ = pt2.y;
				tmpPts[3].x_ = pt1.x;
				tmpPts[3].y_ = pt2.y;
				tmpPts[4] = tmpPts[0];

				std::vector<Point>::iterator ptIt = tmpPts.begin();

				while ( ptIt != tmpPts.end() ) {
					Point& p = *ptIt;
					tmpX = p.x_ * (transform[Matrix2D::mei00]) +
							p.y_ * (transform[Matrix2D::mei10]) +
								(transform[Matrix2D::mei20]);

					tmpY = p.x_ * (transform[Matrix2D::mei01]) +
							p.y_ * (transform[Matrix2D::mei11]) +
								(transform[Matrix2D::mei21]);

					p.x_ = tmpX;
					p.y_ = tmpY;
					++ptIt;
				}

				contextPeer_->polyline( tmpPts );



				//contextPeer_->rectangle( pt1.x, pt1.y, pt2.x, pt2.y );
			}
			break;

			case PointOperation::ptRoundRect :{



				PointOperation& pt1 = *it;
				++it;

				PointOperation& pt2 = *it;
				++it;

				PointOperation& pt3 = *it;
				++it;

				std::vector<Point> tmpPts;
				buildRoundRect( pt1.x, pt1.y, pt2.x, pt2.y, pt3.x, pt3.y, tmpPts, transform );

				contextPeer_->polyline( tmpPts );

			}
			break;

			case PointOperation::ptEllipse : {
				PointOperation& pt1 = *it;
				++it;

				PointOperation& pt2 = *it;
				++it;

				//contextPeer_->ellipse( pt1.x, pt1.y, pt2.x, pt2.y );

				std::vector<Point> tmpPts;
				buildEllipse( pt1.x, pt1.y, pt2.x, pt2.y, tmpPts, transform );

				contextPeer_->polyline( tmpPts );
			}
			break;

			case PointOperation::ptArc :{
				if ( (pathOperations_.end() - it) < 3 ) {
					throw RuntimeException( MAKE_ERROR_MSG_2("Not enough path operations left to complete the bezier curve") );
				}

				PointOperation& pt1 = *it;
				++it;

				PointOperation& pt2 = *it;
				++it;

				PointOperation& pt3 = *it;
				++it;


				std::vector<Point> tmpPts;
				buildArc( pt1.x, pt1.y, pt2.x, pt2.y, pt3.x, pt3.y, tmpPts, transform );

				contextPeer_->polyline( tmpPts );
			}
			break;

			case PointOperation::ptClose : {
				PointOperation& pt = *it;
				contextPeer_->lineTo( pt.x, pt.y );
				++it;
			}
			break;

			default : {
				it = pathOperations_.end();
				break; //quit the loop
			}
			break;
		}
	}

	currentDrawingState_ = GraphicsContext::gsNone;
}


void GraphicsContext::checkPathOperations()
{
	if ( GraphicsContext::gsAddingGraphicsOps != currentDrawingState_ ) {
		pathOperations_.clear();
	}
}

/*
Image* GraphicsContext::getImage( Rect* imageBounds )
{
	Image* result = contextPeer_->getImage( imageBounds );

	ImageRect imgRect(result,imageBounds);

	imageMap_[result] = imgRect;
	return result;
}

void GraphicsContext::putImage( Image* image )
{

	std::map<Image*, ImageRect>::iterator found = imageMap_.find( image );
	if ( found != imageMap_.end() ) {

		Rect& bounds = found->second.bounds_;
		contextPeer_->putImage( bounds.left_, bounds.top_, image );

		imageMap_.erase( found );
		delete image;
	}
	else {
		//throw an exception of some sort!
	}
}

*/




void GraphicsContext::setDrawingArea( Rect bounds )
{
	drawingAreaTopLeft_.x_ = bounds.left_;
	drawingAreaTopLeft_.y_ = bounds.top_;

	if ( NULL == drawingArea_ ) {
		drawingArea_ = GraphicsToolkit::createImage( (uint32)bounds.getWidth(), (uint32)bounds.getHeight() );
	}
	else {
		drawingArea_->setSize( (uint32)bounds.getWidth(), (uint32)bounds.getHeight() );
	}

	drawingArea_->getImageBits()->attachRenderBuffer( drawingArea_->getWidth(), drawingArea_->getHeight() );
	drawingArea_->getImageContext()->setRenderingBuffer( drawingArea_->getImageBits()->renderBuffer_ );

	drawingArea_->getImageContext()->setOrigin( -bounds.left_, -bounds.top_ );

	renderAreaDirty_ = true;
}

void GraphicsContext::deleteDrawingArea()
{
	delete drawingArea_;
	drawingArea_ = NULL;
}

void GraphicsContext::flushDrawingArea()
{
	if ( viewableBounds_.isNull() ) {
		drawImage( drawingAreaTopLeft_, drawingArea_ );
	}
	else {

		//FIXME!!!!!!!
		//drawingArea_->getImageBits()->renderBuffer_->clip_box( agg::rect( viewableBounds_.left_,
		//																	viewableBounds_.top_,
		//																	viewableBounds_.right_,
		//																	viewableBounds_.bottom_ ) );

		drawPartialImage(  viewableBounds_.getTopLeft(), &viewableBounds_, drawingArea_ );
	}

	renderAreaDirty_ = false;
}

void GraphicsContext::buildArc( double centerX,  double centerY,
            double radiusWidth, double radiusHeight,
            double startAngle, double endAngle, std::vector<Point>& pts, const Matrix2D& transform )
{
	agg::path_storage path;

	agg::arc arcPath(centerX,
						centerY,
						radiusWidth, radiusHeight,
						Math::degreesToRadians(startAngle), Math::degreesToRadians(endAngle));

	path.concat_path( arcPath );

	for ( size_t i=0;i<path.total_vertices();i++ ) {
		double vert_x,vert_y;
		path.vertex(i,&vert_x, &vert_y);	

		Point pt;
		pt.x_ = vert_x * (transform[Matrix2D::mei00]) +
							vert_y * (transform[Matrix2D::mei10]) +
								(transform[Matrix2D::mei20]);

		pt.y_ = vert_x * (transform[Matrix2D::mei01]) +
							vert_y * (transform[Matrix2D::mei11]) +
								(transform[Matrix2D::mei21]);

		pts.push_back( pt );
	}


	path.remove_all();
}


void GraphicsContext::buildRoundRect( double x1, double y1, double x2, double y2,
							double cornerArcWidth, double cornerArcHeight,
							std::vector<Point>& pts, const Matrix2D& transform )
{
	agg::path_storage path;

	path.move_to( x1 + cornerArcWidth/2.0, y1 );
	path.line_to( x2 - cornerArcWidth, y1 );

	agg::arc arc1(x2 - cornerArcWidth/2.0,
		y1 + cornerArcHeight/2.0,
		cornerArcWidth/2.0, cornerArcHeight/2.0,
		Math::degreesToRadians(270), Math::degreesToRadians(0));

	path.concat_path( arc1 );

	path.line_to( x2, y2 - cornerArcHeight/2.0 );

	agg::arc arc2(x2 - cornerArcWidth/2.0,
		y2 - cornerArcHeight/2.0,
		cornerArcWidth/2.0, cornerArcHeight/2.0,
		Math::degreesToRadians(0), Math::degreesToRadians(90));

	path.concat_path( arc2 );

	path.line_to( x1 + cornerArcWidth/2.0, y2 );

	agg::arc arc3(x1 + cornerArcWidth/2.0,
		y2 - cornerArcHeight/2.0,
		cornerArcWidth/2.0, cornerArcHeight/2.0,
		Math::degreesToRadians(90), Math::degreesToRadians(180));