Crop fit to mode implementation and fixed Jira issue

Change-Id: I9ea10a5c07d5d70615f451c5f1af3c8c6ec190eb
Signed-off-by: chitta ranjan <chitta.rs@samsung.com>

diff --git a/inc/IvImageCropForm.h b/inc/IvImageCropForm.h
index 036d6fd..c04217a 100644 (file)
--- a/inc/IvImageCropForm.h
+++ b/inc/IvImageCropForm.h
@@ -24,6 +24,7 @@
 
 #include <FMedia.h>
 #include <FUi.h>
+#include "IvFileUpdateEventListener.h"
 
 using namespace Tizen::Ui;
 
@@ -49,6 +50,7 @@ class ImageCropForm
        , public Tizen::Ui::IOrientationEventListener
        , public Tizen::Ui::ITouchEventListener
        , public Tizen::Ui::Scenes::ISceneEventListener
+       , public IFileUpdateEventListener
 {
 public:
        ImageCropForm(void);
@@ -79,6 +81,8 @@ public:
        virtual void OnSceneDeactivated(const Tizen::Ui::Scenes::SceneId& currentSceneId,
                        const Tizen::Ui::Scenes::SceneId& nextSceneId);
 
+       virtual void OnFormFileEventOccuered(const int index, const unsigned long eventId);
+
 private:
        static const int IDA_BUTTON_SAVE = 105;
        static const int IDA_BUTTON_CW_ROTATION = 102;
@@ -87,6 +91,7 @@ private:
 
        Tizen::Graphics::Rectangle __cropBox;
        Tizen::Base::String __sourceFilePath;
+       Tizen::Base::String __cropMode;
        Tizen::Graphics::Rectangle __imageBox;
        Tizen::Media::ImageBuffer __imageBuffer;
        int __imageHeight;
@@ -99,6 +104,10 @@ private:
        Tizen::Graphics::Point __touchStart;
        Tizen::Media::ImageFormat __imageFormat;
        ImageViewerPresentationModel* __pPresentationModel;
+       int __statusValue;
+       long long __contentId;
+       int __formHeight;
+       int __formWidth;
 };
 
 #endif /* _IV_IMAGE_CROP_H_ */

diff --git a/inc/IvImageViewerPresentationModel.h b/inc/IvImageViewerPresentationModel.h
index 3159505..33a2242 100644 (file)
--- a/inc/IvImageViewerPresentationModel.h
+++ b/inc/IvImageViewerPresentationModel.h
@@ -60,6 +60,7 @@ public:
        Tizen::Base::String GetFilePathAt(const int index) const;
        Tizen::Base::Collection::ArrayList* GetImageCache() const;
        ImageInfo* GetImageCacheAt(const int index) const;
+       void AddImageCache(const Tizen::Base::String& filePath);
        void SetImageCacheAt(const int index, const Tizen::Base::String& filePath);
 
        int GetFileCount(void) const;

diff --git a/src/IvImageCropForm.cpp b/src/IvImageCropForm.cpp
index cdb63e8..8b277f9 100644 (file)
--- a/src/IvImageCropForm.cpp
+++ b/src/IvImageCropForm.cpp
@@ -21,6 +21,8 @@
 
 #include <FApp.h>
 #include <FMedia.h>
+#include <FSystem.h>
+#include <FSocial.h>
 #include "IvImageCropForm.h"
 #include "IvImageViewerPresentationModel.h"
 #include "IvResourceManager.h"
@@ -33,6 +35,8 @@ using namespace Tizen::Content;
 using namespace Tizen::Graphics;
 using namespace Tizen::Io;
 using namespace Tizen::Media;
+using namespace Tizen::System;
+using namespace Tizen::Social;
 using namespace Tizen::Ui::Controls;
 using namespace Tizen::Ui::Scenes;
 
@@ -134,6 +138,7 @@ ImageCropForm::OnInitializing(void)
        }
        AddTouchEventListener(*this);
        AddOrientationEventListener(*this);
+       __pPresentationModel->AddFileUpdateListener(this);
 
        delete pCWRotationButtonBitmap;
        delete pCCWRotationButtonBitmap;
@@ -144,20 +149,101 @@ void
 ImageCropForm::OnSceneActivatedN(const SceneId& previousSceneId, const SceneId& currentSceneId, IList* pArgs)
 {
        AppLogDebug("ENTER pArgs(%x)", pArgs);
-       String filePath;
        if (pArgs != null)
        {
-               filePath = *(static_cast<String*>(pArgs->GetAt(0)));
-               delete pArgs;
-       }
-       else
-       {
-               filePath = __pPresentationModel->GetFilePathAt(0);
-       }
+               IEnumerator* pEnum = pArgs->GetEnumeratorN();
+               if (pEnum->MoveNext() != E_SUCCESS)
+               {
+                       delete pEnum;
+                       delete pArgs;
+                       AppLogDebug("EXIT 1(%s)", GetErrorMessage(GetLastResult()));
 
-       if (filePath.IsEmpty() == false)
-       {
-               __sourceFilePath.Append(filePath);
+                       return;
+               }
+               __sourceFilePath = *(static_cast<String*>(pEnum->GetCurrent()));
+               if (__sourceFilePath.IsEmpty() == false)
+               {
+                       result r = __imageBuffer.Construct(__sourceFilePath.GetPointer());
+                       if (r == E_SUCCESS)
+                       {
+                               __imageWidth = __imageBuffer.GetWidth();
+                               __imageHeight = __imageBuffer.GetHeight();
+                               __pCurrentBitmap = __imageBuffer.GetBitmapN(BITMAP_PIXEL_FORMAT_RGB565, BUFFER_SCALING_AUTO);
+                       }
+                       Image img;
+                       __imageFormat = img.GetImageFormat(__sourceFilePath);
+               }
+               if (pEnum->MoveNext() != E_SUCCESS)
+               {
+                       delete pEnum;
+                       delete pArgs;
+                       AppLogDebug("EXIT 2(%s)", GetErrorMessage(GetLastResult()));
+
+                       return;
+               }
+               __cropMode = *(static_cast<String*>(pEnum->GetCurrent()));
+               if (__cropMode.IsEmpty() == false)
+               {
+                       __cropMode.ToLowerCase();
+                       if (__cropMode == "auto")
+                       {
+                               delete pEnum;
+                               delete pArgs;
+                               SetValue();
+                               return;
+                       }
+                       else if (__cropMode == "fit-to-screen")
+                       {
+                               if (pEnum->MoveNext() != E_SUCCESS)
+                               {
+                                       delete pEnum;
+                                       delete pArgs;
+                                       AppLogDebug("EXIT 3(%s)", GetErrorMessage(GetLastResult()));
+
+                                       return;
+                               }
+                               Integer *pStatus = static_cast<Integer*>(pEnum->GetCurrent());
+                               if (pStatus != null)
+                               {
+                                       __statusValue = pStatus->ToInt();
+                               }
+                               if (__statusValue == SET_AT_TYPE_CALLER_IMAGE)
+                               {
+                                       if (pEnum->MoveNext() != E_SUCCESS)
+                                       {
+                                               delete pEnum;
+                                               delete pArgs;
+                                               AppLogDebug("EXIT 4(%s)", GetErrorMessage(GetLastResult()));
+
+                                               return;
+                                       }
+
+                                       LongLong* pContentId = static_cast<LongLong*>(pEnum->GetCurrent());
+                                       if (pContentId != null)
+                                       {
+                                               __contentId = pContentId->ToLongLong();
+                                       }
+                               }
+
+                               delete pEnum;
+                               delete pArgs;
+                               SetValue();
+                       }
+               }
+       }
+//     if (pArgs != null)
+//     {
+//             __sourceFilePath = *(static_cast<String*>(pArgs->GetAt(0)));
+//             __cropMode = *(static_cast<String*>(pArgs->GetAt(1)));
+//             delete pArgs;
+//     }
+//     else
+//     {
+//             __sourceFilePath = __pPresentationModel->GetFilePathAt(0);
+//     }
+/*     if (__sourceFilePath.IsEmpty() == false && __cropMode.IsEmpty() == false)
+       {
+               __cropMode.ToLowerCase();
                result r = __imageBuffer.Construct(__sourceFilePath.GetPointer());
                if (r == E_SUCCESS)
                {
@@ -167,7 +253,7 @@ ImageCropForm::OnSceneActivatedN(const SceneId& previousSceneId, const SceneId&
                }
                Image img;
                __imageFormat = img.GetImageFormat(__sourceFilePath);
-       }
+       }*/
        SetValue();
        AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
 }
@@ -213,41 +299,140 @@ ImageCropForm::OnActionPerformed(const Tizen::Ui::Control& source, int actionId)
                break;
        case IDA_BUTTON_SAVE:
        {
-               ImageBuffer* pCropBuffer = null;
-               int count = 1;
-               int index = 0;
-               String destFilePath;
-               String stringToInsert = L"_";
-               String delimiter = L".";
-               if (__sourceFilePath.IsEmpty() == false)
+               if (__cropMode == "auto")
                {
-                       __sourceFilePath.Reverse();
-                       __sourceFilePath.IndexOf(delimiter, 0, index);
-                       __sourceFilePath.Reverse();
-                       __sourceFilePath.Insert(stringToInsert, __sourceFilePath.GetLength() - index - 1);
-                       destFilePath.Append(__sourceFilePath);
-                       destFilePath.Insert(count, destFilePath.GetLength() - index - 1);
-                       while (File::IsFileExist(destFilePath) == true)
-                       {
-                               count++;
-                               destFilePath.Clear();
+                       ImageBuffer* pCropBuffer = null;
+                       int count = 1;
+                       int index = 0;
+                       String destFilePath;
+                       String stringToInsert = L"_";
+                       String delimiter = L".";
+                       if (__sourceFilePath.IsEmpty() == false)
+                       {
+                               __sourceFilePath.Reverse();
+                               __sourceFilePath.IndexOf(delimiter, 0, index);
+                               __sourceFilePath.Reverse();
+                               __sourceFilePath.Insert(stringToInsert, __sourceFilePath.GetLength() - index - 1);
                                destFilePath.Append(__sourceFilePath);
                                destFilePath.Insert(count, destFilePath.GetLength() - index - 1);
+                               while (File::IsFileExist(destFilePath) == true)
+                               {
+                                       count++;
+                                       destFilePath.Clear();
+                                       destFilePath.Append(__sourceFilePath);
+                                       destFilePath.Insert(count, destFilePath.GetLength() - index - 1);
+                               }
+                               pCropBuffer = __imageBuffer.CropN(((__cropBox.x - __imageBox.x) * __imageWidth) / __imageBox.width, ((__cropBox.y - __imageBox.y) * __imageHeight) / __imageBox.height,
+                                               (__cropBox.width * __imageWidth) / __imageBox.width, (__cropBox.height * __imageHeight) / __imageBox.height);
+                               pCropBuffer->EncodeToFile(destFilePath, __imageFormat, true, 100);
+                               ContentManager::ScanFile(destFilePath);
+                               delete pCropBuffer;
                        }
+                       ArrayList* pList = new (std::nothrow) ArrayList(SingleObjectDeleter);
+                       pList->Add(new (std::nothrow) String(destFilePath));
+                       pSceneManager->GoBackward(BackwardSceneTransition(), pList);
+               }
+               else if(__cropMode == "fit-to-screen")
+               {
+                       ImageBuffer* pCropBuffer = null;
+                       result r = E_SUCCESS;
                        pCropBuffer = __imageBuffer.CropN(((__cropBox.x - __imageBox.x) * __imageWidth) / __imageBox.width, ((__cropBox.y - __imageBox.y) * __imageHeight) / __imageBox.height,
-                                               (__cropBox.width * __imageWidth) / __imageBox.width, (__cropBox.height * __imageHeight) / __imageBox.height);
-                       pCropBuffer->EncodeToFile(destFilePath, __imageFormat, true, 100);
-                       ContentManager::ScanFile(destFilePath);
+                                       (__cropBox.width * __imageWidth) / __imageBox.width, (__cropBox.height * __imageHeight) / __imageBox.height);
+                       if (__statusValue == SET_AT_TYPE_HOME_SCREEN_WALLPAPER)
+                       {
+                               String destPath = App::GetInstance()->GetAppRootPath() + TEMP_FILE_PATH_HOME_SCREEN_WALLPAPER;
+                               r = pCropBuffer->EncodeToFile(destPath, __imageFormat, true, 100);
+                               if (r == E_SUCCESS)
+                               {
+                                       r = SettingInfo::SetValue(SETTING_VALUE_HOME_SCREEN_WALLPAPER, destPath);
+                               }
+                               else if (r == E_OVERFLOW)
+                               {
+                                       MessageBox messageBox;
+                                       messageBox.Construct(L"", L"File size is too big", MSGBOX_STYLE_NONE, 3000);
+                                       int modalResult = 0;
+                                       messageBox.ShowAndWait(modalResult);
+                               }
+                       }
+                       else if (__statusValue == SET_AT_TYPE_LOCK_SCREEN_WALLPAPER)
+                       {
+                               String destPath = App::GetInstance()->GetAppRootPath() + TEMP_FILE_PATH_LOCK_SCREEN_WALLPAPER;
+                               r = pCropBuffer->EncodeToFile(destPath, __imageFormat, true, 100);
+                               if (r == E_SUCCESS)
+                               {
+                                       r = SettingInfo::SetValue(SETTING_VALUE_LOCK_SCREEN_WALLPAPER, destPath);
+                               }
+                               else if (r == E_OVERFLOW)
+                               {
+                                       MessageBox messageBox;
+                                       messageBox.Construct(L"", L"File size is too big", MSGBOX_STYLE_NONE, 3000);
+                                       int modalResult = 0;
+                                       messageBox.ShowAndWait(modalResult);
+                               }
+                       }
+                       else if (__statusValue == SET_AT_TYPE_HOME_AND_LOCK_SCREEN_WALLPAPER)
+                       {
+                               String destPath = App::GetInstance()->GetAppRootPath() + TEMP_FILE_PATH_LOCK_SCREEN_WALLPAPER;
+                               String destPathHome = App::GetInstance()->GetAppRootPath() + TEMP_FILE_PATH_HOME_SCREEN_WALLPAPER;
+                               r = pCropBuffer->EncodeToFile(destPath, __imageFormat, true, 100);
+                               r = pCropBuffer->EncodeToFile(destPathHome, __imageFormat, true, 100);
+                               if (r == E_SUCCESS)
+                               {
+                                       r = SettingInfo::SetValue(SETTING_VALUE_LOCK_SCREEN_WALLPAPER, destPath);
+                                       r = SettingInfo::SetValue(SETTING_VALUE_HOME_SCREEN_WALLPAPER, destPathHome);
+                               }
+                               else if (r == E_OVERFLOW)
+                               {
+                                       MessageBox messageBox;
+                                       messageBox.Construct(L"", L"File size is too big", MSGBOX_STYLE_NONE, 3000);
+                                       int modalResult = 0;
+                                       messageBox.ShowAndWait(modalResult);
+                               }
+                       }
+                       else if (__statusValue == SET_AT_TYPE_CALLER_IMAGE)
+                       {
+                               int count = 1;
+                               int index = 0;
+                               String destFilePath;
+                               String stringToInsert = L"_";
+                               String delimiter = L".";
+                               if (__sourceFilePath.IsEmpty() == false)
+                               {
+                                       __sourceFilePath.Reverse();
+                                       __sourceFilePath.IndexOf(delimiter, 0, index);
+                                       __sourceFilePath.Reverse();
+                                       __sourceFilePath.Insert(stringToInsert, __sourceFilePath.GetLength() - index - 1);
+                                       destFilePath.Append(__sourceFilePath);
+                                       destFilePath.Insert(count, destFilePath.GetLength() - index - 1);
+                                       while (File::IsFileExist(destFilePath) == true)
+                                       {
+                                               count++;
+                                               destFilePath.Clear();
+                                               destFilePath.Append(__sourceFilePath);
+                                               destFilePath.Insert(count, destFilePath.GetLength() - index - 1);
+                                       }
+                               }
+                               r = pCropBuffer->EncodeToFile(destFilePath, __imageFormat, true, 100);
+                               ContentManager::ScanFile(destFilePath);
+                               Contact* pContact = null;
+                               AddressbookManager* pAddressbookManager = AddressbookManager::GetInstance();
+                               Addressbook* pAddressbook = null;
+
+                               pAddressbook = pAddressbookManager->GetAddressbookN(DEFAULT_ADDRESSBOOK_ID);
+                               pContact = pAddressbook->GetContactN(__contentId);
+                               pContact->SetThumbnail(destFilePath);
+                               pAddressbook->UpdateContact(*pContact);
+
+                               delete pContact;
+                               delete pAddressbook;
+                       }
                        delete pCropBuffer;
+                       pSceneManager->GoForward(ForwardSceneTransition(IDSCN_IMAGE_VIEWER));
                }
-               ArrayList* pList = new (std::nothrow) ArrayList(SingleObjectDeleter);
-               pList->Add(new (std::nothrow) String(destFilePath));
-               AppLog("Manish %ls", destFilePath.GetPointer());
-               pSceneManager->GoBackward(BackwardSceneTransition(), pList);
-               AppLog("Exit");
        }
        break;
        }
+       AppLog("Exit");
 }
 
 void
@@ -275,128 +460,396 @@ ImageCropForm::OnTouchMoved(const Tizen::Ui::Control& source, const Tizen::Graph
        AppLogDebug("ENTER");
        int deltaX = currentPosition.x - __touchStart.x;
        int deltaY = currentPosition.y - __touchStart.y;
-       switch(__pointLocation)
+       if (__cropMode.Equals("auto", false))
        {
-       case INSIDE_TOP_RECTANGLE:
-       {
-               if ((__cropBox.y + deltaY) > __imageBox.y && deltaY < (__cropBox.height - (CROP_RECTANGLE_HEIGHT * 3)))
+               switch(__pointLocation)
+               {
+               case INSIDE_TOP_RECTANGLE:
                {
-                       __cropBox.y += deltaY;
-                       __cropBox.height -= deltaY;
+                       if ((__cropBox.y + deltaY) > __imageBox.y && deltaY < (__cropBox.height - (CROP_RECTANGLE_HEIGHT * 3)))
+                       {
+                               __cropBox.y += deltaY;
+                               __cropBox.height -= deltaY;
+                       }
                }
-       }
-       break;
+               break;
 
-       case INSIDE_BOTTOM_RECTANGLE:
-       {
-               if ((__cropBox.y + __cropBox.height + deltaY) < (__imageBox.y + __imageBox.height)
-                       && (__cropBox.height + deltaY) > (CROP_RECTANGLE_HEIGHT * 3))
+               case INSIDE_BOTTOM_RECTANGLE:
                {
-                       __cropBox.height += deltaY;
+                       if ((__cropBox.y + __cropBox.height + deltaY) < (__imageBox.y + __imageBox.height)
+                               && (__cropBox.height + deltaY) > (CROP_RECTANGLE_HEIGHT * 3))
+                       {
+                               __cropBox.height += deltaY;
+                       }
                }
-       }
-       break;
+               break;
 
-       case INSIDE_LEFT_RECTANGLE:
-       {
-               if ((__cropBox.x + deltaX) > __imageBox.x && deltaX < __cropBox.width - (CROP_RECTANGLE_HEIGHT * 3))
+               case INSIDE_LEFT_RECTANGLE:
                {
-                       __cropBox.x += deltaX;
-                       __cropBox.width -= deltaX;
+                       if ((__cropBox.x + deltaX) > __imageBox.x && deltaX < __cropBox.width - (CROP_RECTANGLE_HEIGHT * 3))
+                       {
+                               __cropBox.x += deltaX;
+                               __cropBox.width -= deltaX;
+                       }
                }
-       }
-       break;
+               break;
 
-       case INSIDE_RIGHT_RECTANGLE:
-       {
-               if ((__cropBox.x + __cropBox.width + deltaX) < (__imageBox.x + __imageBox.width)
-                       && __cropBox.width + deltaX > (CROP_RECTANGLE_HEIGHT * 3))
+               case INSIDE_RIGHT_RECTANGLE:
                {
-                       __cropBox.width += deltaX;
+                       if ((__cropBox.x + __cropBox.width + deltaX) < (__imageBox.x + __imageBox.width)
+                               && __cropBox.width + deltaX > (CROP_RECTANGLE_HEIGHT * 3))
+                       {
+                               __cropBox.width += deltaX;
+                       }
                }
-       }
-       break;
+               break;
 
-       case INSIDE_TOP_LEFT_RECTANGLE:
-       {
-               if ((__cropBox.y + deltaY) > __imageBox.y && deltaY < (__cropBox.height - (CROP_RECTANGLE_HEIGHT * 3))
-                               && (__cropBox.x + deltaX) > __imageBox.x && deltaX < __cropBox.width - (CROP_RECTANGLE_HEIGHT * 3))
+               case INSIDE_TOP_LEFT_RECTANGLE:
                {
-                       __cropBox.y += deltaY;
-                       __cropBox.height -= deltaY;
-                       __cropBox.x += deltaX;
-                       __cropBox.width -= deltaX;
+                       if ((__cropBox.y + deltaY) > __imageBox.y && deltaY < (__cropBox.height - (CROP_RECTANGLE_HEIGHT * 3))
+                                       && (__cropBox.x + deltaX) > __imageBox.x && deltaX < __cropBox.width - (CROP_RECTANGLE_HEIGHT * 3))
+                       {
+                               __cropBox.y += deltaY;
+                               __cropBox.height -= deltaY;
+                               __cropBox.x += deltaX;
+                               __cropBox.width -= deltaX;
+                       }
                }
-       }
-       break;
+               break;
 
-       case INSIDE_TOP_RIGHT_RECTANGLE:
-       {
-               if ((__cropBox.y + deltaY) > __imageBox.y && deltaY < (__cropBox.height - (CROP_RECTANGLE_HEIGHT * 3))
-                               && (__cropBox.x + __cropBox.width + deltaX) < (__imageBox.x + __imageBox.width) && __cropBox.width + deltaX > (CROP_RECTANGLE_HEIGHT * 3))
+               case INSIDE_TOP_RIGHT_RECTANGLE:
                {
-                       __cropBox.width += deltaX;
-                       __cropBox.y += deltaY;
-                       __cropBox.height -= deltaY;
+                       if ((__cropBox.y + deltaY) > __imageBox.y && deltaY < (__cropBox.height - (CROP_RECTANGLE_HEIGHT * 3))
+                                       && (__cropBox.x + __cropBox.width + deltaX) < (__imageBox.x + __imageBox.width) && __cropBox.width + deltaX > (CROP_RECTANGLE_HEIGHT * 3))
+                       {
+                               __cropBox.width += deltaX;
+                               __cropBox.y += deltaY;
+                               __cropBox.height -= deltaY;
+                       }
                }
-       }
-       break;
+               break;
 
-       case INSIDE_BOTTOM_LEFT_RECTANGLE:
-       {
-               if ((__cropBox.y + __cropBox.height + deltaY) < (__imageBox.y + __imageBox.height) && (__cropBox.height + deltaY) > (CROP_RECTANGLE_HEIGHT * 3)
-                       && (__cropBox.x + deltaX) > __imageBox.x && deltaX < __cropBox.width - (CROP_RECTANGLE_HEIGHT * 3))
+               case INSIDE_BOTTOM_LEFT_RECTANGLE:
                {
-                       __cropBox.x += deltaX;
-                       __cropBox.width -= deltaX;
-                       __cropBox.height += deltaY;
+                       if ((__cropBox.y + __cropBox.height + deltaY) < (__imageBox.y + __imageBox.height) && (__cropBox.height + deltaY) > (CROP_RECTANGLE_HEIGHT * 3)
+                               && (__cropBox.x + deltaX) > __imageBox.x && deltaX < __cropBox.width - (CROP_RECTANGLE_HEIGHT * 3))
+                       {
+                               __cropBox.x += deltaX;
+                               __cropBox.width -= deltaX;
+                               __cropBox.height += deltaY;
+                       }
                }
-       }
-       break;
+               break;
 
-       case INSIDE_BOTTOM_RIGHT_RECTANGLE:
-       {
-               if ((__cropBox.x + __cropBox.width + deltaX) < (__imageBox.x + __imageBox.width) && __cropBox.width + deltaX > (CROP_RECTANGLE_HEIGHT * 3)
-                       && (__cropBox.y + __cropBox.height + deltaY) < (__imageBox.y + __imageBox.height) && (__cropBox.height + deltaY) > (CROP_RECTANGLE_HEIGHT * 3))
+               case INSIDE_BOTTOM_RIGHT_RECTANGLE:
                {
-                       __cropBox.width += deltaX;
-                       __cropBox.height += deltaY;
+                       if ((__cropBox.x + __cropBox.width + deltaX) < (__imageBox.x + __imageBox.width) && __cropBox.width + deltaX > (CROP_RECTANGLE_HEIGHT * 3)
+                               && (__cropBox.y + __cropBox.height + deltaY) < (__imageBox.y + __imageBox.height) && (__cropBox.height + deltaY) > (CROP_RECTANGLE_HEIGHT * 3))
+                       {
+                               __cropBox.width += deltaX;
+                               __cropBox.height += deltaY;
+                       }
                }
-       }
-       break;
+               break;
 
-       case INSIDE_CROPBOX:
-       {
-               if ((__cropBox.x + deltaX) > __imageBox.x)
+               case INSIDE_CROPBOX:
                {
-                       __cropBox.x += deltaX;
+                       if ((__cropBox.x + deltaX) > __imageBox.x)
+                       {
+                               __cropBox.x += deltaX;
+                       }
+                       else
+                       {
+                               __cropBox.x = __imageBox.x;
+                       }
+                       if ((__cropBox.y + deltaY) > __imageBox.y)
+                       {
+                               __cropBox.y += deltaY;
+                       }
+                       else
+                       {
+                               __cropBox.y = __imageBox.y;
+                       }
+                       if ((__cropBox.x + __cropBox.width + deltaX) > (__imageBox.x + __imageBox.width))
+                       {
+                               __cropBox.x = __imageBox.x + __imageBox.width - __cropBox.width;
+                       }
+                       if ((__cropBox.y + __cropBox.height + deltaY) > (__imageBox.y + __imageBox.height))
+                       {
+                               __cropBox.y = __imageBox.y + __imageBox.height - __cropBox.height;
+                       }
                }
-               else
+               break;
+
+               default:
+                       break;
+               }
+       }
+       else if (__cropMode != "auto")
+       {
+               if (__pointLocation == INSIDE_LEFT_RECTANGLE || __pointLocation == INSIDE_BOTTOM_LEFT_RECTANGLE
+                       || __pointLocation == INSIDE_TOP_LEFT_RECTANGLE)
                {
-                       __cropBox.x = __imageBox.x;
+                       int temp = __cropBox.height;
+                       int height = (__formHeight * (__cropBox.width - (2 * deltaX))) /__formWidth;
+                       temp = height - temp;
+                       if ((__cropBox.width - (2 * deltaX) > (CROP_RECTANGLE_HEIGHT * 3)) && (!(height >= __imageBox.height || (__cropBox.width - (2 * deltaX)) >= __imageBox.width)))
+                       {
+                               if (__cropBox.x + deltaX >= __imageBox.x && __cropBox.x + __cropBox.width - deltaX <= __imageBox.x + __imageBox.width
+                                       && __cropBox.y - (temp / 2) >= __imageBox.y && __cropBox.y + __cropBox.height + (temp / 2) < __imageBox.y + __imageBox.height
+                                       && (__cropBox.width - (2 * deltaX) > (CROP_RECTANGLE_HEIGHT * 3)))
+                               {
+                                       __cropBox.x += deltaX;
+                                       __cropBox.width = __cropBox.width - (2 * deltaX);
+                                       __cropBox.height = height;
+                                       __cropBox.y = __cropBox.y - (temp / 2);
+                               }
+                               else if ((__cropBox.y + __cropBox.height) <= (__imageBox.y + __imageBox.height)
+                                               && __cropBox.width < __imageBox.width
+                                               && __cropBox.x + deltaX >= __imageBox.x && __cropBox.y - temp >= __imageBox.y )
+                               {
+                                       if (__cropBox.x + __cropBox.width - deltaX <= __imageBox.x + __imageBox.width
+                                               && __cropBox.x + deltaX >= __imageBox.x)
+                                       {
+                                               __cropBox.x += deltaX;
+                                       }
+                                       else
+                                       {
+                                               __cropBox.x = __cropBox.x + (2 * deltaX);
+                                       }
+                                       __cropBox.width = __cropBox.width - (2 * deltaX);
+                                       __cropBox.height = height;
+                                       __cropBox.y = __cropBox.y - temp;
+                               }
+                               else if (__cropBox.y - (temp / 2) <= __imageBox.y && __cropBox.width - (deltaX) <= __imageBox.width
+                                               && __cropBox.x + deltaX >= __imageBox.x && __cropBox.y + __cropBox.height + temp <= __imageBox.y + __imageBox.height)
+                               {
+                                       if (__cropBox.x + __cropBox.width - deltaX <= __imageBox.x + __imageBox.width)
+                                       {
+                                               __cropBox.x += deltaX;
+                                       }
+                                       else
+                                       {
+                                               __cropBox.x = __cropBox.x + (2 * deltaX);
+                                       }
+                                       __cropBox.width = __cropBox.width - (2 * deltaX);
+                                       __cropBox.height = height;
+                               }
+                       }
                }
-               if ((__cropBox.y + deltaY) > __imageBox.y)
+               else if (__pointLocation == INSIDE_RIGHT_RECTANGLE || __pointLocation == INSIDE_BOTTOM_RIGHT_RECTANGLE
+                               || __pointLocation == INSIDE_TOP_RIGHT_RECTANGLE)
                {
-                       __cropBox.y += deltaY;
+                       deltaX *= -1;
+
+                       int temp = __cropBox.height;
+                       int height = (__formHeight * (__cropBox.width - (2 * deltaX))) / __formWidth;
+                       temp = height - temp;
+                       if ((__cropBox.width - (2 * deltaX) > (CROP_RECTANGLE_HEIGHT * 3)) && (!(height >= __imageBox.height || (__cropBox.width - (2 * deltaX)) >= __imageBox.width)))
+                       {
+                               if (deltaX < __cropBox.width - (CROP_RECTANGLE_HEIGHT * 3))
+                               {
+                                       if (__cropBox.x + deltaX > __imageBox.x && __cropBox.x + __cropBox.width - deltaX <= __imageBox.x + __imageBox.width
+                                               && __cropBox.y - (temp / 2) > __imageBox.y && __cropBox.y + __cropBox.height + (temp / 2) < __imageBox.y + __imageBox.height)
+                                       {
+                                               __cropBox.x += deltaX;
+                                               __cropBox.width = __cropBox.width - (2 * deltaX);;
+                                               __cropBox.height = height;
+                                               __cropBox.y = __cropBox.y - (temp / 2);
+                                       }
+                                       else if ((__cropBox.y + __cropBox.height + (temp / 2)) >= (__imageBox.y + __imageBox.height)
+                                                       && __cropBox.x + __cropBox.width - (2 * deltaX) <= __imageBox.x + __imageBox.width
+                                                       && __cropBox.x - deltaX >= __imageBox.x && __cropBox.y - temp >= __imageBox.y )
+                                       {
+                                               if (__cropBox.x + __cropBox.width - deltaX <= __imageBox.x + __imageBox.width
+                                                       && __cropBox.x + deltaX >= __imageBox.x)
+                                               {
+                                                       __cropBox.x += deltaX;
+                                               }
+                                               else
+                                               {
+                                                       __cropBox.width = __cropBox.width - (2 * deltaX);
+                                               }
+                                               __cropBox.width = __cropBox.width - (2 * deltaX);
+                                               __cropBox.height = height;
+                                               __cropBox.y = __cropBox.y - temp;
+                                       }
+                                       else if (__cropBox.y - (temp / 2) <= __imageBox.y && __cropBox.width - (deltaX) <= __imageBox.width
+                                                       && __cropBox.x + deltaX <= __imageBox.x && __cropBox.y + __cropBox.height + temp <= __imageBox.y + __imageBox.height)
+                                       {
+                                               if (__cropBox.x + deltaX >= __imageBox.x)
+                                               {
+                                                       __cropBox.x += deltaX;
+                                               }
+                                               else
+                                               {
+                                                       __cropBox.x = __imageBox.x;
+                                               }
+                                               __cropBox.width = __cropBox.width - (2 * deltaX);
+                                               __cropBox.height = height;
+                                       }
+                                       else if (__cropBox.y - (temp / 2) <= __imageBox.y && __cropBox.x + deltaX >= __imageBox.x
+                                                       && __cropBox.x + __cropBox.width - deltaX <= __imageBox.x + __imageBox.width
+                                                       && __cropBox.y + __cropBox.height + temp <= __imageBox.y + __imageBox.height)
+                                       {
+                                               __cropBox.x += deltaX;
+                                               __cropBox.width = __cropBox.width - (2 * deltaX);
+                                               __cropBox.height = height;
+                                       }
+                                       else if (__cropBox.x + deltaX <= __imageBox.x && __cropBox.y - (temp / 2) >= __imageBox.y
+                                                       && __cropBox.x + __cropBox.width - deltaX <= __imageBox.x + __imageBox.width
+                                                       && __cropBox.y + __cropBox.height + temp <= __imageBox.y + __imageBox.height)
+                                       {
+                                               __cropBox.width = __cropBox.width - (2 * deltaX);
+                                               __cropBox.y = __cropBox.y - (temp / 2);
+                                               __cropBox.height = height;
+                                       }
+                               }
+                       }
                }
-               else
+               else if (__pointLocation == INSIDE_TOP_RECTANGLE)
                {
-                       __cropBox.y = __imageBox.y;
+                       int temp = __cropBox.width;
+                       int width = (__formWidth * (__cropBox.height - (2 * deltaY))) / __formHeight;
+                       temp = width - temp;
+                       if (__cropBox.height - (2 * deltaY) > (__formHeight * (CROP_RECTANGLE_HEIGHT * 3)) / __formWidth && (!(__cropBox.height - (2 * deltaY) >= __imageBox.height || width >= __imageBox.width)))
+                       {
+                               if (__cropBox.x - (temp /2 ) > __imageBox.x && __cropBox.x + __cropBox.width + temp < __imageBox.x + __imageBox.width
+                                       && __cropBox.y + (deltaY) > __imageBox.y && __cropBox.y + __cropBox.height - (2 * deltaY) < __imageBox.y + __imageBox.height)
+                               {
+                                       __cropBox.y += deltaY;
+                                       __cropBox.height = __cropBox.height - (2 * deltaY);
+                                       __cropBox.width = width;
+                                       __cropBox.x = __cropBox.x - (temp / 2);
+                               }
+                               else if (__cropBox.x - (temp / 2) < __imageBox.x)
+                               {
+                                       if (__cropBox.x + __cropBox.width + temp <= __imageBox.x + __imageBox.width)
+                                       {
+                                               __cropBox.width = width;
+                                       }
+                                       if (__cropBox.y + deltaY >= __imageBox.y)
+                                       {
+                                               __cropBox.y += deltaY;
+                                       }
+                                       if (__cropBox.y + __cropBox.height - (2 * deltaY) < __imageBox.y + __imageBox.height)
+                                       {
+                                               __cropBox.height = __cropBox.height - (2 * deltaY);
+                                       }
+                               }
+                               else if (__cropBox.y + __cropBox.height - (2 * deltaY) >= __imageBox.x + __imageBox.height
+                                               && __cropBox.y + (2 * deltaY) >= __imageBox.y)
+                               {
+                                       if (__cropBox.x - temp >= __imageBox.x
+                                               && __cropBox.x + __cropBox.width + temp > __imageBox.x + __imageBox.width)
+                                       {
+                                               __cropBox.x = __cropBox.x - temp;
+                                       }
+                                       else if (__cropBox.x - temp >= __imageBox.x)
+                                       {
+                                               __cropBox.x = __cropBox.x - temp / 2;
+                                       }
+                                       if (__cropBox.x + __cropBox.width + temp <= __imageBox.x + __imageBox.width)
+                                       {
+                                               __cropBox.width = width;
+                                       }
+                                       if (__cropBox.y + (2 * deltaY) >= __imageBox.y)
+                                       {
+                                               __cropBox.y = __cropBox.y + (2 * deltaY);
+                                               __cropBox.height = __cropBox.height - (2 * deltaY);
+                                       }
+                               }
+                               else if (__cropBox.x + __cropBox.width + (temp / 2) > __imageBox.x + __imageBox.width
+                                               && __cropBox.x - temp >= __imageBox.x && __cropBox.y + deltaY >= __imageBox.y
+                                               && __cropBox.y + __cropBox.height - (2 * deltaY) <= __imageBox.y + __imageBox.height)
+                               {
+                                       __cropBox.x = __cropBox.x - temp;
+                                       __cropBox.width = width;
+                                       __cropBox.y += deltaY;
+                                       __cropBox.height = __cropBox.height - (2 * deltaY);
+                               }
+                       }
                }
-               if ((__cropBox.x + __cropBox.width + deltaX) > (__imageBox.x + __imageBox.width))
+               else if (__pointLocation == INSIDE_BOTTOM_RECTANGLE)
                {
-                       __cropBox.x = __imageBox.x + __imageBox.width - __cropBox.width;
+                       deltaY = deltaY * (-1);
+                       int temp = __cropBox.width;
+                       int width = (__formWidth * (__cropBox.height - (2 * deltaY))) / __formHeight;
+                       temp = width - temp;
+                       if (__cropBox.height - (2 * deltaY) > (__formHeight * (CROP_RECTANGLE_HEIGHT * 3)) / __formWidth && (!(__cropBox.height - (2 * deltaY) >= __imageBox.height || width >= __imageBox.width)))
+                       {
+                               if (__cropBox.x - (temp / 2) >= __imageBox.x && __cropBox.x + __cropBox.width + temp < __imageBox.x + __imageBox.width
+                                       && __cropBox.y + deltaY > __imageBox.y && __cropBox.y + __cropBox.height - (2 * deltaY) < __imageBox.y + __imageBox.height)
+                               {
+                                       __cropBox.y += deltaY;
+                                       __cropBox.height = __cropBox.height - (2 * deltaY);;
+                                       __cropBox.width = width;
+                                       __cropBox.x = __cropBox.x - (temp / 2);
+                               }
+                               else if (__cropBox.y + deltaY < __imageBox.y && __cropBox.y + __cropBox.height - (2 * deltaY) < __imageBox.y + __imageBox.height
+                                               && __cropBox.x - (temp / 2) > __imageBox.x && __cropBox.x + __cropBox.width + temp < __imageBox.x + __imageBox.width)
+                               {
+                                       __cropBox.x = __cropBox.x - (temp / 2);
+                                       __cropBox.width = width;
+                                       __cropBox.height = __cropBox.height - (2 * deltaY);
+                               }
+                               else if (__cropBox.x + __cropBox.width + temp > __imageBox.x + __imageBox.width
+                                               && __cropBox.y + deltaY >= __imageBox.y && __cropBox.y + __cropBox.height + temp <= __imageBox.y + __imageBox.height
+                                               && __cropBox.x - temp >= __imageBox.x)
+                               {
+                                       __cropBox.x = __cropBox.x - temp;
+                                       __cropBox.y += deltaY;
+                                       __cropBox.width = width;
+                                       __cropBox.height = __cropBox.height - (2 * deltaY);
+                               }
+                               else if (__cropBox.x + __cropBox.width + temp >= __imageBox.x + __imageBox.width
+                                               && __cropBox.y + deltaY <= __imageBox.y && __cropBox.x - temp > __imageBox.x
+                                               && __cropBox.y + __cropBox.height + temp < __imageBox.y + __imageBox.height)
+                               {
+                                       __cropBox.x -= temp;
+                                       __cropBox.width = width;
+                                       __cropBox.height = __cropBox.height - (2 * deltaY);
+                               }
+                               else if (__cropBox.x - temp < __imageBox.x && __cropBox.x + __cropBox.width + temp <= __imageBox.x + __imageBox.width
+                                               && __cropBox.y + __cropBox.height - (2 * deltaY) <= __imageBox.y + __imageBox.height)
+                               {
+                                       if (__cropBox.y + deltaY >= __imageBox.y)
+                                       {
+                                               __cropBox.y += deltaY;
+                                       }
+                                       __cropBox.width = width;
+                                       __cropBox.height = __cropBox.height - (2 * deltaY);
+                               }
+                       }
                }
-               if ((__cropBox.y + __cropBox.height + deltaY) > (__imageBox.y + __imageBox.height))
+               else if (__pointLocation == INSIDE_CROPBOX)
                {
-                       __cropBox.y = __imageBox.y + __imageBox.height - __cropBox.height;
+                       if ((__cropBox.x + deltaX) > __imageBox.x)
+                       {
+                               __cropBox.x += deltaX;
+                       }
+                       else
+                       {
+                               __cropBox.x = __imageBox.x;
+                       }
+                       if ((__cropBox.y + deltaY) > __imageBox.y)
+                       {
+                               __cropBox.y += deltaY;
+                       }
+                       else
+                       {
+                               __cropBox.y = __imageBox.y;
+                       }
+                       if ((__cropBox.x + __cropBox.width + deltaX) > (__imageBox.x + __imageBox.width))
+                       {
+                               __cropBox.x = __imageBox.x + __imageBox.width - __cropBox.width;
+                       }
+                       if ((__cropBox.y + __cropBox.height + deltaY) > (__imageBox.y + __imageBox.height))
+                       {
+                               __cropBox.y = __imageBox.y + __imageBox.height - __cropBox.height;
+                       }
                }
        }
-       break;
-
-       default:
-               break;
-       }
        RequestRedraw(false);
        __touchStart = currentPosition;
        AppLogDebug("EXIT");
@@ -473,49 +926,36 @@ ImageCropForm::SetValue(void)
        int prevWidth = __imageBox.width;
        int prevImageboxX = __imageBox.x;
        int prevImageBoxY = __imageBox.y;
-       int indicatorBarHeight = 0;
-
-       if (GetOrientationStatus() == ORIENTATION_STATUS_LANDSCAPE || GetOrientationStatus() == ORIENTATION_STATUS_LANDSCAPE_REVERSE)
+       if (GetOrientationStatus() == ORIENTATION_STATUS_PORTRAIT)
        {
-               indicatorBarHeight = 21;
+               __formHeight = Form::GetBounds().height;
+               __formWidth = Form::GetBounds().width;
        }
-       else
+       else if(GetOrientationStatus() == ORIENTATION_STATUS_LANDSCAPE || GetOrientationStatus() == ORIENTATION_STATUS_LANDSCAPE_REVERSE)
        {
-               indicatorBarHeight = 60;
+               __formHeight = Form::GetBounds().width;
+               __formWidth = Form::GetBounds().height;
        }
 
-       if (__imageWidth > GetClientAreaBounds().width && __imageHeight > GetClientAreaBounds().height)
+       float clientAreaRatio = (GetClientAreaBoundsF().height - FOOTER_PANEL_HEIGHT) / GetClientAreaBoundsF().width;
+       if (__imageWidth >= GetClientAreaBounds().width || __imageHeight > (GetClientAreaBounds().height - FOOTER_PANEL_HEIGHT))
        {
-               if (__imageHeight > __imageWidth)
+               float imageRatio = __imageHeight / (float) __imageWidth;
+               if (imageRatio < clientAreaRatio)
                {
-                       __imageBox.height = GetClientAreaBounds().height - FOOTER_PANEL_HEIGHT;
-                       __imageBox.width = (__imageWidth * GetClientAreaBounds().height) / __imageHeight;
-                       __imageBox.x = (GetClientAreaBounds().width - __imageBox.width) / 2;
-                       __imageBox.y = indicatorBarHeight;
+                       __imageBox.width = GetClientAreaBounds().width;
+                       __imageBox.height = (__imageHeight * __imageBox.width) / __imageWidth;
+                       __imageBox.x = GetClientAreaBounds().x;
+                       __imageBox.y = GetClientAreaBounds().y + ((GetClientAreaBounds().height - FOOTER_PANEL_HEIGHT) - __imageBox.height) / 2;
                }
                else
                {
-                       __imageBox.width = GetClientAreaBounds().width;
-                       __imageBox.height = (GetClientAreaBounds().width * __imageHeight) / __imageWidth;
-                       __imageBox.x = 0;
-                       __imageBox.y = (GetClientAreaBounds().height - __imageBox.height) / 2;
+                       __imageBox.height = GetClientAreaBounds().height - FOOTER_PANEL_HEIGHT;
+                       __imageBox.width = (__imageWidth * __imageBox.height) / __imageHeight;
+                       __imageBox.x = (GetClientAreaBounds().width - __imageBox.width) / 2;
+                       __imageBox.y = GetClientAreaBounds().y;
                }
        }
-       else if (__imageWidth > GetClientAreaBounds().width)
-       {
-               __imageBox.width = GetClientAreaBounds().width;
-               __imageBox.height = (__imageHeight * GetClientAreaBounds().width) / __imageWidth;
-               __imageBox.x = 0;
-               __imageBox.y = (GetClientAreaBounds().height - __imageBox.height) / 2;
-
-       }
-       else if (__imageHeight > GetClientAreaBounds().height)
-       {
-               __imageBox.height = GetClientAreaBounds().height - FOOTER_PANEL_HEIGHT;
-               __imageBox.width = (__imageWidth * GetClientAreaBounds().height) / __imageHeight;
-               __imageBox.x = (GetClientAreaBounds().width - __imageBox.width) / 2;
-               __imageBox.y = indicatorBarHeight;
-       }
        else
        {
                __imageBox.height = __imageHeight;
@@ -525,17 +965,17 @@ ImageCropForm::SetValue(void)
        }
        if (__isOrientationChanged == false)
        {
-               if (__imageHeight >= __imageWidth)
+               if (__imageBox.height > __imageBox.width)
                {
-                       __cropBox.height = __imageBox.height / 2;
-                       __cropBox.width = __imageBox.width / 2;
-                       __cropBox.y =  __imageBox.y + (__imageBox.height / 4);
-                       __cropBox.x = __imageBox.x + (__imageBox.width / 4);
+                       __cropBox.width = (2 * __imageBox.width) / 3;
+                       __cropBox.height = (__formHeight * __cropBox.width / __formWidth);
+                       __cropBox.y =  __imageBox.y + (__imageBox.height - __cropBox.height) / 2;
+                       __cropBox.x = __imageBox.x + (__imageBox.width - __cropBox.width) / 2;
                }
                else
                {
-                       __cropBox.height = (2 * __imageBox.height) / 3;
-                       __cropBox.width = (2 * __imageBox.width) / 3;
+                       __cropBox.height = (2 *__imageBox.height) / 3;
+                       __cropBox.width = (__formWidth * __cropBox.height / __formHeight);
                        __cropBox.y = __imageBox.y + (__imageBox.height - __cropBox.height) / 2;
                        __cropBox.x = __imageBox.x + (__imageBox.width - __cropBox.width) / 2;
                }
@@ -554,3 +994,10 @@ ImageCropForm::SetValue(void)
        __pCanvas = GetCanvasN();
        __pCanvas->SetForegroundColor(CROP_BOX_RECTANGLE_COLOR);
 }
+
+void ImageCropForm::OnFormFileEventOccuered(const int index, const unsigned long eventId)
+{
+       AppLogDebug(" ENTER");
+       UiApp::GetInstance()->Terminate();
+       AppLogDebug("EXIT(%s)", GetErrorMessage(GetLastResult()));
+}

diff --git a/src/IvImageViewerForm.cpp b/src/IvImageViewerForm.cpp
index 3d1d65d..8a830b6 100644 (file)
--- a/src/IvImageViewerForm.cpp
+++ b/src/IvImageViewerForm.cpp
@@ -776,6 +776,8 @@ ImageViewerForm::InitializeContextMenuMore(void)
                __pContextMenuMore->AddItem(ResourceManager::GetString(L"IDS_IV_OPT_SET_AS"),
                                ACTION_ID_CONTEXTMENU_SET_AS);
                __pContextMenuMore->AddItem(ResourceManager::GetString(L"IDS_IV_BODY_CROP"), ACTION_ID_FOOTER_BUTTON_CROP);
+               //__pContextMenuMore->AddItem("Rotate Left", ACTION_ID_FOOTER_BUTTON_ROTATE_LEFT);
+               //__pContextMenuMore->AddItem("Rotate Right", ACTION_ID_FOOTER_BUTTON_ROTATE_RIGHT);
        }
 
        if (__pGallery->GetItemCount() > 1)
@@ -1419,9 +1421,12 @@ ImageViewerForm::OnActionPerformed(const Control& source, int actionId)
        case ACTION_ID_FOOTER_BUTTON_CROP:
        {
                String filePath;
+               String cropMode = L"auto";
+               //String cropMode = L"auto";
                ArrayList* pList = new (std::nothrow) ArrayList(SingleObjectDeleter);
                filePath = __pPresentationModel->GetFilePathAt(__pGallery->GetCurrentItemIndex());
                pList->Add(new (std::nothrow) String(filePath));
+               pList->Add(new (std::nothrow) String(cropMode));
                pSceneManager->GoForward(ForwardSceneTransition(IDSCN_IMAGE_CROP), pList);
        }
        break;
@@ -1432,6 +1437,12 @@ ImageViewerForm::OnActionPerformed(const Control& source, int actionId)
                RotateMode rotateMode = ROTATE_MODE_RIGHT;
                __pPresentationModel->SetImageRotateStatus(true);
                RotateImage(filePath, rotateMode);
+               AppLog("Manish After Rotate");
+               //__pPresentationModel->SetImageCacheAt(currentIndex, filePath);
+               ImageInfo* pImageInfo = null;
+               pImageInfo->Construct(filePath, null);
+               pImageInfo->ClearBitmap();
+               __pGallery->RefreshGallery(currentIndex, GALLERY_REFRESH_TYPE_ITEM_MODIFY);
                __pPresentationModel->RequestImage(filePath);
                ContentManager::ScanFile(filePath);
        }
@@ -1470,20 +1481,26 @@ ImageViewerForm::OnActionPerformed(const Control& source, int actionId)
        }
        case ACTION_ID_CONTEXTMENU_HOME:
        {
+               String filePath = __pPresentationModel->GetFilePathAt(__pGallery->GetCurrentItemIndex());
+               String cropMode = "fit-to-screen";
                ArrayList* pList = new (std::nothrow) ArrayList(SingleObjectDeleter);
-               pList->Add(new (std::nothrow) Integer(__pGallery->GetCurrentItemIndex()));
+               pList->Add(new (std::nothrow) String(filePath));
+               pList->Add(new (std::nothrow) String(cropMode));
                pList->Add(new (std::nothrow) Integer(SET_AT_TYPE_HOME_SCREEN_WALLPAPER));
-               __pPresentationModel->SetSetterIndex(__pGallery->GetCurrentItemIndex());
-               pSceneManager->GoForward(ForwardSceneTransition(IDSCN_IMAGE_SETTER), pList);
+               //__pPresentationModel->SetSetterIndex(__pGallery->GetCurrentItemIndex());
+               pSceneManager->GoForward(ForwardSceneTransition(IDSCN_IMAGE_CROP), pList);
                break;
        }
        case ACTION_ID_CONTEXTMENU_LOCK:
        {
+               String filePath = __pPresentationModel->GetFilePathAt(__pGallery->GetCurrentItemIndex());
+               String cropMode = "fit-to-screen";
                ArrayList* pList = new (std::nothrow) ArrayList(SingleObjectDeleter);
-               pList->Add(new (std::nothrow) Integer(__pGallery->GetCurrentItemIndex()));
+               pList->Add(new (std::nothrow) String(filePath));
+               pList->Add(new (std::nothrow) String(cropMode));
                pList->Add(new (std::nothrow) Integer(SET_AT_TYPE_LOCK_SCREEN_WALLPAPER));
-               __pPresentationModel->SetSetterIndex(__pGallery->GetCurrentItemIndex());
-               pSceneManager->GoForward(ForwardSceneTransition(IDSCN_IMAGE_SETTER), pList);
+               //__pPresentationModel->SetSetterIndex(__pGallery->GetCurrentItemIndex());
+               pSceneManager->GoForward(ForwardSceneTransition(IDSCN_IMAGE_CROP), pList);
                break;
        }
        case ACTION_ID_CONTEXTMENU_CALLER:
@@ -1504,12 +1521,14 @@ ImageViewerForm::OnActionPerformed(const Control& source, int actionId)
 
        case ACTION_ID_CONTEXTMENU_HOME_AND_LOCK:
        {
+               String filePath = __pPresentationModel->GetFilePathAt(__pGallery->GetCurrentItemIndex());
+               String cropMode = "fit-to-screen";
                ArrayList* pList = new (std::nothrow) ArrayList(SingleObjectDeleter);
-               pList->Add(new (std::nothrow) Integer(__pGallery->GetCurrentItemIndex()));
+               pList->Add(new (std::nothrow) String(filePath));
+               pList->Add(new (std::nothrow) String(cropMode));
                pList->Add(new (std::nothrow) Integer(SET_AT_TYPE_HOME_AND_LOCK_SCREEN_WALLPAPER));
-               __pPresentationModel->SetSetterIndex(__pGallery->GetCurrentItemIndex());
-               pSceneManager->GoForward(ForwardSceneTransition(IDSCN_IMAGE_SETTER), pList);
-               break;
+               //__pPresentationModel->SetSetterIndex(__pGallery->GetCurrentItemIndex());
+               pSceneManager->GoForward(ForwardSceneTransition(IDSCN_IMAGE_CROP), pList);
                break;
        }
 
@@ -1638,14 +1657,12 @@ ImageViewerForm::OnSceneActivatedN(const SceneId& previousSceneId,
        if (previousSceneId == IDSCN_IMAGE_CROP && pArgs != null)
        {
                AppLog("Manish hello");
-               String* pFilePath = null;
-               pFilePath = static_cast<String*>(pArgs->GetAt(0));
-               delete pArgs;
-               AppLog("Manish %ls", pFilePath->GetPointer());
                String filePath;
-               filePath.Append(*pFilePath);
+               filePath = *(static_cast<String*>(pArgs->GetAt(0)));
+               delete pArgs;
+               AppLog("Manish %ls", filePath.GetPointer());
                int count = __pPresentationModel->GetFileCount();
-               __pPresentationModel->SetImageCacheAt(count, filePath);
+               __pPresentationModel->AddImageCache(filePath);
                __pGallery->UpdateGallery();
                __pGallery->SetCurrentItemIndex(count);
                __pPresentationModel->RequestImage(filePath);
@@ -1704,15 +1721,23 @@ ImageViewerForm::OnAppControlCompleteResponseReceived(const AppId& appId,
                if (pContactId != null && pContactId->GetLength() > 0)
                {
                        LongLong::Parse(*pContactId, lresult);
-
+                       String filePath = __pPresentationModel->GetFilePathAt(__pGallery->GetCurrentItemIndex());
+                       String cropMode = "fit-to-screen";
                        ArrayList* pList = new (std::nothrow) ArrayList(SingleObjectDeleter);
+                       pList->Add(new (std::nothrow) String(filePath));
+                       pList->Add(new (std::nothrow) String(cropMode));
+                       pList->Add(new (std::nothrow) Integer(SET_AT_TYPE_CALLER_IMAGE));
+                       pList->Add(new (std::nothrow) LongLong(lresult));
+                       SceneManager* pSceneManager = SceneManager::GetInstance();
+                       pSceneManager->GoForward(ForwardSceneTransition(IDSCN_IMAGE_CROP), pList);
+                       /*ArrayList* pList = new (std::nothrow) ArrayList(SingleObjectDeleter);
                        pList->Add(new (std::nothrow) Integer(__pGallery->GetCurrentItemIndex()));
                        pList->Add(new (std::nothrow) Integer(SET_AT_TYPE_CALLER_IMAGE));
                        pList->Add(new (std::nothrow) LongLong(lresult));
                        __pPresentationModel->SetSetterIndex(__pGallery->GetCurrentItemIndex());
 
                        SceneManager* pSceneManager = SceneManager::GetInstance();
-                       pSceneManager->GoForward(ForwardSceneTransition(IDSCN_IMAGE_SETTER), pList);
+                       pSceneManager->GoForward(ForwardSceneTransition(IDSCN_IMAGE_SETTER), pList);*/
                }
        }
 

diff --git a/src/IvImageViewerPresentationModel.cpp b/src/IvImageViewerPresentationModel.cpp
index fc5e1b7..19e455a 100644 (file)
--- a/src/IvImageViewerPresentationModel.cpp
+++ b/src/IvImageViewerPresentationModel.cpp
@@ -310,20 +310,23 @@ ImageViewerPresentationModel::GetImageCacheAt(const int index) const
 }
 
 void
-ImageViewerPresentationModel::SetImageCacheAt(const int index, const String& filePath)
+ImageViewerPresentationModel::AddImageCache(const String& filePath)
 {
        ImageInfo* pImageInfo = null;
        pImageInfo = new (std::nothrow) ImageInfo();
-       AppLog("Manish %d %ls", index, filePath.GetPointer());
-
        pImageInfo->Construct(filePath, null);
-       //__pImageCaches->Add(pImageInfo);
-       int count = __pImageCaches->GetCount();
-       AppLog("Manish count %d", count);
-       //__pImageCaches->SetCapacity(++count);
        __pImageCaches->Add(pImageInfo);
 }
 
+void
+ImageViewerPresentationModel::SetImageCacheAt(const int index, const String& filePath)
+{
+       ImageInfo* pImageInfo = null;
+       pImageInfo->Construct(filePath, null);
+       pImageInfo->ClearBitmap();
+       //__pImageCaches->SetAt(pImageInfo, index);
+}
+
 int
 ImageViewerPresentationModel::GetFileCount(void) const
 {