osxuitoolkit.cpp

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

    InstallEventLoopIdleTimer( GetCurrentEventLoop(), 0, 0.25,
                                idleTimerUPP_, this, &idleTimerRef_ );


    if ( err != noErr ) {
        printf( "InstallEventHandler failed" );
    }
	
	
	
	
}

OSXUIToolkit::~OSXUIToolkit()
{

    std::map<EventLoopTimerRef,TimeOutHandler>::iterator found = timeoutHandlers_.begin();
    while ( !timeoutHandlers_.empty() ) {
        internal_unregisterTimerHandler( found->second.handler_ );
        found = timeoutHandlers_.begin();
    }


    DisposeEventHandlerUPP(handlerUPP_);
    DisposeEventLoopTimerUPP(timerUPP_);

    RemoveEventLoopTimer( idleTimerRef_ );
    DisposeEventLoopIdleTimerUPP(idleTimerUPP_);
    printf( "OSXUIToolkit destroyed\n");
}

ApplicationPeer* OSXUIToolkit::internal_createApplicationPeer()
{
    return new OSXApplicationPeer();
}

TextPeer* OSXUIToolkit::internal_createTextPeer( const bool& autoWordWrap, const bool& multiLined )
{
	return new OSXTextPeer(autoWordWrap,multiLined);
}

TextEditPeer* OSXUIToolkit::internal_createTextEditPeer( TextControl* component, const bool& isMultiLineControl )
{
	return new OSXTextEditPeer(component,isMultiLineControl);
}
	
	
TreePeer* OSXUIToolkit::internal_createTreePeer( TreeControl* component )
{
    return new OSXTree(component);
}

ListviewPeer* OSXUIToolkit::internal_createListViewPeer( ListViewControl* component )
{
    return new OSXListview(component);
}

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

DialogPeer* OSXUIToolkit::internal_createDialogPeer()
{
    return new OSXDialog();
}

ControlPeer* OSXUIToolkit::internal_createControlPeer( Control* control, ComponentType componentType )
{
	ControlPeer* result = NULL;

	switch ( componentType ){
		case CT_LIGHTWEIGHT:{
			result = new OSXLightweightControl( control );
		}
		break;

		case CT_DEFAULT: case CT_HEAVYWEIGHT:{
			result = new OSXControl( control );
		}
		break;
	}
	return result;	
}

WindowPeer* OSXUIToolkit::internal_createWindowPeer( Control* control, Control* owner )
{
    return new OSXWindow( control, owner );
}

ToolbarPeer* OSXUIToolkit::internal_createToolbarPeer( Toolbar* toolbar )
{
    return new OSXToolbar(toolbar);
}

MenuItemPeer* OSXUIToolkit::internal_createMenuItemPeer( MenuItem* item )
{
    return new OSXMenuItem( item );
}

MenuBarPeer* OSXUIToolkit::internal_createMenuBarPeer( MenuBar* menuBar )
{
    return new OSXMenuBar( menuBar );
}

PopupMenuPeer* OSXUIToolkit::internal_createPopupMenuPeer( PopupMenu* popupMenu )
{
    return new OSXPopupMenu(popupMenu);
}

ButtonPeer* OSXUIToolkit::internal_createButtonPeer( CommandButton* component )
{
    return new OSXButton( component );
}

ContextPeer* OSXUIToolkit::internal_createContextPeer( Control* control )
{
    return new OSXControlContextPeer( control->getPeer() );
}

CommonFileDialogPeer* OSXUIToolkit::internal_createCommonFileOpenDialogPeer( Control* owner )
{
    return new OSXFileOpenDialog(owner);
}

CommonFileDialogPeer* OSXUIToolkit::internal_createCommonFileSaveDialogPeer( Control* owner )
{
    return new OSXFileSaveDialog(owner);
}

CommonColorDialogPeer* OSXUIToolkit::internal_createCommonColorDialogPeer( Control* owner )
{
    return new OSXColorDialog( owner );
}

CommonFolderBrowseDialogPeer* OSXUIToolkit::internal_createCommonFolderBrowseDialogPeer( Control* owner )
{
    return new OSXFolderBrowseDialog( owner );
}

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

DragDropPeer* OSXUIToolkit::internal_createDragDropPeer()
{
    return new OSXDragDropPeer();
}

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

DropTargetPeer* OSXUIToolkit::internal_createDropTargetPeer()
{
    return new OSXDropTargetPeer();
}

DesktopPeer* OSXUIToolkit::internal_createDesktopPeer( Desktop* desktop )
{
    return new OSXDesktopPeer(desktop);
}

ScrollPeer* OSXUIToolkit::internal_createScrollPeer( Control* control )
{
    return new OSXScrollPeer(control);
}

GraphicsResourceBundlePeer* OSXUIToolkit::internal_createGraphicsResourceBundlePeer( AbstractApplication* app )
{
	return new OSXAppResourceBundle( app );
}

SystemTrayPeer* OSXUIToolkit::internal_createSystemTrayPeer()
{
	return NULL;
}

MenuManagerPeer* OSXUIToolkit::internal_createMenuManagerPeer()
{
	return new OSXMenuManagerPeer();
}

CommonPrintDialogPeer* OSXUIToolkit::internal_createCommonPrintDialogPeer( Control* owner )
{
	return NULL;
}

CursorPeer* OSXUIToolkit::internal_createCursorPeer( Cursor* cursor )
{
    return new OSXCursorPeer(cursor);
}

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

bool OSXUIToolkit::internal_createCaret( Control* owningControl, Image* caretImage  )
{
    return false;
}

bool OSXUIToolkit::internal_destroyCaret( Control* owningControl )
{
    return false;
}

void OSXUIToolkit::internal_setCaretVisible( const bool& caretVisible )
{

}

void OSXUIToolkit::internal_setCaretPos( Point* point )
{

}

void OSXUIToolkit::internal_postEvent( VCF::EventHandler* eventHandler, Event* event, const bool& deleteHandler )
{
    EventRef osxEvent = OSXUIToolkit::createUserCarbonEvent(OSXUIToolkit::EventPosted);


    OSStatus err = SetEventParameter( osxEvent, OSXUIToolkit::EventHandler,
                        typeUInt32, OSXUIToolkit::SizeOfEventHandler, &eventHandler );
    if ( err != noErr ) {
        printf( "SetEventParameter failed\n" );
    }

    err = SetEventParameter( osxEvent, OSXUIToolkit::EventHandlerEvent,
                        typeUInt32, OSXUIToolkit::SizeOfEventHandlerEvent, &event );
	if ( err != noErr ) {
        printf( "SetEventParameter failed\n" );
    }

    Boolean val = deleteHandler ? TRUE : FALSE;
    err = SetEventParameter( osxEvent, OSXUIToolkit::DeletePostedEvent,
                        typeBoolean, OSXUIToolkit::SizeOfDeletePostedEvent, &val );
	if ( err != noErr ) {
        printf( "SetEventParameter failed\n" );
    }

    err = PostEventToQueue( GetCurrentEventQueue(), osxEvent, kEventPriorityStandard );
    if ( err != noErr ) {
        printf( "PostEventToQueue failed\n" );
    }
}

void OSXUIToolkit::handleIdleTimer( EventLoopTimerRef inTimer, EventLoopIdleTimerMessage inState, void *inUserData )
{
    OSXUIToolkit* toolkit = (OSXUIToolkit*)inUserData;

       switch ( inState ) {
        case kEventLoopIdleTimerStarted : {

        }
        break;

        case kEventLoopIdleTimerIdling : {
            
            Application* app = Application::getRunningInstance();
            if ( NULL != app ) {
				app->idleTime();
			}

			//check library apps;
			Enumerator<LibraryApplication*>* registeredLibs = LibraryApplication::getRegisteredLibraries();
			while ( true == registeredLibs->hasMoreElements() ) {
				LibraryApplication* libraryApp = registeredLibs->nextElement();
				libraryApp->idleTime();
			}
        }
        break;

        case kEventLoopIdleTimerStopped : {

        }
        break;
    }
}

void OSXUIToolkit::handleTimerEvent( EventLoopTimerRef inTimer, void * inUserData )
{
   OSXUIToolkit* toolkit = (OSXUIToolkit*)inUserData;
   std::map<EventLoopTimerRef,TimeOutHandler>::iterator found =
        toolkit->timeoutHandlers_.find( inTimer );
    if ( found != toolkit->timeoutHandlers_.end() ) {
        TimeOutHandler& toh = found->second;
        TimerEvent event( toh.source_, TIMER_EVENT_PULSE );
		toh.handler_->invoke( &event );
    }
}


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

    TimeOutHandler toh;
    toh.source_ = source;
    toh.handler_ = handler;


    std::map<EventLoopTimerRef,TimeOutHandler>::iterator found = timeoutHandlers_.begin();
    while ( found != timeoutHandlers_.end() ) {
        TimeOutHandler& tmHandler = found->second;
        if ( tmHandler.handler_ == handler ) {
            RemoveEventLoopTimer( tmHandler.timerRef_ );
            timeoutHandlers_.erase( found );
            break;
        }
        found ++;
    }

    double timeout = ((double)timeoutInMilliSeconds/1000.0);

    InstallEventLoopTimer( GetCurrentEventLoop(),
                            timeout,
                            timeout,
                            timerUPP_,
                            this,
                            &toh.timerRef_ );

    timeoutHandlers_[toh.timerRef_] = toh;
}

void OSXUIToolkit::internal_unregisterTimerHandler( VCF::EventHandler* handler )
{
    std::map<EventLoopTimerRef,TimeOutHandler>::iterator found = timeoutHandlers_.begin();
    while ( found != timeoutHandlers_.end() ) {
        TimeOutHandler& tmHandler = found->second;
        if ( tmHandler.handler_ == handler ) {
            RemoveEventLoopTimer( tmHandler.timerRef_ );
            timeoutHandlers_.erase( found );
            break;
        }
        found ++;
    }
}


void OSXUIToolkit::internal_runEventLoop()
{
    //set to false to begin with
    quitEventLoop_ = false;

    RunApplicationEventLoop();

    //reset back to false when finished
    quitEventLoop_ = false;
}

UIToolkit::ModalReturnType OSXUIToolkit::internal_runModalEventLoopFor( Control* control )
{
	Frame* ownerFrame = control->getParentFrame();
	WindowRef controlWindow = (WindowRef) ownerFrame->getPeer()->getHandleID();
	
	//EndAppModalStateForWindow( controlWindow );
	UIToolkit::ModalReturnType result = UIToolkit::mrTrue;
	/*
	EventRef theEvent;
	while  ( ReceiveNextEvent(0, NULL,kEventDurationForever,true, &theEvent)== noErr ) {
		
		SendEventToEventTarget (theEvent, GetEventDispatcherTarget());
				
		if ( kEventClassCommand == GetEventKind( theEvent ) ) {
			HICommand		command;
			GetEventParameter( theEvent, kEventParamDirectObject, typeHICommand, NULL,
								sizeof( HICommand ), NULL, &command );							
								
			if ( command.attributes & kHICommandFromControl ) {
				if ( kEventCommandProcess == GetEventKind( theEvent ) ) {
					switch ( command.commandID ) {
						case kHICommandOK : {
							//result = UIToolkit::mrOK;
						}
						break;
						
						case kHICommandCancel : {
							result = UIToolkit::mrCancel;
						}
						break;
					}
				}
			}					
		}
		
		
		ReleaseEvent(theEvent);
	}
	*/
	
	RunAppModalLoopForWindow( controlWindow );
	
	
	//EndAppModalStateForWindow( controlWindow );
	
    return result;
}

void OSXUIToolkit::internal_quitCurrentEventLoop()
{
    EventLoopRef currentLoop = GetCurrentEventLoop();
    QuitEventLoop( currentLoop );
    quitEventLoop_ = true;
}

OSStatus OSXUIToolkit::handleOSXApplicationEvents( EventHandlerCallRef nextHandler, EventRef osxEvent, void* userData )
{
    OSXUIToolkit * toolkit = (OSXUIToolkit*)userData;
    return toolkit->handleAppEvents( nextHandler, osxEvent );
}

OSStatus OSXUIToolkit::handleAppEvents( EventHandlerCallRef nextHandler, EventRef osxEvent )
{
    OSStatus result = eventNotHandledErr;
    switch ( GetEventClass( osxEvent ) ) {
        case OSXUIToolkit::CustomEventClass : {
            switch ( GetEventKind( osxEvent ) ) {
                case OSXUIToolkit::EventPosted : {
                    ::CallNextEventHandler( nextHandler, osxEvent );

                    UInt32 val;
                    Boolean deleteHandler;
                    OSStatus err = GetEventParameter( osxEvent,
                                        OSXUIToolkit::EventHandler,
                                        typeUInt32,
                                        NULL,
                                        OSXUIToolkit::SizeOfEventHandler,
                                        NULL,
                                        &val );

                    VCF::EventHandler* eventHandler  = (VCF::EventHandler*)val;

                    err = GetEventParameter( osxEvent,
                                        OSXUIToolkit::EventHandlerEvent,
                                        typeUInt32,NULL,
                                        OSXUIToolkit::SizeOfEventHandlerEvent,NULL,
                                        &val );


                    Event* e = (Event*)val;

                    err = GetEventParameter( osxEvent,
                                        OSXUIToolkit::DeletePostedEvent,
                                        typeBoolean,NULL,
                                        OSXUIToolkit::SizeOfDeletePostedEvent,NULL,
                                        &deleteHandler );


                    if ( (NULL != eventHandler) && (NULL != e ) ) {

                        eventHandler->invoke( e );

                        if ( deleteHandler ) {
                            delete eventHandler;
                        }
                        delete e;
                    }

                    result = noErr;
                }
                break;
            }
        }
        break;

		case kEventClassCommand : {
			switch ( GetEventKind( osxEvent ) ) {
				case kEventProcessCommand : {
					HICommand		command;
					GetEventParameter( osxEvent, kEventParamDirectObject, typeHICommand, NULL,
									sizeof( HICommand ), NULL, &command );
									
					MenuItem* item = NULL;
					GetMenuCommandProperty( command.menu.menuRef, 
										command.commandID,
										VCF_PROPERTY_CREATOR, 
										OSXMenuItem::propertyTag,
										sizeof(item),
										NULL, &item );
					
								
					if ( NULL != item ) {
						//cause the menu click method to be called!
						item->click();
						result = noErr;
					}										
                }
                break;
				
				case kEventCommandUpdateStatus : {
					HICommand		command;
					GetEventParameter( osxEvent, kEventParamDirectObject, typeHICommand, NULL,
									sizeof( HICommand ), NULL, &command );
									
					MenuItem* item = NULL;
					GetMenuCommandProperty( command.menu.menuRef, 
										command.commandID,
										VCF_PROPERTY_CREATOR, 
										OSXMenuItem::propertyTag,
										sizeof(item),
										NULL, &item );
					
					
					result = ::CallNextEventHandler( nextHandler, osxEvent );
								
					if ( NULL != item ) {					
						//cause the menu update method to be called!
						//this updates the menu item
						item->update();
					}										
                }
                break;
			}
		}
		break;
		
        default : {
            return ::CallNextEventHandler( nextHandler, osxEvent );
        }
        break;
    }

    return result;
}




VCF::Event* OSXUIToolkit::internal_createEventFromNativeOSEventData( void* eventData )
{
    VCF::Event* result = NULL;
    OSXEventMsg* msg = (OSXEventMsg*)eventData;
    UInt32 whatHappened = GetEventKind( msg->osxEvent_ );

    UInt32 type = GetEventClass( msg->osxEvent_ );