gtkuitoolkit.cpp

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

//GTKUIToolkit.cpp

/*
Copyright 2000-2004 The VCF Project.
Please see License.txt in the top level directory
where you installed the VCF.
*/


#include "vcf/ApplicationKit/ApplicationKit.h"
#include "vcf/ApplicationKit/ApplicationKitPrivate.h"

#include "vcf/ApplicationKit/GTKUIToolkit.h"
#include "vcf/ApplicationKit/GTKDesktop.h"
#include "vcf/ApplicationKit/GTKApplication.h"
#include "vcf/ApplicationKit/GTKControlContext.h"
#include "vcf/ApplicationKit/GTKControl.h"
#include "vcf/ApplicationKit/GTKCursor.h"


#include "vcf/ApplicationKit/GTKWindow.h"


#include "vcf/ApplicationKit/LightweightComponent.h"

#include <gdk/gdkkeysyms.h>

#include "vcf/ApplicationKit/GTKDialog.h"
#include "vcf/ApplicationKit/GTKCommandButton.h"
#include "vcf/ApplicationKit/GTKTextControl.h"
#include "vcf/ApplicationKit/GTKFileOpenDialog.h"
#include "vcf/ApplicationKit/GTKToolbar.h"
#include "vcf/ApplicationKit/Toolbar.h"

//get rid of the stupip fscking warning from GCC
#define NULL 0


#define VCF_GTK_POST_EVENT			"VCF_GTK_POST_EVENT"



using namespace VCF;


//UIMetricsManager implementation for GTK
class GTKUIMetricsManager : public UIMetricsManager
{
public:
	GTKUIMetricsManager()
	{}

	virtual ~GTKUIMetricsManager()
	{}

	virtual VCF::Font getDefaultFontFor( const UIMetricsManager::FontType& type )
	{
		VCF::Font result( "ARIAL", 10 );

		result.setColor( GraphicsToolkit::getSystemColor( SYSCOLOR_CAPTION_TEXT ) );
		switch ( type ) {
			case UIMetricsManager::ftMenuItemFont : {}
				break;

			case UIMetricsManager::ftSelectedMenuItemFont : {}
				break;

			case UIMetricsManager::ftControlFont :
		case UIMetricsManager::ftSystemFont : {}
				break;

			case UIMetricsManager::ftMessageFont : {}
				break;

			case UIMetricsManager::ftToolTipFont : {}
				break;
		}

		return result;
	}

	virtual double getDefaultHeightFor( const UIMetricsManager::HeightType& type )
	{
		double result = 0.0;
		switch ( type ) {
			case UIMetricsManager::htLabelHeight : {
					VCF::Font f = getDefaultFontFor( UIMetricsManager::ftControlFont );
					result = f.getHeight() * 1.75;
				}
				break;

			case UIMetricsManager::htComboBoxHeight : {
					VCF::Font f = getDefaultFontFor( UIMetricsManager::ftControlFont );
					result = f.getHeight() * 2.0;
				}
				break;

			case UIMetricsManager::htListItemHeight : {
					VCF::Font f = getDefaultFontFor( UIMetricsManager::ftControlFont );
					result = f.getHeight() * 1.65;
				}
				break;

			case UIMetricsManager::htButtonHeight : {
					VCF::Font f = getDefaultFontFor( UIMetricsManager::ftControlFont );
					result = ( f.getHeight() * 1.75 ) + 2.50;
				}
				break;

			case UIMetricsManager::htRadioBoxHeight :
			case UIMetricsManager::htCheckBoxHeight : {
					//in Win32 a radio box or check box is ALWAYS 10 dialog units high
					//dialog units are converted by
					//(2 * average char height dialog font / average char height system font pixels
					//where average char height dialog font = TEXTMETRIC.tmHeight field or a Font::getHeight()


					VCF::Font f = getDefaultFontFor( UIMetricsManager::ftControlFont );
					result = ( 9.0 * ( ( 2.0 * f.getHeight() ) / f.getHeight() ) ) - 4.0; //0.590909;
				}
				break;

			case UIMetricsManager::htToolTipHeight : {
					VCF::Font f = getDefaultFontFor( UIMetricsManager::ftToolTipFont );
					result = f.getHeight() * 1.2222;
				}
				break;

			case UIMetricsManager::htSeparatorHeight : {
					result = 2.0;
				}
				break;

			case UIMetricsManager::htInformationalControl : {
					VCF::Font f = getDefaultFontFor( UIMetricsManager::ftControlFont );
					result = f.getHeight() * 1.75;
				}
				break;
		}
		return result;

	}

	virtual double getPreferredSpacingFor( const UIMetricsManager::SpacingType& type )
	{
		double result = 0.0;

		//values largely derived from the Apple HIG at
		//http://developer.apple.com/techpubs/macosx/Essentials/AquaHIGuidelines/AHIGLayout/index.html
		switch ( type ) {
			case UIMetricsManager::stWindowBorderDelta : {
					result = 20.0;
				}
				break;

			case UIMetricsManager::stContainerBorderDelta : {
					result = 8.0;
				}
				break;

			case UIMetricsManager::stControlVerticalSpacing : {
					result = 14.0;
				}
				break;

			case UIMetricsManager::stControlHorizontalSpacing : {
					result = 10.0;
				}
				break;

			case UIMetricsManager::stInformationControlTopSpacer : {
					result = 2.0;
				}
				break;

			case UIMetricsManager::stInformationControlBottomSpacer : {
					result = 8.0;
				}
				break;
		}

		return result;
	}

	virtual Size getDefaultSliderThumbDimensions()
	{
		Size result;

		//where the hell do we get these ????
		result.width_ = 22;
		result.height_ = 22;

		return result;
	}

	virtual Size getDefaultMenuItemDimensions( const String& caption )
	{
		Size result;


		return result;
	}

	virtual Size getDefaultVerticalScrollButtonDimensions()
	{
		Size result;

		result.width_ = 22;
		result.height_ = 22;

		return result;
	}

	virtual Size getDefaultHorizontalScrollButtonDimensions()
	{
		Size result;

		result.width_ = 22;
		result.height_ = 22;

		return result;
	}

	virtual Size getDefaultTabDimensions( const String& caption )
	{
		Size result;

		return result;
	}
};










GTKUIToolkit::GTKUIToolkit() :
		defaultParent_( NULL )
{
	//this will work, but it means ignoring certain arguments that might be important for
	//gtk initialization - need to figure out a better way
	gdk_parse_args ( NULL, NULL );

	if ( !gdk_display_open_default_libgtk_only () ) {
		StringUtils::trace( "gdk_display_open_default_libgtk_only () failed!\n" );
		//throw exception????
	}


	metricsMgr_ = new GTKUIMetricsManager();
	createDefaultParentWnd();


	gdk_atom_intern( VCF_GTK_POST_EVENT, FALSE );
}

GTKUIToolkit::~GTKUIToolkit()
{}

ApplicationPeer* GTKUIToolkit::internal_createApplicationPeer()
{
	return new GTKApplication();
}

TextPeer* GTKUIToolkit::internal_createTextPeer( TextControl* component,
                                                 const bool& isMultiLineControl )
{
	return new GTKTextControl( component, isMultiLineControl );
}

TextPeer* GTKUIToolkit::internal_createTextPeer( TextControl* component,
                                                 const bool& isMultiLineControl,
                                                 ComponentType componentType )
{
	return new GTKTextControl( component, isMultiLineControl );
}


TreePeer* GTKUIToolkit::internal_createTreePeer( TreeControl* componentb )
{
	return 0;
}

ListviewPeer* GTKUIToolkit::internal_createListViewPeer( ListViewControl* component )
{
	return 0;
}

CommonPrintDialogPeer* GTKUIToolkit::internal_createCommonPrintDialogPeer( Control* owner )
{
	return 0;
}

DialogPeer* GTKUIToolkit::internal_createDialogPeer( Control* owner, Dialog* component )
{
	return new GTKDialog( owner, component );
}

DialogPeer* GTKUIToolkit::internal_createDialogPeer()
{
	return new GTKDialog();
}

ControlPeer* GTKUIToolkit::internal_createControlPeer( Control* component, ComponentType componentType )
{
	ControlPeer * result = NULL;

	switch ( componentType ) {
		case CT_LIGHTWEIGHT: {
				result = new LightweightComponent( component );
			}
			break;

		case CT_DEFAULT:
		case CT_HEAVYWEIGHT: {
				result = new GTKControl( component );
			}
			break;
	}
	return result;
}

WindowPeer* GTKUIToolkit::internal_createWindowPeer( Control* component,
                                                     Control* owner )
{
	return new GTKWindow( component, owner );
}

ToolbarPeer* GTKUIToolkit::internal_createToolbarPeer( Toolbar* toolbar )
{
	return new GTKToolbar( toolbar );
}

MenuItemPeer* GTKUIToolkit::internal_createMenuItemPeer( MenuItem* item )
{
	return NULL;
}

MenuBarPeer* GTKUIToolkit::internal_createMenuBarPeer( MenuBar* menuBar )
{
	return NULL;
}

PopupMenuPeer* GTKUIToolkit::internal_createPopupMenuPeer( PopupMenu* popupMenu )
{
	return NULL;
}

ButtonPeer* GTKUIToolkit::internal_createButtonPeer( CommandButton* component )
{
	return new GTKCommandButton( component );
}

HTMLBrowserPeer* GTKUIToolkit::internal_createHTMLBrowserPeer( Control* control )
{
	return NULL;
}

ContextPeer* GTKUIToolkit::internal_createContextPeer( Control* component )
{
	return new GTKControlContext( component->getPeer() );
}

CommonFileDialogPeer* GTKUIToolkit::internal_createCommonFileOpenDialogPeer( Control* owner )
{
	return new GTKFileOpenDialog( owner );
}

CommonFileDialogPeer* GTKUIToolkit::internal_createCommonFileSaveDialogPeer( Control* owner )
{
	return NULL;
}

CommonColorDialogPeer* GTKUIToolkit::internal_createCommonColorDialogPeer( Control* owner )
{
	return NULL;
}

CommonFolderBrowseDialogPeer* GTKUIToolkit::internal_createCommonFolderBrowseDialogPeer( Control* owner )
{
	return NULL;
}

CommonFontDialogPeer* GTKUIToolkit::internal_createCommonFontDialogPeer( Control* owner )
{
	return NULL;
}

DragDropPeer* GTKUIToolkit::internal_createDragDropPeer()
{
	return NULL;
}

DataObjectPeer* GTKUIToolkit::internal_createDataObjectPeer()
{
	return NULL;
}

DropTargetPeer* GTKUIToolkit::internal_createDropTargetPeer()
{
	return NULL;
}

DesktopPeer* GTKUIToolkit::internal_createDesktopPeer( Desktop* desktop )
{
	return new GTKDesktop( desktop );
}

ScrollPeer* GTKUIToolkit::internal_createScrollPeer( Control* control )
{
	return NULL;
}

CursorPeer* GTKUIToolkit::internal_createCursorPeer( Cursor* cursor )
{
	return new GTKCursor( cursor );
}

ClipboardPeer* GTKUIToolkit::internal_createClipboardPeer()
{
	return NULL;
}

bool GTKUIToolkit::internal_createCaret( Control* owningControl, Image* caretImage )
{
	bool result = false;

	return result;
}

bool GTKUIToolkit::internal_destroyCaret( Control* owningControl )
{
	bool result = false;

	return result;
}

void GTKUIToolkit::internal_setCaretVisible( const bool& caretVisible )
{}

void GTKUIToolkit::internal_setCaretPos( Point* point )
{}

void GTKUIToolkit::internal_postEvent( EventHandler* eventHandler, Event* event, const bool& deleteHandler )
{
	GdkEventClient clientEvent;
	memset( &clientEvent, 0, sizeof( clientEvent ) );

	clientEvent.type = GDK_CLIENT_EVENT;
	clientEvent.message_type = gdk_atom_intern( VCF_GTK_POST_EVENT, FALSE );
	clientEvent.data.l[ 0 ] = ( unsigned long ) eventHandler;
	clientEvent.data.l[ 1 ] = ( unsigned long ) event->clone();
	clientEvent.data.l[ 2 ] = deleteHandler ? TRUE : FALSE;

	gdk_event_put( ( GdkEvent* ) & clientEvent );
}

void GTKUIToolkit::internal_registerTimerHandler( Object* source, EventHandler* handler, const ulong32& timeoutInMilliSeconds )
{


	std::map<EventHandler*, TimeOutHandler>::iterator found = timeoutHandlers_.find( handler );
	if ( found != timeoutHandlers_.end() ) {
		TimeOutHandler & tmHandler = found->second;
		gtk_timeout_remove ( tmHandler.timerID_ );
		timeoutHandlers_.erase( found );
	}


	TimeOutHandler tmHandler;
	tmHandler.source_ = source;
	tmHandler.handler_ = handler;
	tmHandler.timerID_ = gtk_timeout_add( timeoutInMilliSeconds,
	                                      GTKUIToolkit::gtkTimeOutHandler,
	                                      ( gpointer ) handler );

	timeoutHandlers_[ handler ] = tmHandler;