gtkcontext.cpp

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

			                  gdkGC_,
			                  TRUE,
			                  &xPts[ 0 ],
			                  xPts.size() );
		} else {
			gdk_draw_lines( drawable_,
			                gdkGC_,
			                &xPts[ 0 ],
			                xPts.size() );
		}
	}
}

void GTKContext::curve( const double & x1,
                        const double & y1,
                        const double & x2,
                        const double & y2,
                        const double & x3,
                        const double & y3,
                        const double & x4,
                        const double & y4 )
{
	// 	int degree = 3; //3rd degree bezier poly - needs 4 controls
	// 	Mgc::Vector2* bezPts = new Mgc::Vector2[ 4 ];
	// 	bezPts[ 0 ][ 0 ] = long( x1 + origin_.x_ );
	// 	bezPts[ 0 ][ 1 ] = long( y1 + origin_.y_ );
	// 	bezPts[ 1 ][ 0 ] = long( x2 + origin_.x_ );
	// 	bezPts[ 1 ][ 1 ] = long( y2 + origin_.y_ );
	// 	bezPts[ 2 ][ 0 ] = long( x3 + origin_.x_ );
	// 	bezPts[ 2 ][ 1 ] = long( y3 + origin_.y_ );
	// 	bezPts[ 3 ][ 0 ] = long( x4 + origin_.x_ );
	// 	bezPts[ 3 ][ 1 ] = long( y4 + origin_.y_ );
	//
	// 	Mgc::BezierCurve2 bezCurve( degree, bezPts );
	//
	// 	//get the length over the duration of the curve from
	// 	//t= 0.0 to t=1.0
	// 	double length = bezCurve.GetLength( 0.0, 0.1250 );
	// 	double max = bezCurve.GetMaxTime();
	// 	double min = bezCurve.GetMinTime();
	// 	double dt = ( max - min ) / length;
	//
	// 	std::vector<GdkPoint> xPts;
	// 	for ( double t = min ; t < max; t += dt ) {
	// 		Mgc::Vector2 vec = bezCurve.GetPosition( t );
	// 		GdkPoint pt;
	// 		pt.x = gint( vec[ 0 ] );
	// 		pt.y = gint( vec[ 1 ] );
	// 		xPts.push_back( pt );
	// 	}
	//
	// 	if ( !xPts.empty() ) {
	// 		if ( inFillPath_ ) {
	// 			gdk_draw_polygon( drawable_, gdkGC_, TRUE, &xPts[ 0 ], xPts.size() );
	// 		} else {
	// 			gdk_draw_lines( drawable_, gdkGC_, &xPts[ 0 ], xPts.size() );
	// 		}
	// 	}
}

void GTKContext::lineTo( const double & x, const double & y )
{
	gdk_draw_line( drawable_, gdkGC_,
	               int( currentMoveTo_.x_ + origin_.x_ ),
	               int( currentMoveTo_.y_ + origin_.y_ ),
	               int( x + origin_.x_ ),
	               int( y + origin_.y_ ) );

	currentMoveTo_.x_ = x;
	currentMoveTo_.y_ = y;
}

void GTKContext::moveTo( const double & x, const double & y )
{
	currentMoveTo_.x_ = x;
	currentMoveTo_.y_ = y;
}

void GTKContext::setOrigin( const double& x, const double& y )
{
	origin_.x_ = x;
	origin_.y_ = y;
}

Point GTKContext::getOrigin()
{
	return origin_;
}

void GTKContext::copyContext( const Rect& sourceRect,
                              const Rect& destRect,
                              ContextPeer* sourceContext )
{
	if ( sourceContext ) {
		this->checkHandle();

		gdk_draw_drawable( drawable_,
		                   gdkGC_,
		                   reinterpret_cast<GdkDrawable*>(
		                       sourceContext->getContextID() ),
		                   gint( sourceRect.left_ ),
		                   gint( sourceRect.top_ ),
		                   gint( destRect.left_ + origin_.x_ ),
		                   gint( destRect.top_ + origin_.y_ ),
		                   gint( destRect.getWidth() ),
		                   gint( destRect.getHeight() ) );

		releaseHandle();
	}
}

bool GTKContext::isMemoryContext()
{
	return isMemoryCtx_;
}

void GTKContext::checkHandle()
{
	if ( parentImage_ ) {
		parentImage_->updatePixmapFromImageBits();
	}
}

void GTKContext::releaseHandle()
{
	if ( parentImage_ ) {
		parentImage_->updateImageBitsFromPixmap();
	}
}

bool GTKContext::isXORModeOn()
{
	return isXORModeOn_;
}

void GTKContext::setXORModeOn( const bool& XORModeOn )
{
	isXORModeOn_ = XORModeOn;
}

void GTKContext::setTextAlignment( const bool& alignTobaseline )
{
	alignToBaseline_ = alignTobaseline;
}

bool GTKContext::isTextAlignedToBaseline()
{
	return alignToBaseline_;
}

GtkStyle* GTKContext::getGTKStyle( GtkWidget* widget )
{
	if ( widget and GTK_IS_WIDGET( widget ) ) {
		return widget->style;
	} else {
		GTKGraphicsToolkit* toolkit =
		    static_cast<GTKGraphicsToolkit*>(
		        GraphicsToolkit::internal_getDefaultGraphicsToolkit() );
		return toolkit->getDefaultGTKStyle();
	}

}

GtkStateType GTKContext::getGTKState( GtkWidget* widget )
{
	GtkStateType result = GTK_STATE_NORMAL;

	if ( widget and GTK_IS_WIDGET( widget ) ) {
		result = GtkStateType( GTK_WIDGET_STATE( widget ) );
	}

	return result;
}

// void GTKContext::drawSelectionRect( Rect* rect )
// {
// 	GdkRectangle r = { gint( rect->left_ ),
// 	                   gint( rect->top_ ),
// 	                   gint( rect->getWidth() ),
// 	                   gint( rect->getHeight() ) };
//
// 	GtkWidget* widget = 0;
// 	gdk_window_get_user_data( drawable_, &widget );
// 	GtkStyle* style = getGTKStyle( widget );
//
// 	gtk_paint_focus( style,
// 	                 drawable_,
// 	                 getGTKState( widget ),
// 	                 &r,
// 	                 widget,
// 	                 0,
// 	                 r.x,
// 	                 r.y,
// 	                 r.width,
// 	                 r.height );
// }

// void GTKContext::drawButtonRect( Rect* rect, const bool& isPressed )
// {
// 		GdkRectangle r = { gint( rect->left_ ),
// 		                   gint( rect->top_ ),
// 		                   gint( rect->getWidth() ),
// 		                   gint( rect->getHeight() ) };
//
// 	GtkWidget * widget = 0;
// 	gdk_window_get_user_data( drawable_, &widget );
// 	GtkStyle* style = getGTKStyle( widget );
//
// 	gtk_paint_box( style, drawable_,
// 	               getGTKState( widget ),
// 	               ( isPressed ) ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
// 	               &r,
// 	               widget,
// 	               "button",
// 	               r.x,
// 	               r.y,
// 	               r.width,
// 	               r.height );
//
// }

// void GTKContext::drawCheckboxRect( Rect* rect, const bool& isPressed )
// {
// 	GdkRectangle r = { gint( rect->left_ ),
// 	                   gint( rect->top_ ),
// 	                   gint( rect->getWidth() ),
// 	                   gint( rect->getHeight() ) };
//
// 	GtkWidget* widget = 0;
// 	gdk_window_get_user_data( drawable_, &widget );
// 	GtkStyle* style = getGTKStyle( widget );
//
// 	gtk_paint_check( style, drawable_,
// 	                 getGTKState( widget ),
// 	                 ( isPressed ) ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
// 	                 &r,
// 	                 widget,
// 	                 "button",
// 	                 r.x,
// 	                 r.y,
// 	                 r.width,
// 	                 r.height );
// }

void GTKContext::drawThemeRadioButtonRect( Rect* rect, ButtonState& state )
{
	GdkRectangle r = { gint( rect->left_ ),
	                   gint( rect->top_ ),
	                   gint( rect->getWidth() ),
	                   gint( rect->getHeight() ) };

	gpointer widgetPtr = 0;
	gdk_window_get_user_data( drawable_, &widgetPtr );
	GtkWidget* widget = reinterpret_cast<GtkWidget*>( &widgetPtr );
	GtkStyle* style = getGTKStyle( widget );

	gtk_paint_option( style, drawable_,
	                  getGTKState( widget ),
	                  ( state.isPressed() ) ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
	                  &r,
	                  widget,
	                  "button",
	                  r.x,
	                  r.y,
	                  r.width,
	                  r.height );
}

void GTKContext::drawThemeProgress( Rect* rect, ProgressState& state )
{}

// void GTKContext::drawVerticalScrollButtonRect( Rect* rect,
//                                                const bool& topButton,
//                                                const bool& isPressed )
// {}

// void GTKContext::drawDisclosureButton( Rect* rect, const long& state )
// {}

// void GTKContext::drawHorizontalScrollButtonRect( Rect* rect,
//                                                  const bool& leftButton,
//                                                  const bool& isPressed )
// {}

// void GTKContext::drawTab( Rect* rect, const bool& selected, const String& caption )
// {}

// void GTKContext::drawTabPage( Rect* rect )
// {}

// void GTKContext::drawTickMarks( Rect* rect, const SliderInfo& sliderInfo )
// {}

// void GTKContext::drawSliderThumb( Rect* rect, const SliderInfo& sliderInfo )
// {}

// void GTKContext::drawSlider( Rect* rect, const SliderInfo& sliderInfo )
// {}

// void GTKContext::drawHeader( Rect* rect )
// {}

// void GTKContext::drawEdge( Rect* rect, const long& edgeSides, const long& edgeStyle )
// {
// 	GdkRectangle r = { gint( rect->left_ ),
// 	                   gint( rect->top_ ),
// 	                   gint( rect->getWidth() ),
// 	                   gint( rect->getHeight() ) };
//
// 	GtkWidget* widget = 0;
// 	gdk_window_get_user_data( drawable_, &widget );
// 	GtkStyle* style = getGTKStyle( widget );
//
// 	GtkShadowType shadow = GTK_SHADOW_NONE;
//
// 	switch ( edgeStyle ) {
// 		case GraphicsContext::etRecessed : {
// 				shadow = GTK_SHADOW_IN;
// 			}
// 			break;
//
// 		case GraphicsContext::etEtched : {
// 				shadow = GTK_SHADOW_ETCHED_IN;
// 			}
// 			break;
//
// 		case GraphicsContext::etRaised : {
// 				shadow = GTK_SHADOW_ETCHED_OUT;
// 			}
// 			break;
//
// 		case GraphicsContext::etSunken : {
// 				shadow = GTK_SHADOW_OUT;
// 			}
// 			break;
// 	}
//
// 	if ( GTK_SHADOW_NONE == shadow ) {
// 		return ;
// 	}
//
// 	if ( edgeSides & GraphicsContext::etLeftSide
// 	        and edgeSides & GraphicsContext::etRightSide
// 	        and edgeSides & GraphicsContext::etTopSide
// 	        and edgeSides & GraphicsContext::etBottomSide ) {
//
// 		gtk_paint_box( style, drawable_,
// 		               getGTKState( widget ),
// 		               shadow,
// 		               &r,
// 		               widget,
// 		               "button",
// 		               r.x,
// 		               r.y,
// 		               r.width,
// 		               r.height );
// 	} else {