imageconverterappui.cpp

这个源代码是symbian下实现图片旋转及缩放的例子代码。对图片处理时有帮助。

/*
* ============================================================================
*  Name     : CImageConverterAppUi from ImageConverterAppUi.cpp
*  Part of  : ImageConverter
*  Created  : May 14, 2006 by Forum Nokia
*  Version  : 2.0
*  Copyright: Nokia Corporation
* ============================================================================
*/

// INCLUDE FILES
#include "ImageConverterAppUi.h"
#include "ImageConverterContainer.h" 
#include "ImageConverterEngine.h"
#include <ImageConverter.rsg>
#include "imageconverter.hrh"
#include "encoderselectiondialog.h"
#include "showinfodialog.h"

#include <avkon.hrh>
#include <caknfileselectiondialog.h>
#include <akncommondialogs.h>
#include <imageconversion.h>
#include <eikmenup.h>
#include <aknglobalnote.h>

const TInt KScaleUpFactor = 110;   // Scale up by 10%
const TInt KScaleDownFactor = 90;  // Scale down by 10%
const TInt KMaxInfoMsgLength = 50;

// We specify a custom cleanup method for the RImageTypeDescriptionArray used
// in CImageConverterAppUi::HandleSaveAsL(). This way we can, in that method, 
// simply call CleanupStack::PopAndDestroy() on the array and do whatever 
// additional cleanup we need here. In this case ResetAndDestroy() is called 
// on the array to release resources consumed by it.
// In general, creating a custom cleanup method allows cleanup to be more 
// sophisticated than simply deleting objects, for example, releasing access to 
// some shared resource.
void CleanupRArray( TAny* object )
    {
    ((RImageTypeDescriptionArray*)object)->ResetAndDestroy();
    }

// ================= MEMBER FUNCTIONS =======================
//
// ----------------------------------------------------------
// CImageConverterAppUi::ConstructL()
// 
// ----------------------------------------------------------
//
void CImageConverterAppUi::ConstructL()
    {
    BaseConstructL(EAknEnableSkin);

    iAppContainer = new (ELeave) CImageConverterContainer;
    iAppContainer->SetMopParent( this );
    iAppContainer->ConstructL( ClientRect() );
    AddToStackL( iAppContainer );   
    
    iImageLoaded = EFalse;
    iConverter = CImageConverterEngine::NewL( this );
    }

// ----------------------------------------------------
// CImageConverterAppUi::~CImageConverterAppUi()
// Destructor
// Frees reserved resources
// ----------------------------------------------------
//
CImageConverterAppUi::~CImageConverterAppUi()
    {
    if (iAppContainer)
        {
        RemoveFromStack( iAppContainer );
        delete iAppContainer;
        }
 
    if (iConverter)
        {
	    iConverter->Cancel();
        delete iConverter;
        }
    }

// ----------------------------------------------------
// CImageConverterAppUi::DynInitMenuPaneL(
//    TInt aResourceId,CEikMenuPane* aMenuPane)
// Handle dynamic menu initialization
// ----------------------------------------------------
//
void CImageConverterAppUi::DynInitMenuPaneL(
    TInt aResourceId,CEikMenuPane* aMenuPane)
    {
    if( aResourceId == R_IMAGECONVERTER_MENU ) 
        {
        if( !iImageLoaded ) 
            {
            // if there is no image loaded do not show "save as" and
            // "info" menu entries
            aMenuPane->SetItemDimmed( EImageConverterCmdSaveAs, true );
            aMenuPane->SetItemDimmed( EImageConverterCmdInfo, true );
            }
        else 
            {
            aMenuPane->SetItemDimmed( EImageConverterCmdSaveAs, false );
            aMenuPane->SetItemDimmed( EImageConverterCmdInfo, false );
            }
        }
    }

// ----------------------------------------------------
// CImageConverterAppUi::HandleKeyEventL(
//     const TKeyEvent& aKeyEvent,TEventCode /*aType*/)
// takes care of key event handling
// ----------------------------------------------------
//
TKeyResponse CImageConverterAppUi::HandleKeyEventL(
    const TKeyEvent& aKeyEvent,TEventCode aType)
    {
    // if there is an image loaded, pressing arrow keys causes
    // scale and rotate
    if( iImageLoaded &&
        (aType == EEventKey) ) 
        {
        if( aKeyEvent.iCode == EKeyLeftArrow ) 
            {
            iImageLoaded = false;
            iConverter->Rotate( CImageConverterEngine::EAntiClockwise90 );
            return EKeyWasConsumed;
            }
        else if( aKeyEvent.iCode == EKeyRightArrow ) 
            {
            iImageLoaded = false;
            iConverter->Rotate( CImageConverterEngine::EClockwise90 );
            return EKeyWasConsumed;
            }
        else if( aKeyEvent.iCode == EKeyUpArrow ) 
            {
            iImageLoaded = false;
            iConverter->Scale( KScaleUpFactor ); // scale up
            return EKeyWasConsumed;
            }
        else if( aKeyEvent.iCode == EKeyDownArrow ) 
            {
            iImageLoaded = false;
            iConverter->Scale( KScaleDownFactor ); // scale down
            return EKeyWasConsumed;
            }
        }
    return EKeyWasNotConsumed;
    }

// ----------------------------------------------------
// CImageConverterAppUi::HandleCommandL(TInt aCommand)
// takes care of command handling
// ----------------------------------------------------
//
void CImageConverterAppUi::HandleCommandL(TInt aCommand)
    {
    switch ( aCommand )
        {
        case EAknSoftkeyBack:
        case EEikCmdExit:
            {
            Exit();
            break;
            }
 	    case EImageConverterCmdOpen:
	        {
            HandleOpenL();
            break;
            }
        case EImageConverterCmdSaveAs:
            {
            HandleSaveAsL();
            break;
            }
        case EImageConverterCmdInfo:
            {
            HandleInfoL();
            break;
            }
        default:
            break;      
        }
    }

// ----------------------------------------------------
// CImageConverterAppUi::HandleOpenL( )
// Handle open command
// ----------------------------------------------------
//
void CImageConverterAppUi::HandleOpenL( )
    {
    TFileName fileToOpen;
	
    _LIT( KFileSelectionTitle, "Select image to open" );
	
    // show fileopen dialog from akncommondialogs
    if( !AknCommonDialogs::RunSelectDlgLD(fileToOpen, 
        R_MEMORY_SELECTION_DIALOG, KFileSelectionTitle) ) 
        {
        return;
        }

    iImageLoaded = false;
    iAppContainer->SetBitmap(NULL);	

    // request the actuall open/decode
    // asynchronous, the result is reported via callback
    // NotifyCompletion
    TRAPD( err, iConverter->StartToDecodeL(fileToOpen) );

    // report errors in issuing the asynchronous call
    if( err != KErrNone ) 
        {
        _LIT( KMsg, "Error when starting to decode:%d" );
        TBuf<KMaxInfoMsgLength> buf;
        buf.Format( KMsg, err );
        ShowMessage(buf);
        }
    }

// ----------------------------------------------------
// CImageConverterAppUi::HandleSaveAsL()
// Handle save command
// ----------------------------------------------------
//
void CImageConverterAppUi::HandleSaveAsL()
    {
    // get encoder types from engine
    RImageTypeDescriptionArray imageTypes; 
    iConverter->GetEncoderImageTypesL( imageTypes);	
    
    // Create a custom cleanup item and specify CleanupRArray to be the
    // method that is called once we call CleanupStack::PopAndDestroy() at the
    // end of this method.
    CleanupStack::PushL( TCleanupItem(CleanupRArray, &imageTypes) );

    TInt selectedIdx = 0;

    // show the encoder types in a dialog
    CEncoderSelectionDialog* dialog = 
        new(ELeave) CEncoderSelectionDialog( imageTypes, 
                                            selectedIdx );

    if( dialog->ExecuteLD(R_IMAGECONVERTER_TYPESELECTION_DIALOG) ) 
        {
        TFileName fileToSave;
        // Append the correct file extension (.gif, .jpeg, .bmp or such 
        // according to the type selection)
        _LIT(KDot, ".");
        fileToSave.Append(KDot);
        fileToSave.Append(imageTypes[selectedIdx]->Description());
        
        if( AknCommonDialogs::RunSaveDlgLD(fileToSave, 
            R_MEMORY_SELECTION_DIALOG) ) 
            {			
            // request the actuall save/encode
            // asynchronous, the result is reported via callback
            // NotifyCompletion
            TRAPD( err, iConverter->StartToEncodeL(fileToSave, 
                imageTypes[selectedIdx]->ImageType(),
                imageTypes[selectedIdx]->SubType()) );
            // report errors in issuing the asynchronous call
            if( err != KErrNone ) 
                {
                _LIT( KMsg, "Error when starting to decode:%d" );
                TBuf<KMaxInfoMsgLength> buf;
                buf.Format( KMsg, err );
                ShowMessage( buf );
                }
            }
        }
	
    // This will lead to a call to CleanupRArray, our custom cleanup method.
    CleanupStack::PopAndDestroy(&imageTypes);
    }

// ----------------------------------------------------
// CImageConverterAppUi::HandleInfoL()
// Handle info command
// ----------------------------------------------------
//
void CImageConverterAppUi::HandleInfoL()
    {
    // get the info strings
    CFrameInfoStrings* infoStrings = iConverter->GetImageInfoL();

    CleanupStack::PushL( infoStrings );

    // show the info strings in a separate dialog
    CShowInfoDialog* dialog = new(ELeave) CShowInfoDialog( infoStrings );

    dialog->ExecuteLD( R_IMAGECONVERTER_SHOWINFO_DIALOG );

    CleanupStack::PopAndDestroy(infoStrings); // infoStrings
    }

// ----------------------------------------------------
// CImageConverterAppUi::NotifyCompletion( TInt aErr, 
//                const TDesC& aMsg )
// Handle completion notifications
// ----------------------------------------------------
//
void CImageConverterAppUi::NotifyCompletion( TInt aErr, const TDesC& aMsg ) 
    {
    if( aErr == KErrNone ) 
        {
        // we have succesfully decoded an image, now make the view
        // to display it
        iAppContainer->SetBitmap(iConverter->GetBitmap());
        iImageLoaded = true;
        }
    else 
        {
        iAppContainer->SetBitmap(NULL);
        iImageLoaded = false;
        }
    iAppContainer->DrawNow();
    ShowMessage(aMsg);
    }

// ----------------------------------------------------
// CImageConverterAppUi::ShowMessage(const TDesC& aMsg) const
// Show a message to the user
// ----------------------------------------------------
//
void CImageConverterAppUi::ShowMessage(const TDesC& aMsg) const
    {
    if (aMsg.Length())  // If there's something to show, otherwise do nothing
        {
        // No need to react if this leaves, just trap
        TRAPD(err, ShowMessageL(aMsg));
        }
    }
// ----------------------------------------------------
// CImageConverterAppUi::ShowMessageL(const TDesC& aMsg) const
// Show a message to the user
// ----------------------------------------------------
//
void CImageConverterAppUi::ShowMessageL(const TDesC& aMsg) const
    {
    CAknGlobalNote* note = CAknGlobalNote::NewLC();
    note->ShowNoteL(EAknGlobalConfirmationNote, aMsg);
    CleanupStack::PopAndDestroy(note);
    }

// End of File