/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:   File Implements the various input events, including custom events.
*
*/


#include <alf/alfenv.h>
#include <alf/alfevent.h>
#include <alf/alfvisual.h>
#include <osn/osncommon.h>
#include "alf/alfreferencetovisual.h"
#include <alf/alfexceptions.h>
#include "alf/alfattribute.h"
#include "alf/alfwidget.h"
#include "alf/ialfattributeowner.h"
#include <alf/alfwidgetevents.h>
#include <alf/alfwidgetcommand.h>
#include "alfeventinput.h"

namespace Alf
    {


// ======== LOCAL FUNCTIONS ========

// ======== MEMBER FUNCTIONS ========

AlfEventInput::AlfEventInput(int aEvtTypeFlags,int aEventID,int aEventData, int aKeyEventModifiers)
    {
    mEventTypeFlags = aEvtTypeFlags;
    mEventID = aEventID;
    mEventData = aEventData;
    mKeyEventModifiers = aKeyEventModifiers;
    }

// ---------------------------------------------------------------------------
// ?implementation_description
// ---------------------------------------------------------------------------
//
bool AlfEventInput::accept( const TAlfEvent& aEvent ) const
    {
    bool ret = false;

	// Custom event
    if ( aEvent.Type() == TAlfEvent::ETypeCustom &&
            ( mEventTypeFlags & custom ) &&
            aEvent.CustomParameter() == mEventID )
        {
        // If event data is defined to be used, it must match also
        if ( ( mEventTypeFlags & useEventData ) == 0 ||
                aEvent.CustomEventData() == mEventData )
            {
            ret = true;
            }
        }
    // Key event
    else if( aEvent.Type() == TAlfEvent::ETypeKey &&
              ( mEventTypeFlags & custom ) == 0 &&
    		   aEvent.KeyEvent().iScanCode == mEventID )
        {
        // Test that key event up/down matches
        
        // keyDown triggers from EEventKey event.
        // keyUp triggers from EEventKeyUp event.
        
        if ( ( mEventTypeFlags & keyDown &&
               aEvent.Code() == EEventKey ) ||
             ( mEventTypeFlags & keyUp &&
               aEvent.Code() == EEventKeyUp ) )
        	{
        	// Set trigger status true first, match checks will change it to false if no match.
        	ret = true;

            // If no modifiers requested, no need to check anything
            if ( mKeyEventModifiers )
                {                
            	uint receivedModifiers = aEvent.KeyEvent().iModifiers;
            	
            	while ( true )
            	    {
                	if ( mKeyEventModifiers & alt )
                	    {
            	        if ( !(receivedModifiers & (eventBitLeftAlt|eventBitRightAlt|eventBitAlt)) )
            	            {
            	            ret = false;
            	            break;
            	            }
               	        }
                	if ( mKeyEventModifiers & ctrl )
            	        {
            	        if ( !(receivedModifiers & (eventBitLeftCtrl|eventBitRightCtrl|eventBitCtrl)) )
            	            {
            	            ret = false;
            	            break;
            	            }        	        
            	        }
                	if ( mKeyEventModifiers & shift )
                	    {
            	        if ( !(receivedModifiers & (eventBitLeftShift|eventBitRightShift|eventBitShift)) )
            	            {
                	        ret = false;
                	        break;
                	        }        	        
                	    }
                	if ( mKeyEventModifiers & func )
                	    {
            	        if ( !(receivedModifiers & (eventBitLeftFunc|eventBitRightFunc|eventBitFunc)) )
            	            {
                	        ret = false;
                	        break;
                	        }        	    
                	    }
                	    
                	break;
            	    }
                	    
               	if ( mKeyEventModifiers & capsLock && !(receivedModifiers & eventBitCapsLock) )
               	    {
               	    ret = false;
               	    }
               	    
               	if ( mKeyEventModifiers & numLock && !(receivedModifiers & eventBitNumLock) )
               	    {
               	    ret = false;
               	    }
               	    
               	if ( mKeyEventModifiers & scrollLock && !(receivedModifiers & eventBitScrollLock) )
               	    {
               	    ret = false;
               	    }
                }
        	}
        }

    return ret;
    }

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
AlfPointerEventInput::AlfPointerEventInput()
    {
    }

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
AlfPointerEventInput::AlfPointerEventInput( const char* aElementName, 
                                            const char* aVisualName,
                                            WidgetPointerEvent aEvent )
    {
    mVisualRef.reset(AlfReferenceToVisual::create(aElementName, aVisualName, true ));
    mEvent = aEvent;
    }

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
AlfPointerEventInput::~AlfPointerEventInput()
    {
    }

// ---------------------------------------------------------------------------
// ?implementation_description
// ---------------------------------------------------------------------------
//
bool AlfPointerEventInput::accept(
    CAlfWidgetControl& aControl, const TAlfEvent& aEvent ) const
    {
    // Check whether the tapped visual matches with element and visual names
    // of this pointer event input.
    bool ret = false;

    // map OSN pointer event to TPointerEvent::TType
    TPointerEvent::TType eventType = TPointerEvent::EButton1Down;
    switch (mEvent)
        {
        case pointerEventDown:
            eventType = TPointerEvent::EButton1Down;
            break;
        case pointerEventUp:
            eventType = TPointerEvent::EButton1Up;
            break;
        case pointerEventDrag:
            eventType = TPointerEvent::EDrag;
            break;
        default:
            break;
        }
    
    ret = aEvent.IsPointerEvent() && 
          (eventType == aEvent.PointerEvent().iType) && 
          mVisualRef->resolve( aControl, aEvent.Visual());

    return ret;
    }
// ---------------------------------------------------------------------------
// Class AlfWidgetAttributeInput
// ---------------------------------------------------------------------------
//
AlfWidgetAttributeInput::AlfWidgetAttributeInput( AlfAttribute& aAttribute,
	    const char* aElementId )
	    {
	    mAttr = &aAttribute;
	    mElementId = "";
	    if (aElementId)   
	        {
	        mElementId = aElementId;
	        }
	    }

AlfWidgetAttributeInput::AlfWidgetAttributeInput()
    {
    }

AlfWidgetAttributeInput::~AlfWidgetAttributeInput()
    {
    delete mAttr;
    }
    
bool AlfWidgetAttributeInput::accept(const TAlfEvent& aEvent) const
    {
    bool accept(false);
    
    if (aEvent.IsCustomEvent())
        {
        unsigned int eventID = aEvent.CustomParameter(); 
        if (eventID == EEventWidgetAttributeChanged)
            {
            TAlfWidgetAttributeCommand* command = 
                (TAlfWidgetAttributeCommand*)aEvent.CustomEventData();
            AlfAttribute* attribute = command->mOwnedAttribute;
            const char* name = attribute->name();
            const char* targetelement = command->mTarget.getUtf8();
                        
            accept = true;
            if (!mElementId.isEmpty() && targetelement)
            	{
	            if ( strcmp(mElementId.getUtf8(), targetelement) )
	                {
	                accept = false;
	                }
            	}
            
            if (accept)
            	{
            	accept= false;
	            if (!strcmp(mAttr->name(), name))
	                {
	                accept = true;
	                }
            	}
            }
        }
    
    return accept;
    }    
// ---------------------------------------------------------------------------
// Class AlfEventPasserInput
// ---------------------------------------------------------------------------
//
// AlfEventInput could be used instead of this class, it contains all the same
// functionality! 
//
AlfEventPasserInput::AlfEventPasserInput( int aEventId, int aEventData  )
    {
    mEventId = aEventId;
    mEventData = aEventData;//not used yet...
    }

AlfEventPasserInput::AlfEventPasserInput()
    {
    }

AlfEventPasserInput::~AlfEventPasserInput()
    {
    }
    
bool AlfEventPasserInput::accept( const TAlfEvent& aEvent ) const
    {
    // check whether the event matches to the one we need to pass to another widget

    return aEvent.IsCustomEvent() &&
        aEvent.CustomParameter() == mEventId;    
    }    
        
    }//Alf

// End of File.