开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
PictureEditor.c
资源名称：mmi.rar　[点击查看]
上传用户：lqx1163
上传日期：2014-08-13
资源大小：9183k
文件大小：158k
源码类别：

MTK

开发平台：

C/C++

PictureEditor.c：源码内容
  1.             nInlinePenSize = 0;
  2.             break;
  3.     }
  4. #ifndef __MMI_TOUCH_SCREEN__    /* PMT MANISH   20050616 */
  5.     switch (gpPicEditPen->penMove)
  6.     {
  7.         case PIC_EDIT_PEN_MOVE_1:
  8.             nInlinePenMoveFactor = 0;
  9.             break;
  10.         case PIC_EDIT_PEN_MOVE_2:
  11.             nInlinePenMoveFactor = 1;
  12.             break;
  13.         case PIC_EDIT_PEN_MOVE_3:
  14.             nInlinePenMoveFactor = 2;
  15.             break;
  16.         case PIC_EDIT_PEN_MOVE_4:
  17.             nInlinePenMoveFactor = 3;
  18.             break;
  19.         default:
  20.             nInlinePenMoveFactor = 0;
  21.             break;
  22.     }
  23. #endif /* __MMI_TOUCH_SCREEN__ */ 
  25.     for (iCount = 0; iCount < MAX_TYPE_PEN_COLOR; ++iCount)
  26.     {
  27.         pInlinePenColorIndexList[iCount] = (U8*) GetString((U16) (iCount + 1 + STR_PE_COLOR_NONE));
  28.         inlinePERGBlist[iCount][0] = (U8) ((0xFF000000 & gPEColorRGB[iCount + 1]) >> 24);
  29.         inlinePERGBlist[iCount][1] = (U8) ((0x00FF0000 & gPEColorRGB[iCount + 1]) >> 16);
  30.         inlinePERGBlist[iCount][2] = (U8) ((0x0000FF00 & gPEColorRGB[iCount + 1]) >> 8);
  31.     }
  32.     inlinePERGBlist[iCount - 1][0] = (U8) ((0xFF000000 & gPEColorRGB[iCount - 1]) >> 24);
  33.     inlinePERGBlist[iCount - 1][1] = (U8) ((0x00FF0000 & gPEColorRGB[iCount - 1]) >> 16);
  34.     inlinePERGBlist[iCount - 1][2] = (U8) ((0x0000FF00 & gPEColorRGB[iCount - 1]) >> 8);
  36.     inputBuffer = GetCurrNInputBuffer(SCR_PE_PEN_SETTING, &inputBufferSize);    /* added for inline edit history */
  38.     RegisterHighlightHandler(PicEditPenSettingInlineEdit);
  39.     g_pe_color_index = nInlinePenColorIndex + 1;
  41.     SetPicEditPenSettingInlineItemData();
  42.     if (inputBuffer != NULL)
  43.         SetCategory57Data(PicEditInLineItems,
  44. #ifdef __MMI_TOUCH_SCREEN__
  45.                           4,
  46. #else 
  47.                           6,
  48. #endif 
  49.                           inputBuffer);
  51.     ShowCategory57Screen(STR_PE_EDIT_OPT_PEN_SETTING, GetRootTitleIcon(MENU_PICTURE_EDITOR),
  52.                          STR_GLOBAL_OK, IMG_GLOBAL_OK, STR_GLOBAL_BACK, IMG_GLOBAL_BACK,
  53. #ifdef __MMI_TOUCH_SCREEN__
  54.                          4,
  55. #else 
  56.                          6,
  57. #endif 
  58.                          NULL, PicEditInLineItems, 0, guiBuffer);
  60.     DisableCategory57ScreenDone();
  62.     RegisterInlineSelectHighlightHandler(&PicEditInLineItems[PE_PEN_SIZE_SELECT], PicEditPenSettingSelectInlineEdit);
  63. #ifndef __MMI_TOUCH_SCREEN__
  64.     RegisterInlineSelectHighlightHandler(&PicEditInLineItems[PE_PEN_MOVE_SELECT], PicEditPenSettingSelectInlineEdit);
  65. #endif 
  66.     RegisterInlineSelectHighlightHandler(&PicEditInLineItems[PE_PEN_COLOR_SELECT], PicEditPenSettingSelectInlineEdit);
  67.     PicEditPenSettingSelectInlineEdit(-1);
  69.     /* SetExitHandler(SCR_PE_PEN_SETTING, ExitScr4PicEditPenSetting); */
  70. }
  73. /*****************************************************************************
  74.  * FUNCTION
  75.  *  ExitScr4PicEditPenSetting
  76.  * DESCRIPTION
  77.  *  Exit function for EntryScr4PicEditPenSetting
  78.  * PARAMETERS
  79.  *  void
  80.  * RETURNS
  81.  *  void
  82.  *****************************************************************************/
  83. void ExitScr4PicEditPenSetting(void)
  84. {
  85.     /*----------------------------------------------------------------*/
  86.     /* Local Variables                                                */
  87.     /*----------------------------------------------------------------*/
  88.     history h;
  89.     S16 nHistory = 0;
  90.     U16 inputBufferSize;
  92.     /*----------------------------------------------------------------*/
  93.     /* Code Body                                                      */
  94.     /*----------------------------------------------------------------*/
  95.     CloseCategory57Screen();
  96.     h.scrnID = SCR_PE_PEN_SETTING;
  97.     h.entryFuncPtr = EntryScr4PicEditPenSetting;
  98.     pfnUnicodeStrcpy((S8*) h.inputBuffer, (S8*) & nHistory);
  99.     GetCategory57History(h.guiBuffer);
  100.     inputBufferSize = (S16) GetCategory57DataSize();    /* added for inline edit history */
  101.     GetCategory57Data((U8*) h.inputBuffer);             /* added for inline edit history */
  102.     AddNHistory(h, inputBufferSize);                    /* added for inline edit history */
  103. }
  106. /*****************************************************************************
  107.  * FUNCTION
  108.  *  GoBackPicEditPenSettingHistory
  109.  * DESCRIPTION
  110.  *  Go Back function for Pen settign screen
  111.  * PARAMETERS
  112.  *  void
  113.  * RETURNS
  114.  *  void
  115.  *****************************************************************************/
  116. void GoBackPicEditPenSettingHistory(void)
  117. {
  118.     /*----------------------------------------------------------------*/
  119.     /* Local Variables                                                */
  120.     /*----------------------------------------------------------------*/
  122.     /*----------------------------------------------------------------*/
  123.     /* Code Body                                                      */
  124.     /*----------------------------------------------------------------*/
  125.     CloseCategory57Screen();
  126.     GoBackHistory();
  127. }
  130. /*****************************************************************************
  131.  * FUNCTION
  132.  *  PicEditPenSettingInlineEdit
  133.  * DESCRIPTION
  134.  *  Changes the softkeys for pen setting screen
  135.  * PARAMETERS
  136.  *  nIndex      [IN]        
  137.  * RETURNS
  138.  *  void
  139.  *****************************************************************************/
  140. void PicEditPenSettingInlineEdit(S32 nIndex)
  141. {
  142.     /*----------------------------------------------------------------*/
  143.     /* Local Variables                                                */
  144.     /*----------------------------------------------------------------*/
  146.     /*----------------------------------------------------------------*/
  147.     /* Code Body                                                      */
  148.     /*----------------------------------------------------------------*/
  149.     nSelPEPenSetting = (U8) nIndex;
  150.     ChangePenSettingSoftkey();
  151. }
  154. /*****************************************************************************
  155.  * FUNCTION
  156.  *  PicEditPenSettingSelectInlineEdit
  157.  * DESCRIPTION
  158.  *  changes softkey when inline item selected on pen setting screen
  159.  * PARAMETERS
  160.  *  index       [IN]        
  161.  * RETURNS
  162.  *  void
  163.  *****************************************************************************/
  164. void PicEditPenSettingSelectInlineEdit(S32 index)
  165. {
  166.     /*----------------------------------------------------------------*/
  167.     /* Local Variables                                                */
  168.     /*----------------------------------------------------------------*/
  170.     /*----------------------------------------------------------------*/
  171.     /* Code Body                                                      */
  172.     /*----------------------------------------------------------------*/
  173.     if ((nSelPEPenSetting == PE_PEN_COLOR_SELECT) && (index != -1))
  174.     {
  175.         g_pe_color_index = index;
  176.     }
  177.     ChangePenSettingSoftkey();
  178. }
  181. /*****************************************************************************
  182.  * FUNCTION
  183.  *  ChangePenSettingSoftkey
  184.  * DESCRIPTION
  185.  *  Changes softkey on pen setting screen
  186.  * PARAMETERS
  187.  *  void
  188.  * RETURNS
  189.  *  void
  190.  *****************************************************************************/
  191. void ChangePenSettingSoftkey(void)
  192. {
  193.     /*----------------------------------------------------------------*/
  194.     /* Local Variables                                                */
  195.     /*----------------------------------------------------------------*/
  197.     /*----------------------------------------------------------------*/
  198.     /* Code Body                                                      */
  199.     /*----------------------------------------------------------------*/
  200.     if (CheckPicEditPenSettingChange())
  201.     {
  202.         ChangeRightSoftkey(STR_GLOBAL_DONE, IMG_GLOBAL_BACK);
  203.         SetRightSoftkeyFunction(EntryScr4PicEditPenSettingSaveConfirm, KEY_EVENT_UP);
  204.     }
  205.     else
  206.     {
  207.         ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  208.         SetRightSoftkeyFunction(GoBackPicEditPenSettingHistory, KEY_EVENT_UP);
  209.     }
  211.     if ((nSelPEPenSetting == PE_PEN_COLOR_SELECT) && (g_pe_color_index + 1 == PE_COLOR_CUSTOM_1))
  212.     {
  213.         ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  214.         SetCategory57LeftSoftkeyFunction(EntryScr4PicEditCustomColor);
  215.     }
  216.     else
  217.     {
  218.         ChangeLeftSoftkey((U16) NULL, (U16) NULL);
  219.     }
  220. }
  223. /*****************************************************************************
  224.  * FUNCTION
  225.  *  EntryScr4PicEditPenSettingSaveConfirm
  226.  * DESCRIPTION
  227.  *  Confirmation screen for save pen settings
  228.  * PARAMETERS
  229.  *  void
  230.  * RETURNS
  231.  *  void
  232.  *****************************************************************************/
  233. void EntryScr4PicEditPenSettingSaveConfirm(void)
  234. {
  235. #if (0)
  236. /* under construction !*/
  237. /* under construction !*/
  238. /* under construction !*/
  239. /* under construction !*/
  240. /* under construction !*/
  241. /* under construction !*/
  242. /* under construction !*/
  243. /* under construction !*/
  244. /* under construction !*/
  245. /* under construction !*/
  246. /* under construction !*/
  247. /* under construction !*/
  248. /* under construction !*/
  249. /* under construction !*/
  250. #endif /* (0) */ 
  252.     /*----------------------------------------------------------------*/
  253.     /* Code Body                                                      */
  254.     /*----------------------------------------------------------------*/
  255.     DisplayConfirm(
  256.         STR_GLOBAL_YES,
  257.         IMG_GLOBAL_YES,
  258.         STR_GLOBAL_NO,
  259.         IMG_GLOBAL_NO,
  260.         get_string(STR_GLOBAL_SAVE),
  261.         IMG_GLOBAL_QUESTION,
  262.         WARNING_TONE);
  264.     SetLeftSoftkeyFunction(SavePicEditPenSetting, KEY_EVENT_UP);
  266.     SetRightSoftkeyFunction(GoBackPicEditPenSettingConfirmHistory, KEY_EVENT_UP);
  268.     /* playRequestedTone(WARNING_TONE) ; */
  270.     /* SetExitHandler(SCR_PE_PEN_SETTING_SAVE, ExitScr4PicEditPenSettingSaveConfirm); */
  272. }
  275. /*****************************************************************************
  276.  * FUNCTION
  277.  *  ExitScr4PicEditPenSettingSaveConfirm
  278.  * DESCRIPTION
  279.  *  Exit function EntryScr4PicEditPenSettingSaveConfirm
  280.  * PARAMETERS
  281.  *  void
  282.  * RETURNS
  283.  *  void
  284.  *****************************************************************************/
  285. void ExitScr4PicEditPenSettingSaveConfirm(void)
  286. {
  287.     /*----------------------------------------------------------------*/
  288.     /* Local Variables                                                */
  289.     /*----------------------------------------------------------------*/
  290.     history h;  /* Variable to hold the history data */
  291.     S16 nHistory = 0;
  293.     /*----------------------------------------------------------------*/
  294.     /* Code Body                                                      */
  295.     /*----------------------------------------------------------------*/
  296.     stopRequestedTone(WARNING_TONE);
  297.     h.scrnID = SCR_PE_PEN_SETTING_SAVE;
  298.     h.entryFuncPtr = EntryScr4PicEditPenSettingSaveConfirm;
  299.     pfnUnicodeStrcpy((S8*) h.inputBuffer, (S8*) & nHistory);
  300.     GetCategoryHistory(h.guiBuffer);
  301. }
  304. /*****************************************************************************
  305.  * FUNCTION
  306.  *  GoBackPicEditPenSettingConfirmHistory
  307.  * DESCRIPTION
  308.  *  Go Back History for save pen setting coonfirmatioon screen
  309.  * PARAMETERS
  310.  *  void
  311.  * RETURNS
  312.  *  void
  313.  *****************************************************************************/
  314. void GoBackPicEditPenSettingConfirmHistory(void)
  315. {
  316.     /*----------------------------------------------------------------*/
  317.     /* Local Variables                                                */
  318.     /*----------------------------------------------------------------*/
  320.     /*----------------------------------------------------------------*/
  321.     /* Code Body                                                      */
  322.     /*----------------------------------------------------------------*/
  323.     CloseCategory57Screen();
  324.     DeleteUptoScrID(SCR_PE_EDIT_PIC_OPT);
  325.     GoBackHistory();
  326. }
  329. /*****************************************************************************
  330.  * FUNCTION
  331.  *  SavePicEditPenSetting
  332.  * DESCRIPTION
  333.  *  Saves Pen setting
  334.  * PARAMETERS
  335.  *  void
  336.  * RETURNS
  337.  *  void
  338.  *****************************************************************************/
  339. void SavePicEditPenSetting(void)
  340. {
  341.     /*----------------------------------------------------------------*/
  342.     /* Local Variables                                                */
  343.     /*----------------------------------------------------------------*/
  344.     U8 infoPalette[MAX_TYPE_PEN_COLOR * 4];
  346.     /*----------------------------------------------------------------*/
  347.     /* Code Body                                                      */
  348.     /*----------------------------------------------------------------*/
  349.     gpPicEditPen->penColorIndex = (U8) nInlinePenColorIndex + 1;
  350.     switch (nInlinePenSize)
  351.     {
  352.         case 0:
  353.             gpPicEditPen->penPixel = PIC_EDIT_PEN_PIXEL_1;
  354.             break;
  355.         case 1:
  356.             gpPicEditPen->penPixel = PIC_EDIT_PEN_PIXEL_2;
  357.             break;
  358.         case 2:
  359.             gpPicEditPen->penPixel = PIC_EDIT_PEN_PIXEL_3;
  360.             break;
  361.         case 3:
  362.             gpPicEditPen->penPixel = PIC_EDIT_PEN_PIXEL_4;
  363.             break;
  364.         default:
  365.             gpPicEditPen->penPixel = PIC_EDIT_PEN_PIXEL_1;
  366.             break;
  367.     }
  368. #ifndef __MMI_TOUCH_SCREEN__    /* PMT MANISH   20050616 */
  369.     switch (nInlinePenMoveFactor)
  370.     {
  371.         case 0:
  372.             gpPicEditPen->penMove = PIC_EDIT_PEN_MOVE_1;
  373.             break;
  374.         case 1:
  375.             gpPicEditPen->penMove = PIC_EDIT_PEN_MOVE_2;
  376.             break;
  377.         case 2:
  378.             gpPicEditPen->penMove = PIC_EDIT_PEN_MOVE_3;
  379.             break;
  380.         case 3:
  381.             gpPicEditPen->penMove = PIC_EDIT_PEN_MOVE_4;
  382.             break;
  383.         default:
  384.             gpPicEditPen->penMove = PIC_EDIT_PEN_MOVE_1;
  385.             break;
  386.     }
  387. #endif /* __MMI_TOUCH_SCREEN__ */ 
  388.     CloseCategory57Screen();
  390.     GetPaletteInfo(infoPalette);
  391.     memcpy(gpPEFileBuff + 54, &infoPalette, MAX_TYPE_PEN_COLOR * gPEBitsPerPixel);
  393.     DisplayPopup((PU8) GetString(STR_GLOBAL_DONE), IMG_GLOBAL_ACTIVATED, 1, PE_NOTIFYDURATION, SUCCESS_TONE);
  394.     DeleteUptoScrID(SCR_PE_EDIT_PIC);
  395. }
  398. /*****************************************************************************
  399.  * FUNCTION
  400.  *  SetPicEditFillPicInlineItemData
  401.  * DESCRIPTION
  402.  *  Setup inline item data for fill image background
  403.  * PARAMETERS
  404.  *  void
  405.  * RETURNS
  406.  *  void
  407.  *****************************************************************************/
  408. void SetPicEditFillPicInlineItemData(void)
  409. {
  410.     /*----------------------------------------------------------------*/
  411.     /* Local Variables                                                */
  412.     /*----------------------------------------------------------------*/
  414.     /*----------------------------------------------------------------*/
  415.     /* Code Body                                                      */
  416.     /*----------------------------------------------------------------*/
  417.     SetInlineItemActivation(&PicEditInLineItems[0], INLINE_ITEM_ACTIVATE_WITHOUT_KEY_EVENT, 0);
  418.     SetInlineItemCaption(&PicEditInLineItems[0], (PU8) (get_string(STR_PE_EDIT_OPT_FILL_PIC)));
  420.     SetInlineItemActivation(&PicEditInLineItems[1], INLINE_ITEM_ACTIVATE_WITHOUT_KEY_EVENT, 0);
  421.     SetInlineItemSelect(
  422.         &PicEditInLineItems[1],
  423.         MAX_TYPE_PEN_COLOR - 1,
  424.         pInlinePenColorIndexList,
  425.         &nInlinePenColorIndex);
  426.     RegisterInlineSelectHighlightHandler(&PicEditInLineItems[1], PicEditPenColorHiLiteHandler);
  427. }
  430. /*****************************************************************************
  431.  * FUNCTION
  432.  *  EntryScr4PicEditFillPic
  433.  * DESCRIPTION
  434.  *  Entry function for filling image with selected color
  435.  * PARAMETERS
  436.  *  void
  437.  * RETURNS
  438.  *  void
  439.  *****************************************************************************/
  440. void EntryScr4PicEditFillPic(void)
  441. {
  442.     /*----------------------------------------------------------------*/
  443.     /* Local Variables                                                */
  444.     /*----------------------------------------------------------------*/
  445.     U8 *guiBuffer;
  446.     U8 *inputBuffer;        /* added for inline edit history */
  447.     U16 inputBufferSize;    /* added for inline edit history */
  449.     U8 iCount;
  451.     /*----------------------------------------------------------------*/
  452.     /* Code Body                                                      */
  453.     /*----------------------------------------------------------------*/
  454.     /* ExecuteCurrExitHandler(); */
  455.     EntryNewScreen(SCR_PE_FILL_PIC, ExitScr4PicEditFillPic, NULL, NULL);
  456.     guiBuffer = GetCurrGuiBuffer(SCR_PE_FILL_PIC);
  458.     //Pixtel patch
  459.     //      nInlinePenColorIndex=gpPicEditPen->penBackgrdColorIndex;
  461.     for (iCount = 0; iCount < MAX_TYPE_PEN_COLOR; iCount++)
  462.     {
  463.         pInlinePenColorIndexList[iCount] = (U8*) GetString((U16) (iCount + 1 + STR_PE_COLOR_NONE));
  464.         inlinePERGBlist[iCount][0] = (U8) ((0xFF000000 & gPEColorRGB[iCount + 1]) >> 24);
  465.         inlinePERGBlist[iCount][1] = (U8) ((0x00FF0000 & gPEColorRGB[iCount + 1]) >> 16);
  466.         inlinePERGBlist[iCount][2] = (U8) ((0x0000FF00 & gPEColorRGB[iCount + 1]) >> 8);
  467.     }
  469.     inputBuffer = GetCurrNInputBuffer(SCR_PE_FILL_PIC, &inputBufferSize);       /* added for inline edit history */
  471.     RegisterHighlightHandler(ChangeSoftkeyFillPic);
  472.     g_pe_color_index = nInlinePenColorIndex + 1;
  474.     InitializeCategory57Screen();
  475.     SetPicEditFillPicInlineItemData();
  476.     if (inputBuffer != NULL)
  477.     {
  478.         SetCategory57Data(PicEditInLineItems, 2, inputBuffer);
  479.     }
  481.     ShowCategory57Screen(
  482.         STR_PE_EDIT_OPT_FILL_PIC,
  483.         GetRootTitleIcon(MENU_PICTURE_EDITOR),
  484.         0,
  485.         0,
  486.         STR_GLOBAL_BACK,
  487.         IMG_GLOBAL_BACK,
  488.         2,
  489.         NULL,
  490.         PicEditInLineItems,
  491.         0,
  492.         guiBuffer);
  493.     EnableCategory57ScreenDone();
  494.     SetCategory57RightSoftkeyFunctions(EntryScr4PicEditFillPicSaveConfirm, GoBackHistory);
  495. }
  498. /*****************************************************************************
  499.  * FUNCTION
  500.  *  ExitScr4PicEditFillPic
  501.  * DESCRIPTION
  502.  *  Exit function for EntryScr4PicEditFillPic
  503.  * PARAMETERS
  504.  *  void
  505.  * RETURNS
  506.  *  void
  507.  *****************************************************************************/
  508. void ExitScr4PicEditFillPic(void)
  509. {
  510.     /*----------------------------------------------------------------*/
  511.     /* Local Variables                                                */
  512.     /*----------------------------------------------------------------*/
  513.     history h;
  514.     S16 nHistory = 0;
  515.     U16 inputBufferSize;
  517.     /*----------------------------------------------------------------*/
  518.     /* Code Body                                                      */
  519.     /*----------------------------------------------------------------*/
  520.     CloseCategory57Screen();
  521.     h.scrnID = SCR_PE_FILL_PIC;
  522.     h.entryFuncPtr = EntryScr4PicEditFillPic;
  523.     pfnUnicodeStrcpy((S8*) h.inputBuffer, (S8*) & nHistory);
  524.     GetCategory57History(h.guiBuffer);
  525.     inputBufferSize = (S16) GetCategory57DataSize();    /* added for inline edit history */
  526.     GetCategory57Data((U8*) h.inputBuffer);             /* added for inline edit history */
  527.     AddNHistory(h, inputBufferSize);                    /* added for inline edit history */
  528. }
  531. /*****************************************************************************
  532.  * FUNCTION
  533.  *  ChangeSoftkeyFillPic
  534.  * DESCRIPTION
  535.  *  Changes softkeys when inline item selected
  536.  * PARAMETERS
  537.  *  index       [IN]        
  538.  * RETURNS
  539.  *  void
  540.  *****************************************************************************/
  541. void ChangeSoftkeyFillPic(S32 index)
  542. {
  543.     /*----------------------------------------------------------------*/
  544.     /* Local Variables                                                */
  545.     /*----------------------------------------------------------------*/
  547.     /*----------------------------------------------------------------*/
  548.     /* Code Body                                                      */
  549.     /*----------------------------------------------------------------*/
  550.     if (gpPicEditPen->penBackgrdColorIndex != (U8) g_pe_color_index)
  551.     {
  552.         ChangeRightSoftkey(STR_GLOBAL_DONE, IMG_GLOBAL_BACK);
  553.         ChangeLeftSoftkey((U16) NULL, (U16) NULL);
  554.         SetRightSoftkeyFunction(EntryScr4PicEditFillPicSaveConfirm, KEY_EVENT_UP);
  555.     }
  556.     else
  557.     {
  558.         ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  559.         /* ChangeLeftSoftkey(STR_GLOBAL_OK,IMG_GLOBAL_OK); */
  560.         SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  561.         SetCategory57LeftSoftkeyFunction(EntryScr4PicEditFillPicSaveConfirm);
  562.     }
  563. }
  566. /*****************************************************************************
  567.  * FUNCTION
  568.  *  PicEditFillPicSelectInlineEdit
  569.  * DESCRIPTION
  570.  *  Changes softkeys when inline item selected
  571.  * PARAMETERS
  572.  *  index       [IN]        
  573.  * RETURNS
  574.  *  void
  575.  *****************************************************************************/
  576. void PicEditFillPicSelectInlineEdit(S32 index)
  577. {
  578.     /*----------------------------------------------------------------*/
  579.     /* Local Variables                                                */
  580.     /*----------------------------------------------------------------*/
  582.     /*----------------------------------------------------------------*/
  583.     /* Code Body                                                      */
  584.     /*----------------------------------------------------------------*/
  585.     g_pe_color_index = index + 1;
  586.     ChangeSoftkeyFillPic(index);
  587. }
  590. /*****************************************************************************
  591.  * FUNCTION
  592.  *  EntryScr4PicEditFillPicSaveConfirm
  593.  * DESCRIPTION
  594.  *  Confirmation screen for filling image with color selected
  595.  * PARAMETERS
  596.  *  void
  597.  * RETURNS
  598.  *  void
  599.  *****************************************************************************/
  600. void EntryScr4PicEditFillPicSaveConfirm(void)
  601. {
  602. #if (0)
  603. /* under construction !*/
  604. /* under construction !*/
  605. /* under construction !*/
  606. /* under construction !*/
  607. /* under construction !*/
  608. /* under construction !*/
  609. /* under construction !*/
  610. /* under construction !*/
  611. /* under construction !*/
  612. /* under construction !*/
  613. /* under construction !*/
  614. /* under construction !*/
  615. /* under construction !*/
  616. /* under construction !*/
  617. #endif /* (0) */ 
  619.     /*----------------------------------------------------------------*/
  620.     /* Code Body                                                      */
  621.     /*----------------------------------------------------------------*/
  622.     DisplayConfirm(
  623.         STR_GLOBAL_YES,
  624.         IMG_GLOBAL_YES,
  625.         STR_GLOBAL_NO,
  626.         IMG_GLOBAL_NO,
  627.         get_string(STR_PE_EDIT_OPT_FILL_PIC),
  628.         IMG_GLOBAL_QUESTION,
  629.         WARNING_TONE);
  631.     SetLeftSoftkeyFunction(SavePicEditFillPic, KEY_EVENT_UP);
  633.     SetRightSoftkeyFunction(GoBackPicEditFillPicConfirmHistory, KEY_EVENT_UP);
  635.     /* playRequestedTone(WARNING_TONE) ; */
  637.     /* SetExitHandler(SCR_PE_FILL_PIC_SAVE, ExitScr4PicEditFillPicSaveConfirm); */
  638. }
  641. /*****************************************************************************
  642.  * FUNCTION
  643.  *  ExitScr4PicEditFillPicSaveConfirm
  644.  * DESCRIPTION
  645.  *  Exit function for EntryScr4PicEditFillPicSaveConfirm
  646.  * PARAMETERS
  647.  *  void
  648.  * RETURNS
  649.  *  void
  650.  *****************************************************************************/
  651. void ExitScr4PicEditFillPicSaveConfirm(void)
  652. {
  653.     /*----------------------------------------------------------------*/
  654.     /* Local Variables                                                */
  655.     /*----------------------------------------------------------------*/
  656.     history h;  /* Variable to hold the history data */
  657.     S16 nHistory = 0;
  659.     /*----------------------------------------------------------------*/
  660.     /* Code Body                                                      */
  661.     /*----------------------------------------------------------------*/
  662.     stopRequestedTone(WARNING_TONE);
  663.     h.scrnID = SCR_PE_FILL_PIC_SAVE;
  664.     h.entryFuncPtr = EntryScr4PicEditFillPicSaveConfirm;
  665.     pfnUnicodeStrcpy((S8*) h.inputBuffer, (S8*) & nHistory);
  666.     GetCategoryHistory(h.guiBuffer);
  667. }
  670. /*****************************************************************************
  671.  * FUNCTION
  672.  *  GoBackPicEditFillPicConfirmHistory
  673.  * DESCRIPTION
  674.  *  Go Back history function for the confirmation screen for filling image
  675.  * PARAMETERS
  676.  *  void
  677.  * RETURNS
  678.  *  void
  679.  *****************************************************************************/
  680. void GoBackPicEditFillPicConfirmHistory(void)
  681. {
  682.     /*----------------------------------------------------------------*/
  683.     /* Local Variables                                                */
  684.     /*----------------------------------------------------------------*/
  686.     /*----------------------------------------------------------------*/
  687.     /* Code Body                                                      */
  688.     /*----------------------------------------------------------------*/
  689.     CloseCategory57Screen();
  690.     DeleteUptoScrID(SCR_PE_EDIT_PIC_OPT);
  691.     GoBackHistory();
  692. }
  695. /*****************************************************************************
  696.  * FUNCTION
  697.  *  SavePicEditFillPic
  698.  * DESCRIPTION
  699.  *  Fills image with the color selected
  700.  * PARAMETERS
  701.  *  void
  702.  * RETURNS
  703.  *  void
  704.  *****************************************************************************/
  705. void SavePicEditFillPic(void)
  706. {
  707.     /*----------------------------------------------------------------*/
  708.     /* Local Variables                                                */
  709.     /*----------------------------------------------------------------*/
  710.     U8 infoPalette[MAX_TYPE_PEN_COLOR * 4];
  712.     /*----------------------------------------------------------------*/
  713.     /* Code Body                                                      */
  714.     /*----------------------------------------------------------------*/
  715.     gpPicEditPen->penBackgrdColorIndex = (U8) nInlinePenColorIndex + 1;
  716.     CloseCategory57Screen();
  717.     GetPaletteInfo(infoPalette);
  719.     gPEImageWidth_bak = gPEImageWidth;
  720.     gPEImageHeight_bak = gPEImageHeight;
  721.     SET_PE_IMAGE_EDIT(gPEAttrib);
  722.     UNSET_PE_MARK_IMAGE(gPEAttrib);
  723.     UNSET_PE_COPY_IMAGE(gPEAttrib);
  725.     memcpy(&gpPEFileBuff[54], &infoPalette, MAX_TYPE_PEN_COLOR * gPEBitsPerPixel);
  726.     memset(
  727.         &gpPEFileBuff[PIC_EDIT_FILE_HEADER_SIZE],
  728.         ((gpPicEditPen->penBackgrdColorIndex) | (gpPicEditPen->penBackgrdColorIndex << 4)),
  729.         (gpPicEditPen->maxY - gpPicEditPen->minY) * GetImageWidth(gpPicEditPen->minX, gpPicEditPen->maxX));
  730.     SavePEContext();
  731.     DisplayPopup((PU8) GetString(STR_GLOBAL_DONE), IMG_GLOBAL_ACTIVATED, 1, PE_NOTIFYDURATION, SUCCESS_TONE);
  732.     DeleteUptoScrID(SCR_PE_EDIT_PIC);
  733. }
  736. /*****************************************************************************
  737.  * FUNCTION
  738.  *  EntryScr4PicEditScrResize
  739.  * DESCRIPTION
  740.  *  Entry screen for resize image
  741.  * PARAMETERS
  742.  *  void
  743.  * RETURNS
  744.  *  void
  745.  *****************************************************************************/
  746. void EntryScr4PicEditScrResize(void)
  747. {
  748.     /*----------------------------------------------------------------*/
  749.     /* Local Variables                                                */
  750.     /*----------------------------------------------------------------*/
  751.     U8 *guiBuffer;
  752.     U8 iCount;
  753.     U8 *inputBuffer;        /* added for inline edit history */
  754.     U16 inputBufferSize;    /* added for inline edit history */
  756.     /*----------------------------------------------------------------*/
  757.     /* Code Body                                                      */
  758.     /*----------------------------------------------------------------*/
  759.     /* ExecuteCurrExitHandler(); */
  760.     EntryNewScreen(SCR_PE_SCR_RESIZE, ExitScr4PicEditScrResize, NULL, NULL);
  761.     InitializeCategory57Screen();
  762.     guiBuffer = GetCurrGuiBuffer(SCR_PE_SCR_RESIZE);
  764.     //Pixtel patch
  765.     //      memset( (void *)PicEditInLineItems, 0, sizeof( InlineItem )*MAX_RESIZE_INLINE_EDIT );
  767.     for (iCount = 0; iCount < MAX_TYPE_SCR_TYPE; ++iCount)
  768.     {
  769.     #ifdef __MMI_MAINLCD_240X320__
  770.         pInlinePEScrList[iCount] = (U8*) GetString((U16) (iCount + STR_PE_RESIZE_32)); /* 110805 resize region Calvin added */
  771.     #else 
  772.         pInlinePEScrList[iCount] = (U8*) GetString((U16) (iCount + STR_PE_RESIZE_16));
  773.     #endif 
  774.     }
  775.     inputBuffer = GetCurrNInputBuffer(SCR_PE_SCR_RESIZE, &inputBufferSize);     /* added for inline edit history */
  777.     //Pixtel patch
  778.     //      FillPicEditResizeInLine(PicEditInLineItems);
  779.     RegisterHighlightHandler(ChangeResizeSoftKey);
  781.     /* Pixtel patch */
  782.     if (inputBuffer != NULL)    /* added for inline edit history */
  783.     {
  784.         SetCategory57Data(PicEditInLineItems, MAX_RESIZE_INLINE_EDIT, inputBuffer);     /* sets the data */
  785.     }
  786.     else
  787.     {
  788.         memset((void*)PicEditInLineItems, 0, sizeof(InlineItem) * MAX_RESIZE_INLINE_EDIT);
  789.         FillPicEditResizeInLine(PicEditInLineItems);
  790.     }
  791.     DisableCategory57ScreenDone();
  793.     ShowCategory57Screen(
  794.         STR_PE_EDIT_OPT_RESIZE,
  795.         GetRootTitleIcon(MENU_PICTURE_EDITOR),
  796.         STR_GLOBAL_OK,
  797.         IMG_GLOBAL_OK,
  798.         STR_GLOBAL_BACK,
  799.         IMG_GLOBAL_BACK,
  800.         MAX_RESIZE_INLINE_EDIT,
  801.         (U16*) NULL,
  802.         PicEditInLineItems,
  803.         0,
  804.         guiBuffer);
  806.     DisableCategory57ScreenDone();
  807.     SetLeftSoftkeyFunction(ValidateScrWidthHeight, KEY_EVENT_UP);
  808.     SetCategory57RightSoftkeyFunctions(ValidateScrWidthHeight, GoBackHistory);
  809.     /* SetExitHandler(SCR_PE_SCR_RESIZE, ExitScr4PicEditScrResize); */
  810. }
  813. /*****************************************************************************
  814.  * FUNCTION
  815.  *  ExitScr4PicEditScrResize
  816.  * DESCRIPTION
  817.  *  Exit function for EntryScr4PicEditScrResize
  818.  * PARAMETERS
  819.  *  void
  820.  * RETURNS
  821.  *  void
  822.  *****************************************************************************/
  823. void ExitScr4PicEditScrResize(void)
  824. {
  825.     /*----------------------------------------------------------------*/
  826.     /* Local Variables                                                */
  827.     /*----------------------------------------------------------------*/
  828.     history h;
  829.     S16 nHistory = 0;
  830.     U16 inputBufferSize;
  832.     /*----------------------------------------------------------------*/
  833.     /* Code Body                                                      */
  834.     /*----------------------------------------------------------------*/
  835.     CloseCategory57Screen();
  836.     h.scrnID = SCR_PE_SCR_RESIZE;
  837.     h.entryFuncPtr = EntryScr4PicEditScrResize;
  838.     pfnUnicodeStrcpy((S8*) h.inputBuffer, (S8*) & nHistory);
  839.     GetCategoryHistory(h.guiBuffer);
  840.     inputBufferSize = (S16) GetCategory57DataSize();    /* added for inline edit history */
  841.     GetCategory57Data((U8*) h.inputBuffer);             /* added for inline edit history */
  842.     AddNHistory(h, inputBufferSize);                    /* added for inline edit history */
  844. }
  847. /*****************************************************************************
  848.  * FUNCTION
  849.  *  FillPicEditResizeInLine
  850.  * DESCRIPTION
  851.  *  Fills the Inline buffer for resize image screen
  852.  * PARAMETERS
  853.  *  ResizeInline        [?]     
  854.  * RETURNS
  855.  *  void
  856.  *****************************************************************************/
  857. void FillPicEditResizeInLine(InlineItem *ResizeInline)
  858. {
  859.     /*----------------------------------------------------------------*/
  860.     /* Local Variables                                                */
  861.     /*----------------------------------------------------------------*/
  863.     /*----------------------------------------------------------------*/
  864.     /* Code Body                                                      */
  865.     /*----------------------------------------------------------------*/
  866.     SetInlineItemActivation(&ResizeInline[0], INLINE_ITEM_ACTIVATE_WITHOUT_KEY_EVENT, 0);
  867.     SetInlineItemCaption(&ResizeInline[0], (PU8) (GetString(STR_PE_RESIZE_TO)));
  869.     SetInlineItemActivation(&ResizeInline[1], INLINE_ITEM_ACTIVATE_WITHOUT_KEY_EVENT, 0);
  870.     SetInlineItemSelect(&ResizeInline[1], (S32) MAX_TYPE_SCR_TYPE, pInlinePEScrList, &nInlinePEScr);
  871.     RegisterInlineSelectHighlightHandler(&ResizeInline[1], HighlightResizeInlineItemHandler);
  873.     SetInlineItemActivation(&ResizeInline[2], INLINE_ITEM_ACTIVATE_WITHOUT_KEY_EVENT, 0);
  874.     SetInlineItemCaption(&ResizeInline[2], (PU8) (GetString(STR_PE_RESIZE_WIDTH)));
  876.     SetInlineItemActivation(&ResizeInline[3], INLINE_ITEM_ACTIVATE_WITHOUT_KEY_EVENT, 0);
  877.     SetInlineItemTextEdit(&ResizeInline[3], (PU8) nInlinePEScrWidth, PE_RESIZE_BUF_SIZE, INPUT_TYPE_NUMERIC);   /* 100405 image editor Calvin */
  878.     RightJustifyInlineItem(&ResizeInline[3]);
  879.     EnableInlineItemBoundary(&ResizeInline[3]);
  881.     SetInlineItemActivation(&ResizeInline[4], INLINE_ITEM_ACTIVATE_WITHOUT_KEY_EVENT, 0);
  882.     SetInlineItemCaption(&ResizeInline[4], (PU8) (GetString(STR_PE_RESIZE_HEIGHT)));
  884.     SetInlineItemActivation(&ResizeInline[5], INLINE_ITEM_ACTIVATE_WITHOUT_KEY_EVENT, 0);
  885.     SetInlineItemTextEdit(&ResizeInline[5], (PU8) nInlinePEScrHeight, PE_RESIZE_BUF_SIZE, INPUT_TYPE_NUMERIC);  /* 100405 image editor Calvin */
  886.     RightJustifyInlineItem(&ResizeInline[5]);
  887.     EnableInlineItemBoundary(&ResizeInline[5]);
  888. }
  891. /*****************************************************************************
  892.  * FUNCTION
  893.  *  HighlightResizeInlineItemHandler
  894.  * DESCRIPTION
  895.  *  Highlight Handler for Inline Item selected
  896.  * PARAMETERS
  897.  *  index       [IN]        
  898.  * RETURNS
  899.  *  void
  900.  *****************************************************************************/
  901. void HighlightResizeInlineItemHandler(S32 index)
  902. {
  903.     /*----------------------------------------------------------------*/
  904.     /* Local Variables                                                */
  905.     /*----------------------------------------------------------------*/
  906.     U8 scrWParam[4 * ENCODING_LENGTH], scrHParam[4 * ENCODING_LENGTH];
  908.     /*----------------------------------------------------------------*/
  909.     /* Code Body                                                      */
  910.     /*----------------------------------------------------------------*/
  911.     if (index == PE_SCR_4)
  912.     {
  913.         if (!nInlinePenColorIndex)
  914.         {
  915.             /* Leo start 20050824 */
  916.             //                      sprintf((PS8)scrWParam,"%d",nInlinePenSize);
  917.             //                      sprintf((PS8)scrHParam,"%d",nInlinePenMoveFactor);
  918.             /* Leo end 20050824 */
  919.             sprintf((PS8) scrWParam, "%d", gPEImageWidth);
  920.             sprintf((PS8) scrHParam, "%d", gPEImageHeight);
  921.             nInlinePenColorIndex = 1;
  922.             AnsiiToUnicodeString((PS8) nInlinePEScrWidth, (PS8) scrWParam);
  923.             AnsiiToUnicodeString((PS8) nInlinePEScrHeight, (PS8) scrHParam);
  924.             EnableInlineItem(PicEditInLineItems, 3);
  925.             EnableInlineItem(PicEditInLineItems, 5);
  926.         }
  927.     }
  928.     else
  929.     {
  930.         if (nInlinePenColorIndex)
  931.         {
  932.             UnicodeToAnsii((PS8) scrWParam, (PS8) nInlinePEScrWidth);
  933.             UnicodeToAnsii((PS8) scrHParam, (PS8) nInlinePEScrHeight);
  934.             nInlinePenSize = (U16) atoi((PS8) scrWParam);
  935.             nInlinePenMoveFactor = (U16) atoi((PS8) scrHParam);
  936.             nInlinePenColorIndex = 0;
  937.         }
  938.         sprintf((PS8) scrWParam, "");
  939.         sprintf((PS8) scrHParam, "");
  940.         AnsiiToUnicodeString((PS8) nInlinePEScrWidth, (PS8) scrWParam);
  941.         AnsiiToUnicodeString((PS8) nInlinePEScrHeight, (PS8) scrHParam);
  942.         DisableInlineItem(PicEditInLineItems, 3);
  943.         DisableInlineItem(PicEditInLineItems, 5);
  944.     }
  945.     RedrawCategoryFunction();
  946. }
  949. /*****************************************************************************
  950.  * FUNCTION
  951.  *  ChangeResizeSoftKey
  952.  * DESCRIPTION
  953.  *  Change softkey for Resize screen
  954.  * PARAMETERS
  955.  *  nIndex      [IN]        
  956.  * RETURNS
  957.  *  void
  958.  *****************************************************************************/
  959. void ChangeResizeSoftKey(S32 nIndex)
  960. {
  961.     /*----------------------------------------------------------------*/
  962.     /* Local Variables                                                */
  963.     /*----------------------------------------------------------------*/
  965.     /*----------------------------------------------------------------*/
  966.     /* Code Body                                                      */
  967.     /*----------------------------------------------------------------*/
  968.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  969.     SetCategory57LeftSoftkeyFunction(ValidateScrWidthHeight);
  970. }
  973. /*****************************************************************************
  974.  * FUNCTION
  975.  *  SetResizeInlineItemValues
  976.  * DESCRIPTION
  977.  *  Sets Resize Inline item values
  978.  * PARAMETERS
  979.  *  void
  980.  * RETURNS
  981.  *  void
  982.  *****************************************************************************/
  983. void SetResizeInlineItemValues(void)
  984. {
  985.     /*----------------------------------------------------------------*/
  986.     /* Local Variables                                                */
  987.     /*----------------------------------------------------------------*/
  989.     /*----------------------------------------------------------------*/
  990.     /* Code Body                                                      */
  991.     /*----------------------------------------------------------------*/
  992.     nInlinePEScr = (U32) GetPicEditScr();
  993.     //nInlinePenSize used as temp buffer for inline Width
  994.     //      nInlinePenSize =(S32)gPEImageWidth;     
  995.     //      gPEImageWidth_bak =(S32)gPEImageWidth;     
  996.     //nInlinePenMoveFactor used as temp buffer for inline Height
  997.     //      nInlinePenMoveFactor =(S32)gPEImageHeight;
  998.     //      gPEImageHeight_bak =(S32)gPEImageHeight;
  999.     //nInlinePenColorIndex used as flag for Inline Resize Screen
  1000.     nInlinePenColorIndex = 0;
  1001. }
  1004. /*****************************************************************************
  1005.  * FUNCTION
  1006.  *  ValidateScrWidthHeight
  1007.  * DESCRIPTION
  1008.  *  Validates and sets the values for width and height of image
  1009.  * PARAMETERS
  1010.  *  void
  1011.  * RETURNS
  1012.  *  void
  1013.  *****************************************************************************/
  1014. void ValidateScrWidthHeight(void)
  1015. {
  1016.     /*----------------------------------------------------------------*/
  1017.     /* Local Variables                                                */
  1018.     /*----------------------------------------------------------------*/
  1019.     U8 scrWParam[4 * ENCODING_LENGTH], scrHParam[4 * ENCODING_LENGTH];
  1020.     U16 nWidth, nHeight;
  1021.     BOOL bFlag = FALSE;
  1023.     /*----------------------------------------------------------------*/
  1024.     /* Code Body                                                      */
  1025.     /*----------------------------------------------------------------*/
  1026.     CloseCategory57Screen();
  1028.     gPEImageWidth_bak = gPEImageWidth;
  1029.     gPEImageHeight_bak = gPEImageHeight;
  1030.     gPEImageResized = MMI_TRUE;
  1031.     switch (nInlinePEScr)
  1032.     {
  1033.         case PE_SCR_1:
  1034.             gPEImageWidth = PE_SCR_SIZE_1;
  1035.             gPEImageHeight = PE_SCR_SIZE_1;
  1036.             break;
  1037.         case PE_SCR_2:
  1038.             gPEImageWidth = PE_SCR_SIZE_2;
  1039.             gPEImageHeight = PE_SCR_SIZE_2;
  1040.             break;
  1041.         case PE_SCR_3:
  1042.             gPEImageWidth = PE_SCR_SIZE_MAX;
  1043.             gPEImageHeight = PE_SCR_SIZE_MAX;
  1044.             break;
  1045.         case PE_SCR_4:
  1046.             UnicodeToAnsii((PS8) scrWParam, (PS8) nInlinePEScrWidth);
  1047.             UnicodeToAnsii((PS8) scrHParam, (PS8) nInlinePEScrHeight);
  1049.             nWidth = (U16) atoi((PS8) scrWParam);
  1050.             nHeight = (U16) atoi((PS8) scrHParam);
  1052.             if (((nWidth >= PE_SCR_SIZE_MIN) && (nWidth <= PE_SCR_SIZE_MAX)) &&
  1053.                 ((nHeight >= PE_SCR_SIZE_MIN) && (nHeight <= PE_SCR_SIZE_MAX)))
  1054.             {
  1055.                 gPEImageWidth = nWidth;
  1056.                 gPEImageHeight = nHeight;
  1057.             }
  1058.             else
  1059.             {
  1060.                 /* 092005 Image Editor Size Calvin */
  1061.             #ifdef __MMI_MAINLCD_240X320__
  1062.                 DisplayPopup(
  1063.                     (U8*) GetString(STR_PE_RESIZE_ERROR_BIG),
  1064.                     IMG_GLOBAL_WARNING,
  1065.                     0,
  1066.                     PE_NOTIFYDURATION,
  1067.                     (U8) WARNING_TONE);
  1068.             #else /* __MMI_MAINLCD_240X320__ */ 
  1069.                 DisplayPopup(
  1070.                     (U8*) GetString(STR_PE_RESIZE_ERROR),
  1071.                     IMG_GLOBAL_WARNING,
  1072.                     0,
  1073.                     PE_NOTIFYDURATION,
  1074.                     (U8) WARNING_TONE);
  1075.             #endif /* __MMI_MAINLCD_240X320__ */ 
  1076.                 /* 092005 Calvin end */
  1077.                 bFlag = TRUE;
  1078.             }
  1079.             break;
  1080.         default:
  1081.             gPEImageWidth = PE_SCR_SIZE_2;
  1082.             gPEImageHeight = PE_SCR_SIZE_2;
  1083.             break;
  1084.     }
  1086.     if (!bFlag)
  1087.     {
  1088.         /* CloseCategory57Screen(); */
  1089.         UNSET_PE_PEN_DOWN(gPEAttrib);
  1091.         /* check if image is resized to smaller size */
  1092.         if (!SetPicEditPenMarkBoundary())
  1093.         {
  1094.             SavePEContext();
  1095.             gPECurrentAction = SEL_PE_EDIT_OPT_SAVE_PIC;
  1096.             SetPicEditPenBoundary();
  1097.             ResizePicEditImageDataBuff();
  1098.             if (IS_PE_ZOOM_IMAGE(gPEAttrib))
  1099.             {
  1100.                 SetPicEditZoomWindow(FALSE);
  1101.             }
  1102.             SET_PE_IMAGE_EDIT(gPEAttrib);
  1103.             UNSET_PE_MARK_IMAGE(gPEAttrib);
  1104.             DisplayPopup((PU8) GetString(STR_GLOBAL_DONE), IMG_GLOBAL_ACTIVATED, 1, PE_NOTIFYDURATION, SUCCESS_TONE);
  1105.             DeleteUptoScrID(SCR_PE_EDIT_PIC);
  1106.         }
  1107.         else
  1108.         {
  1109.             gPECurrentAction = SEL_PE_EDIT_OPT_RESIZE;
  1110.             DeleteUptoScrID(SCR_PE_EDIT_PIC);
  1111.             GoBackHistory();
  1112.         }
  1113.     }
  1114. }
  1117. /*****************************************************************************
  1118.  * FUNCTION
  1119.  *  EntryScr4PicEditHelp
  1120.  * DESCRIPTION
  1121.  *  Entry screen for help
  1122.  * PARAMETERS
  1123.  *  void
  1124.  * RETURNS
  1125.  *  void
  1126.  *****************************************************************************/
  1127. void EntryScr4PicEditHelp(void)
  1128. {
  1129.     /*----------------------------------------------------------------*/
  1130.     /* Local Variables                                                */
  1131.     /*----------------------------------------------------------------*/
  1132.     U8 *guiBuffer;
  1133.     S8 *buffer;
  1134.     S32 bufferSize;
  1136.     /*----------------------------------------------------------------*/
  1137.     /* Code Body                                                      */
  1138.     /*----------------------------------------------------------------*/
  1139.     /* ExecuteCurrExitHandler(); */
  1140.     EntryNewScreen(SCR_PE_HELP, ExitScr4PicEditHelp, NULL, NULL);
  1141.     guiBuffer = GetCurrGuiBuffer(SCR_PE_HELP);
  1142.     /* Leo add 20050705 start */
  1143. #ifdef __MMI_TOUCH_SCREEN__
  1144.     buffer = GetString(STR_PE_HELP_DESCRIPTION_TOUCH);
  1145. #else 
  1146.     buffer = GetString(STR_PE_HELP_DESCRIPTION);
  1147. #endif 
  1148.     /* Leo add 20050705 end */
  1149.     bufferSize = pfnUnicodeStrlen(buffer);
  1151.     ShowCategory74Screen(
  1152.         STR_PE_EDIT_OPT_HELP,
  1153.         GetRootTitleIcon(MENU_PICTURE_EDITOR),
  1154.         0,
  1155.         0,
  1156.         STR_GLOBAL_BACK,
  1157.         IMG_GLOBAL_BACK,
  1158.         (PU8) buffer,
  1159.         bufferSize,
  1160.         guiBuffer);
  1162.     /* go back to option menu */
  1163.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  1164.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1165.     /* SetExitHandler (SCR_PE_HELP,ExitScr4PicEditHelp); */
  1166. }
  1169. /*****************************************************************************
  1170.  * FUNCTION
  1171.  *  ExitScr4PicEditHelp
  1172.  * DESCRIPTION
  1173.  *  Exit function for EntryScr4PicEditHelp
  1174.  * PARAMETERS
  1175.  *  void
  1176.  * RETURNS
  1177.  *  void
  1178.  *****************************************************************************/
  1179. void ExitScr4PicEditHelp(void)
  1180. {
  1181.     /*----------------------------------------------------------------*/
  1182.     /* Local Variables                                                */
  1183.     /*----------------------------------------------------------------*/
  1184.     history h;
  1185.     S16 nHistory = 0;
  1187.     /*----------------------------------------------------------------*/
  1188.     /* Code Body                                                      */
  1189.     /*----------------------------------------------------------------*/
  1190.     h.scrnID = SCR_PE_HELP;
  1191.     h.entryFuncPtr = EntryScr4PicEditHelp;
  1192.     pfnUnicodeStrcpy((S8*) h.inputBuffer, (S8*) & nHistory);
  1193.     GetCategoryHistory(h.guiBuffer);
  1194.     AddHistory(h);
  1195. }
  1198. /*****************************************************************************
  1199.  * FUNCTION
  1200.  *  EntryScr4PicEditCustomColor
  1201.  * DESCRIPTION
  1202.  *  Entry screen function for custom color setting change
  1203.  * PARAMETERS
  1204.  *  void
  1205.  * RETURNS
  1206.  *  void
  1207.  *****************************************************************************/
  1208. void EntryScr4PicEditCustomColor(void)
  1209. {
  1210.     /*----------------------------------------------------------------*/
  1211.     /* Local Variables                                                */
  1212.     /*----------------------------------------------------------------*/
  1213.     U8 *guiBuffer;
  1215.     /*----------------------------------------------------------------*/
  1216.     /* Code Body                                                      */
  1217.     /*----------------------------------------------------------------*/
  1218.     /* ExecuteCurrExitHandler(); */
  1219.     EntryNewScreen(SCR_PE_CUSTOM_COLOR, ExitScr4PicEditCustomColor, NULL, NULL);
  1220.     guiBuffer = GetCurrGuiBuffer(SCR_PE_CUSTOM_COLOR);
  1222.     inlineCustomRGB[0] = inlinePERGBlist[PE_COLOR_CUSTOM_1][0];
  1223.     inlineCustomRGB[1] = inlinePERGBlist[PE_COLOR_CUSTOM_1][1];
  1224.     inlineCustomRGB[2] = inlinePERGBlist[PE_COLOR_CUSTOM_1][2];
  1226.     ShowCategory91Screen(
  1227.         STR_PE_COLOR_SEL,
  1228.         GetRootTitleIcon(MENU_PICTURE_EDITOR),
  1229.         STR_GLOBAL_OK,
  1230.         IMG_GLOBAL_OK,
  1231.         STR_GLOBAL_BACK,
  1232.         IMG_GLOBAL_BACK,
  1233.         &inlineCustomRGB[0],
  1234.         &inlineCustomRGB[1],
  1235.         &inlineCustomRGB[2],
  1236.         &highlighted_slider,
  1237.         guiBuffer);
  1239.     SetLeftSoftkeyFunction(SavePicEditCustomColor, KEY_EVENT_UP);
  1240.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1241.     /* SetExitHandler(SCR_PE_CUSTOM_COLOR, ExitScr4PicEditCustomColor); */
  1242. }
  1245. /*****************************************************************************
  1246.  * FUNCTION
  1247.  *  ExitScr4PicEditCustomColor
  1248.  * DESCRIPTION
  1249.  *  Exit function for EntryScr4PicEditCustomColor
  1250.  * PARAMETERS
  1251.  *  void
  1252.  * RETURNS
  1253.  *  void
  1254.  *****************************************************************************/
  1255. void ExitScr4PicEditCustomColor(void)
  1256. {
  1257.     /*----------------------------------------------------------------*/
  1258.     /* Local Variables                                                */
  1259.     /*----------------------------------------------------------------*/
  1260.     history h;
  1261.     S16 nHistory = 0;
  1263.     /*----------------------------------------------------------------*/
  1264.     /* Code Body                                                      */
  1265.     /*----------------------------------------------------------------*/
  1266.     h.scrnID = SCR_PE_CUSTOM_COLOR;
  1267.     h.entryFuncPtr = EntryScr4PicEditCustomColor;
  1268.     pfnUnicodeStrcpy((S8*) h.inputBuffer, (S8*) & nHistory);
  1269.     GetCategoryHistory(h.guiBuffer);
  1270.     AddHistory(h);
  1271. }
  1274. /*****************************************************************************
  1275.  * FUNCTION
  1276.  *  SavePicEditCustomColor
  1277.  * DESCRIPTION
  1278.  *  Saves custom color settings
  1279.  * PARAMETERS
  1280.  *  void
  1281.  * RETURNS
  1282.  *  void
  1283.  *****************************************************************************/
  1284. void SavePicEditCustomColor(void)
  1285. {
  1286.     /*----------------------------------------------------------------*/
  1287.     /* Local Variables                                                */
  1288.     /*----------------------------------------------------------------*/
  1289.     U8 infoPalette[MAX_TYPE_PEN_COLOR * 4];
  1291.     /*----------------------------------------------------------------*/
  1292.     /* Code Body                                                      */
  1293.     /*----------------------------------------------------------------*/
  1294.     inlinePERGBlist[PE_COLOR_CUSTOM_1][0] = inlineCustomRGB[0];
  1295.     inlinePERGBlist[PE_COLOR_CUSTOM_1][1] = inlineCustomRGB[1];
  1296.     inlinePERGBlist[PE_COLOR_CUSTOM_1][2] = inlineCustomRGB[2];
  1297.     gPEColorRGB[PE_COLOR_CUSTOM_1] &= 0x000000FF;
  1298.     gPEColorRGB[PE_COLOR_CUSTOM_1] |=
  1299.         ((((U32) inlineCustomRGB[0]) << 24) | (((U32) inlineCustomRGB[1]) << 16) |
  1300.          (((U32) inlineCustomRGB[2]) << 8));
  1302.     /* Removed by Leo               gpPicEditPen->penColorIndex=(U8)nInlinePenColorIndex+1; */
  1303.     GetPaletteInfo(infoPalette);
  1304.     memcpy(gpPEFileBuff + 54, &infoPalette, MAX_TYPE_PEN_COLOR * gPEBitsPerPixel);
  1306.     GoBackHistory();
  1307. }
  1310. /*****************************************************************************
  1311.  * FUNCTION
  1312.  *  EntryScr4PicEditSaveImageConfirm
  1313.  * DESCRIPTION
  1314.  *  Confirmation screen for Saving image
  1315.  * PARAMETERS
  1316.  *  void
  1317.  * RETURNS
  1318.  *  void
  1319.  *****************************************************************************/
  1320. void EntryScr4PicEditSaveImageConfirm(void)
  1321. {
  1322. #if (0)
  1323. /* under construction !*/
  1324. /* under construction !*/
  1325. /* under construction !*/
  1326. /* under construction !*/
  1327. /* under construction !*/
  1328. /* under construction !*/
  1329. /* under construction !*/
  1330. /* under construction !*/
  1331. /* under construction !*/
  1332. /* under construction !*/
  1333. /* under construction !*/
  1334. /* under construction !*/
  1335. /* under construction !*/
  1336. /* under construction !*/
  1337. #endif /* (0) */ 
  1339.     /*----------------------------------------------------------------*/
  1340.     /* Code Body                                                      */
  1341.     /*----------------------------------------------------------------*/
  1342.     DisplayConfirm(
  1343.         STR_GLOBAL_YES,
  1344.         IMG_GLOBAL_YES,
  1345.         STR_GLOBAL_NO,
  1346.         IMG_GLOBAL_NO,
  1347.         get_string(STR_GLOBAL_SAVE),
  1348.         IMG_GLOBAL_QUESTION,
  1349.         WARNING_TONE);
  1351.     SetLeftSoftkeyFunction(PicEditSaveImage, KEY_EVENT_UP);
  1352.     SetRightSoftkeyFunction(GoBackPicEditSaveImageConfirmHistory, KEY_EVENT_UP);
  1353.     playRequestedTone(WARNING_TONE);
  1354.     /* SetExitHandler(SCR_PE_SAVE_IMAGE_CONFIRM, ExitScr4PicEditPenSettingSaveConfirm); */
  1355. }
  1358. /*****************************************************************************
  1359.  * FUNCTION
  1360.  *  ExitScr4PicEditSaveImageConfirm
  1361.  * DESCRIPTION
  1362.  *  Exit screen function for EntryScr4PicEditSaveImageConfirm
  1363.  * PARAMETERS
  1364.  *  void
  1365.  * RETURNS
  1366.  *  void
  1367.  *****************************************************************************/
  1368. void ExitScr4PicEditSaveImageConfirm(void)
  1369. {
  1370.     /*----------------------------------------------------------------*/
  1371.     /* Local Variables                                                */
  1372.     /*----------------------------------------------------------------*/
  1373.     history h;  /* Variable to hold the history data */
  1374.     S16 nHistory = 0;
  1376.     /*----------------------------------------------------------------*/
  1377.     /* Code Body                                                      */
  1378.     /*----------------------------------------------------------------*/
  1379.     stopRequestedTone(WARNING_TONE);
  1380.     h.scrnID = SCR_PE_SAVE_IMAGE_CONFIRM;
  1381.     h.entryFuncPtr = EntryScr4PicEditSaveImageConfirm;
  1382.     pfnUnicodeStrcpy((S8*) h.inputBuffer, (S8*) & nHistory);
  1383.     GetCategoryHistory(h.guiBuffer);
  1384. }
  1387. /*****************************************************************************
  1388.  * FUNCTION
  1389.  *  GoBackPicEditSaveImageConfirmHistory
  1390.  * DESCRIPTION
  1391.  *  Go back histroy fucntion for saving image confirmation screen
  1392.  * PARAMETERS
  1393.  *  void
  1394.  * RETURNS
  1395.  *  void
  1396.  *****************************************************************************/
  1397. void GoBackPicEditSaveImageConfirmHistory(void)
  1398. {
  1399.     /*----------------------------------------------------------------*/
  1400.     /* Local Variables                                                */
  1401.     /*----------------------------------------------------------------*/
  1403.     /*----------------------------------------------------------------*/
  1404.     /* Code Body                                                      */
  1405.     /*----------------------------------------------------------------*/
  1406.     InitPicEditPen();
  1407.     GoBacknHistory(1);
  1408. }
  1411. /*****************************************************************************
  1412.  * FUNCTION
  1413.  *  PicEditSaveImage
  1414.  * DESCRIPTION
  1415.  *  Saves image
  1416.  * PARAMETERS
  1417.  *  void
  1418.  * RETURNS
  1419.  *  void
  1420.  *****************************************************************************/
  1421. void PicEditSaveImage(void)
  1422. {
  1423.     /*----------------------------------------------------------------*/
  1424.     /* Local Variables                                                */
  1425.     /*----------------------------------------------------------------*/
  1426.     S32 result;
  1428.     /*----------------------------------------------------------------*/
  1429.     /* Code Body                                                      */
  1430.     /*----------------------------------------------------------------*/
  1431.     result = SavePicEditImageDataBuff();
  1433.     if (result == FS_NO_ERROR)
  1434.     {
  1435.         DisplayPopup((PU8) GetString(STR_GLOBAL_DONE), IMG_GLOBAL_ACTIVATED, 1, PE_NOTIFYDURATION, SUCCESS_TONE);
  1436.     }
  1437.     else
  1438.     {
  1439.         DisplayPopup(
  1440.             (U8*) get_string(GetFileSystemErrorString(result)),
  1441.             IMG_GLOBAL_ERROR,
  1442.             1,
  1443.             PE_NOTIFYDURATION,
  1444.             ERROR_TONE);
  1445.     }
  1446.     InitPicEditPen();
  1447.     DeleteNHistory(1);
  1448. }
  1451. /*****************************************************************************
  1452.  * FUNCTION
  1453.  *  SetPicEditPenAtCenter
  1454.  * DESCRIPTION
  1455.  *  Sets Pen at the center of the image if bflag TRUE
  1456.  * PARAMETERS
  1457.  *  bFlag       [IN]        
  1458.  * RETURNS
  1459.  *  void
  1460.  *****************************************************************************/
  1461. void SetPicEditPenAtCenter(BOOL bFlag)
  1462. {
  1463.     /*----------------------------------------------------------------*/
  1464.     /* Local Variables                                                */
  1465.     /*----------------------------------------------------------------*/
  1467.     /*----------------------------------------------------------------*/
  1468.     /* Code Body                                                      */
  1469.     /*----------------------------------------------------------------*/
  1470.     if (bFlag)
  1471.     {
  1472.         gpPicEditPen->penX = (U16) (UI_device_width / 2) + PE_IMAGE_WIDTH_EXTRA;
  1473.         gpPicEditPen->penY = (U16) (UI_device_height / 2) + PE_IMAGE_HEIGHT_EXTRA;
  1474.     }
  1475.     else
  1476.     {
  1477.         gpPicEditPen->penX = gpPicEditPen->minX;
  1478.         gpPicEditPen->penY = gpPicEditPen->minY;
  1479.     }
  1480. }
  1483. /*****************************************************************************
  1484.  * FUNCTION
  1485.  *  SetPicEditPenBoundary
  1486.  * DESCRIPTION
  1487.  *  Sets Pen boundary wrt to the image size
  1488.  * PARAMETERS
  1489.  *  void
  1490.  * RETURNS
  1491.  *  void
  1492.  *****************************************************************************/
  1493. void SetPicEditPenBoundary(void)
  1494. {
  1495.     /*----------------------------------------------------------------*/
  1496.     /* Local Variables                                                */
  1497.     /*----------------------------------------------------------------*/
  1498.     U16 nWidth, nHeight;
  1500.     /*----------------------------------------------------------------*/
  1501.     /* Code Body                                                      */
  1502.     /*----------------------------------------------------------------*/
  1503.     switch (nInlinePEScr)
  1504.     {
  1505.         case PE_SCR_1:
  1506.             nWidth = PE_SCR_SIZE_1;
  1507.             nHeight = PE_SCR_SIZE_1;
  1508.             break;
  1509.         case PE_SCR_2:
  1510.             nWidth = PE_SCR_SIZE_2;
  1511.             nHeight = PE_SCR_SIZE_2;
  1512.             break;
  1513.         case PE_SCR_3:
  1514.             nWidth = PE_SCR_SIZE_MAX;
  1515.             nHeight = PE_SCR_SIZE_MAX;
  1516.             break;
  1517.         case PE_SCR_4:
  1518.             nWidth = gPEImageWidth;
  1519.             nHeight = gPEImageHeight;
  1520.             break;
  1521.         default:
  1522.             nWidth = PE_SCR_SIZE_2;
  1523.             nHeight = PE_SCR_SIZE_2;
  1524.             break;
  1525.     }
  1527.     gpPicEditPen->minX = SET_WINDOW_MINX(nWidth);
  1528.     gpPicEditPen->maxX = gpPicEditPen->minX + (U16) nWidth;
  1529.     gpPicEditPen->minY = SET_WINDOW_MINY(nHeight);
  1530.     gpPicEditPen->maxY = gpPicEditPen->minY + (U16) nHeight;
  1531. }
  1534. /*****************************************************************************
  1535.  * FUNCTION
  1536.  *  SavePicEditImageDataBuff
  1537.  * DESCRIPTION
  1538.  *  Saves Image data buffer
  1539.  * PARAMETERS
  1540.  *  void
  1541.  * RETURNS
  1542.  *  void
  1543.  *****************************************************************************/
  1544. S32 SavePicEditImageDataBuff(void)
  1545. {
  1546.     /*----------------------------------------------------------------*/
  1547.     /* Local Variables                                                */
  1548.     /*----------------------------------------------------------------*/
  1549.     FILE_HANDLE fileHandle;
  1550.     S8 fileBuf[100 * ENCODING_LENGTH];  /* padding for filepath */
  1551.     S8 fileName[100 * ENCODING_LENGTH]; /* padding for filepath */
  1552.     S8 localBuffer[30 * ENCODING_LENGTH];
  1553.     U32 wByte = 0;
  1554.     S32 result;
  1555.     U16 image_size;
  1557.     /*----------------------------------------------------------------*/
  1558.     /* Code Body                                                      */
  1559.     /*----------------------------------------------------------------*/
  1560. #ifdef __ASCII
  1561.     pfnUnicodeStrcpy((PS8) fileName, PICTURE_EDITOR_PATH);
  1562. #else 
  1563.     AnsiiToUnicodeString((PS8) fileName, PICTURE_EDITOR_PATH);
  1564. #endif 
  1566.     memset(fileName, 0, sizeof(fileName));
  1567.     sprintf(fileBuf, "%c:\", MMI_PUBLIC_DRV);
  1568.     AnsiiToUnicodeString((S8*) fileName, (S8*) fileBuf);
  1569.     pfnUnicodeStrcat((S8*) fileName, (S8*) FMGR_DEFAULT_FOLDER_IMAGES);
  1571.     fileHandle = FS_Open((U16*) fileName, FS_OPEN_DIR | FS_READ_ONLY);
  1573.     if (fileHandle < 0)
  1574.     {
  1575.         fileHandle = pcreateDir(fileName);
  1576.         pfclose(fileHandle);
  1577.     }
  1578.     else
  1579.     {
  1580.         pfclose(fileHandle);
  1581.     }
  1583.     if (IS_PE_ADD_IMAGE(gPEAttrib))
  1584.     {
  1585.         //              wByte=0;
  1586.         //              while(1)
  1587.         //              {
  1588.         //                      sprintf(localBuffer,"Picture%d.bmp",(wByte%MAXIMUM_PICTURE_EDITOR_IMAGES)+1);
  1589.         sprintf(localBuffer, "Picture%d.bmp", gPicEditCurrPic + 1);
  1590.         AnsiiToUnicodeString((S8*) fileBuf, (S8*) localBuffer);
  1591.         //                      if (!SearchPicEditFileName(fileBuf)) break; else wByte++;
  1592.         //              }
  1593.     }
  1594.     else
  1595.     {
  1596.         pfnUnicodeStrcpy((S8*) fileBuf, (S8*) gPicEditorInfo[gPicEditCurrPic].ImageName);
  1597.     }
  1599.     pfnUnicodeStrcat((S8*) fileName, (S8*) fileBuf);
  1601.     if ((fileHandle = FS_Open((PU16) fileName, FS_READ_WRITE | FS_CREATE_ALWAYS)) < 0)
  1602.     {
  1603.         return fileHandle;
  1604.     }
  1605.     image_size = PIC_EDIT_FILE_HEADER_SIZE + ((GetImageWidth(0, gPEImageWidth) * gPEImageHeight));
  1606.     memcpy((S8*) & gpPEFileBuff[2], &image_size, 2);
  1607.     /* pfwrite(gpPEFileBuff,1,PIC_EDIT_FILE_BUFF,fileHandle,&wByte); */
  1608.     result = FS_Write(fileHandle, gpPEFileBuff, image_size, &wByte);    /* (gpPEFileBuff,1,image_size,fileHandle,&wByte); */
  1609.     if (result < 0)
  1610.     {
  1611.         FS_Close(fileHandle);
  1612.         return result;
  1613.     }
  1614.     FS_Close(fileHandle);
  1615.     if (IS_PE_ADD_IMAGE(gPEAttrib))
  1616.     {
  1617.         /* AddPictureEditorImage(( S8*)fileBuf); */
  1618.         AddPictureEditorImageAtIndex((S8*) fileBuf, gPicEditCurrPic);
  1619.         WritePicEditListToNVRAM();
  1620.     }
  1621.     return FS_NO_ERROR;
  1622. }
  1625. /*****************************************************************************
  1626.  * FUNCTION
  1627.  *  SearchPicEditFileName
  1628.  * DESCRIPTION
  1629.  *  Search file name in the images already present
  1630.  * PARAMETERS
  1631.  *  sFile       [?]     
  1632.  * RETURNS
  1633.  *  void
  1634.  *****************************************************************************/
  1635. U8 SearchPicEditFileName(S8 *sFile)
  1636. {
  1637.     /*----------------------------------------------------------------*/
  1638.     /* Local Variables                                                */
  1639.     /*----------------------------------------------------------------*/
  1640.     U8 jCount;
  1642.     /*----------------------------------------------------------------*/
  1643.     /* Code Body                                                      */
  1644.     /*----------------------------------------------------------------*/
  1645.     /* for (jCount=0;jCount<gPEImageCount;jCount++) */
  1646.     for (jCount = 0; jCount < MAXIMUM_PICTURE_EDITOR_IMAGES; jCount++)
  1647.     {
  1648.         if ((gPicEditorInfo[jCount].ImagesId) &&
  1649.             (!pfnUnicodeStrcmp((S8*) sFile, (S8*) gPicEditorInfo[jCount].ImageName)))
  1650.         {
  1651.             return 1;
  1652.         }
  1653.     }
  1654.     return 0;
  1655. }
  1658. /*****************************************************************************
  1659.  * FUNCTION
  1660.  *  GetPicEditCurrentImageName
  1661.  * DESCRIPTION
  1662.  *  Gets the image name for image selected
  1663.  * PARAMETERS
  1664.  *  void
  1665.  * RETURNS
  1666.  *  void
  1667.  *****************************************************************************/
  1668. U8 *GetPicEditCurrentImageName(void)
  1669. {
  1670.     /*----------------------------------------------------------------*/
  1671.     /* Local Variables                                                */
  1672.     /*----------------------------------------------------------------*/
  1674.     /*----------------------------------------------------------------*/
  1675.     /* Code Body                                                      */
  1676.     /*----------------------------------------------------------------*/
  1677.     return gPicEditorInfo[gPicEditCurrPic].ImageName;
  1678. }
  1681. /*****************************************************************************
  1682.  * FUNCTION
  1683.  *  GetPicEditCurrentImageId
  1684.  * DESCRIPTION
  1685.  *  Gets the image id for image selected
  1686.  * PARAMETERS
  1687.  *  void
  1688.  * RETURNS
  1689.  *  void
  1690.  *****************************************************************************/
  1691. U16 GetPicEditCurrentImageId(void)
  1692. {
  1693.     /*----------------------------------------------------------------*/
  1694.     /* Local Variables                                                */
  1695.     /*----------------------------------------------------------------*/
  1697.     /*----------------------------------------------------------------*/
  1698.     /* Code Body                                                      */
  1699.     /*----------------------------------------------------------------*/
  1700.     return gPicEditorInfo[gPicEditCurrPic].ImagesId;
  1701. }
  1704. /*****************************************************************************
  1705.  * FUNCTION
  1706.  *  SetPicEditPenMarkBoundary
  1707.  * DESCRIPTION
  1708.  *  Sets the mark boundary
  1709.  * PARAMETERS
  1710.  *  void
  1711.  * RETURNS
  1712.  *  void
  1713.  *****************************************************************************/
  1714. extern PicEditMarkBox gPicEditZoomWindow;
  1716. BOOL SetPicEditPenMarkBoundary(void)
  1717. {
  1718.     /*----------------------------------------------------------------*/
  1719.     /* Local Variables                                                */
  1720.     /*----------------------------------------------------------------*/
  1721.     U16 nWidth, nHeight;
  1723.     /*----------------------------------------------------------------*/
  1724.     /* Code Body                                                      */
  1725.     /*----------------------------------------------------------------*/
  1726.     switch (nInlinePEScr)
  1727.     {
  1728.         case PE_SCR_1:
  1729.             nWidth = PE_SCR_SIZE_1;
  1730.             nHeight = PE_SCR_SIZE_1;
  1731.             break;
  1732.         case PE_SCR_2:
  1733.             nWidth = PE_SCR_SIZE_2;
  1734.             nHeight = PE_SCR_SIZE_2;
  1735.             break;
  1736.         case PE_SCR_3:
  1737.             nWidth = PE_SCR_SIZE_MAX;
  1738.             nHeight = PE_SCR_SIZE_MAX;
  1739.             break;
  1740.         case PE_SCR_4:
  1741.             nWidth = gPEImageWidth;
  1742.             nHeight = gPEImageHeight;
  1743.             break;
  1744.         default:
  1745.             nWidth = PE_SCR_SIZE_2;
  1746.             nHeight = PE_SCR_SIZE_2;
  1747.             break;
  1748.     }
  1750.     if (((gpPicEditPen->maxX - gpPicEditPen->minX) >= nWidth) && ((gpPicEditPen->maxY - gpPicEditPen->minY) >= nHeight))
  1751.     {
  1752.         gPicEditZoomWindow.minX = gPicEditMark.minX = gpPicEditPen->penX = gpPicEditPen->minX;
  1753.         gPicEditZoomWindow.minY = gPicEditMark.minY = gpPicEditPen->penY = gpPicEditPen->minY;
  1754.         gPicEditZoomWindow.maxX = gPicEditMark.maxX = gPicEditMark.minX + nWidth;
  1755.         gPicEditZoomWindow.maxY = gPicEditMark.maxY = gPicEditMark.minY + nHeight;
  1757.         return TRUE;
  1758.     }
  1759.     else
  1760.     {
  1761.         return FALSE;
  1762.     }
  1763. }
  1766. /*****************************************************************************
  1767.  * FUNCTION
  1768.  *  GetPicEditScr
  1769.  * DESCRIPTION
  1770.  *  Gets the image size
  1771.  * PARAMETERS
  1772.  *  void
  1773.  * RETURNS
  1774.  *  void
  1775.  *****************************************************************************/
  1776. U8 GetPicEditScr(void)
  1777. {
  1778.     /*----------------------------------------------------------------*/
  1779.     /* Local Variables                                                */
  1780.     /*----------------------------------------------------------------*/
  1782.     /*----------------------------------------------------------------*/
  1783.     /* Code Body                                                      */
  1784.     /*----------------------------------------------------------------*/
  1785.     if ((gPEImageWidth == PE_SCR_SIZE_1) && (gPEImageHeight == PE_SCR_SIZE_1))
  1786.     {
  1787.         return PE_SCR_1;
  1788.     }
  1789.     else if ((gPEImageWidth == PE_SCR_SIZE_2) && (gPEImageHeight == PE_SCR_SIZE_2))
  1790.     {
  1791.         return PE_SCR_2;
  1792.     }
  1793.     else if ((gPEImageWidth == PE_SCR_SIZE_MAX) && (gPEImageHeight == PE_SCR_SIZE_MAX))
  1794.     {
  1795.         return PE_SCR_3;
  1796.     }
  1797.     else
  1798.     {
  1799.         return PE_SCR_4;
  1800.     }
  1801. }
  1804. /*****************************************************************************
  1805.  * FUNCTION
  1806.  *  CheckPicEditPenSettingChange
  1807.  * DESCRIPTION
  1808.  *  Checks if pen setting changed
  1809.  * PARAMETERS
  1810.  *  void
  1811.  * RETURNS
  1812.  *  void
  1813.  *****************************************************************************/
  1814. BOOL CheckPicEditPenSettingChange(void)
  1815. {
  1816.     /*----------------------------------------------------------------*/
  1817.     /* Local Variables                                                */
  1818.     /*----------------------------------------------------------------*/
  1819.     U8 penPixel;
  1821. #ifndef __MMI_TOUCH_SCREEN__
  1822.     U8 penMove;
  1823. #endif 
  1825.     /*----------------------------------------------------------------*/
  1826.     /* Code Body                                                      */
  1827.     /*----------------------------------------------------------------*/
  1828.     if (nInlinePenColorIndex != gpPicEditPen->penColorIndex - 1)
  1829.     {
  1830.         return TRUE;
  1831.     }
  1833.     switch (nInlinePenSize)
  1834.     {
  1835.         case 0:
  1836.             penPixel = PIC_EDIT_PEN_PIXEL_1;
  1837.             break;
  1838.         case 1:
  1839.             penPixel = PIC_EDIT_PEN_PIXEL_2;
  1840.             break;
  1841.         case 2:
  1842.             penPixel = PIC_EDIT_PEN_PIXEL_3;
  1843.             break;
  1844.         case 3:
  1845.             penPixel = PIC_EDIT_PEN_PIXEL_4;
  1846.             break;
  1847.         default:
  1848.             penPixel = PIC_EDIT_PEN_PIXEL_1;
  1849.             break;
  1850.     }
  1851. #ifndef __MMI_TOUCH_SCREEN__    /* PMT MANISH   20050616 */
  1852.     switch (nInlinePenMoveFactor)
  1853.     {
  1854.         case 0:
  1855.             penMove = PIC_EDIT_PEN_MOVE_1;
  1856.             break;
  1857.         case 1:
  1858.             penMove = PIC_EDIT_PEN_MOVE_2;
  1859.             break;
  1860.         case 2:
  1861.             penMove = PIC_EDIT_PEN_MOVE_3;
  1862.             break;
  1863.         case 3:
  1864.             penMove = PIC_EDIT_PEN_MOVE_4;
  1865.             break;
  1866.         default:
  1867.             penMove = PIC_EDIT_PEN_MOVE_1;
  1868.             break;
  1869.     }
  1870. #endif /* __MMI_TOUCH_SCREEN__ */ 
  1871.     if (gpPicEditPen->penPixel != penPixel)
  1872.     {
  1873.         return TRUE;
  1874.     }
  1875. #ifndef __MMI_TOUCH_SCREEN__
  1876.     if (gpPicEditPen->penMove != penMove)
  1877.     {
  1878.         return TRUE;
  1879.     }
  1880. #endif /* __MMI_TOUCH_SCREEN__ */ 
  1881.     return FALSE;
  1882. }
  1885. /*****************************************************************************
  1886.  * FUNCTION
  1887.  *  ReadPicEditListFromNVRAM
  1888.  * DESCRIPTION
  1889.  *  Reads image names present from NVRAM
  1890.  * PARAMETERS
  1891.  *  void
  1892.  * RETURNS
  1893.  *  void
  1894.  *****************************************************************************/
  1895. void ReadPicEditListFromNVRAM(void)
  1896. {
  1897.     /*----------------------------------------------------------------*/
  1898.     /* Local Variables                                                */
  1899.     /*----------------------------------------------------------------*/
  1900.     S16 error = 0;
  1901.     int nCount;
  1903.     /*----------------------------------------------------------------*/
  1904.     /* Code Body                                                      */
  1905.     /*----------------------------------------------------------------*/
  1906.     PRINT_INFORMATION(("Reading Picture List from NVRAM"));
  1908.     gPEImageCount = 0;
  1910.     if (ReadRecord(NVRAM_PICTURE_EDITOR_LID, (U16) (1), (void*)&gPicEditorInfo, NVRAM_PICTURE_EDITOR_SIZE, &error) < 0)
  1911.     {
  1912.         PRINT_INFORMATION(("PICTURE EDITOR : ReadRecord failed (ecode %d)", (int)error));
  1913.         memset(&gPicEditorInfo, '', NVRAM_PICTURE_EDITOR_SIZE);
  1914.         WriteRecord(NVRAM_PICTURE_EDITOR_LID, (U16) (1), (void*)&gPicEditorInfo, NVRAM_PICTURE_EDITOR_SIZE, &error);
  1915.     }
  1916.     for (nCount = 0; nCount < MAXIMUM_PICTURE_EDITOR_IMAGES; nCount++)
  1917.         if (gPicEditorInfo[nCount].ImagesId)
  1918.         {
  1919.             gPEImageCount++;
  1920.         }
  1921. }
  1924. /*****************************************************************************
  1925.  * FUNCTION
  1926.  *  WritePicEditListToNVRAM
  1927.  * DESCRIPTION
  1928.  *  Writes the image names in NVRAM
  1929.  * PARAMETERS
  1930.  *  void
  1931.  * RETURNS
  1932.  *  void
  1933.  *****************************************************************************/
  1934. void WritePicEditListToNVRAM(void)
  1935. {
  1936.     /*----------------------------------------------------------------*/
  1937.     /* Local Variables                                                */
  1938.     /*----------------------------------------------------------------*/
  1939.     S16 error = 0;
  1941.     /*----------------------------------------------------------------*/
  1942.     /* Code Body                                                      */
  1943.     /*----------------------------------------------------------------*/
  1944.     PRINT_INFORMATION(("Picture Name List To Write Record NVRAM"));
  1946.     if (WriteRecord(
  1947.             NVRAM_PICTURE_EDITOR_LID,
  1948.             (U16) (1),
  1949.             (void*)&gPicEditorInfo,
  1950.             NVRAM_PICTURE_EDITOR_SIZE,
  1951.             &error) != NVRAM_PICTURE_EDITOR_SIZE)
  1952.     {
  1953.         PRINT_INFORMATION(("PICTURE EDITOR : WriteRecord failed (ecode %d)", (int)error));
  1954.     }
  1955. }
  1958. /*****************************************************************************
  1959.  * FUNCTION
  1960.  *  AddPictureEditorImage
  1961.  * DESCRIPTION
  1962.  *  Add image to the image editor pictures
  1963.  * PARAMETERS
  1964.  *  fileName        [IN]        
  1965.  * RETURNS
  1966.  *  void
  1967.  *****************************************************************************/
  1968. S8 AddPictureEditorImage(S8 *fileName)
  1969. {
  1970.     /*----------------------------------------------------------------*/
  1971.     /* Local Variables                                                */
  1972.     /*----------------------------------------------------------------*/
  1973.     U16 searchId, jCount, nIndex = 0;
  1974.     BOOL bFound = FALSE;
  1976.     /*----------------------------------------------------------------*/
  1977.     /* Code Body                                                      */
  1978.     /*----------------------------------------------------------------*/
  1979.     if ((gPEImageCount) == MAXIMUM_PICTURE_EDITOR_IMAGES)
  1980.     {
  1981.         return 0;
  1982.     }
  1984.     for (jCount = 0; jCount < MAXIMUM_PICTURE_EDITOR_IMAGES; jCount++)
  1985.     {
  1986.         if (!
  1987.             ((gPicEditorInfo[jCount].ImagesId >= (U16) PICTURE_EDITOR_IMAGE_BASE) &&
  1988.              (gPicEditorInfo[jCount].ImagesId <= PICTURE_EDITOR_IMAGE_BASE_END)))
  1989.         {
  1990.             nIndex = jCount;
  1991.             break;
  1992.         }
  1993.     }
  1994.     if (!nIndex)
  1995.     {
  1996.         return 0;
  1997.     }
  1999.     for (searchId = (U16) PICTURE_EDITOR_IMAGE_BASE; searchId <= PICTURE_EDITOR_IMAGE_BASE_END; searchId++)
  2000.     {
  2001.         bFound = FALSE;
  2002.         for (jCount = 0; jCount < MAXIMUM_PICTURE_EDITOR_IMAGES; jCount++)
  2003.         {
  2004.             if (gPicEditorInfo[jCount].ImagesId == searchId)
  2005.             {
  2006.                 bFound = TRUE;
  2007.                 break;
  2008.             }
  2009.         }
  2010.         if (bFound == FALSE)
  2011.         {
  2012.             break;
  2013.         }
  2014.     }
  2016.     gPicEditorInfo[nIndex].ImagesId = searchId;
  2017.     memset((S8*) gPicEditorInfo[nIndex].ImageName, '', sizeof(U8) * MAX_IMAGE_NAME_WIDTH);
  2018.     pfnUnicodeStrcpy((S8*) gPicEditorInfo[nIndex].ImageName, fileName);
  2019.     gPEImageCount++;
  2020.     return 1;
  2021. }
  2024. /*****************************************************************************
  2025.  * FUNCTION
  2026.  *  AddPictureEditorImageAtIndex
  2027.  * DESCRIPTION
  2028.  *  Add image to the image editor pictures
  2029.  * PARAMETERS
  2030.  *  fileName        [IN]        
  2031.  *  nIndex          [IN]        
  2032.  * RETURNS
  2033.  *  void
  2034.  *****************************************************************************/
  2035. S8 AddPictureEditorImageAtIndex(S8 *fileName, U8 nIndex)
  2036. {
  2037.     /*----------------------------------------------------------------*/
  2038.     /* Local Variables                                                */
  2039.     /*----------------------------------------------------------------*/
  2040.     U16 searchId, jCount;
  2041.     BOOL bFound = FALSE;
  2043.     /*----------------------------------------------------------------*/
  2044.     /* Code Body                                                      */
  2045.     /*----------------------------------------------------------------*/
  2046.     if (!
  2047.         ((gPicEditorInfo[nIndex].ImagesId >= (U16) PICTURE_EDITOR_IMAGE_BASE) &&
  2048.          (gPicEditorInfo[nIndex].ImagesId <= PICTURE_EDITOR_IMAGE_BASE_END)))
  2049.     {
  2050.         if ((gPEImageCount) == MAXIMUM_PICTURE_EDITOR_IMAGES)
  2051.         {
  2052.             return 0;
  2053.         }
  2054.         for (searchId = (U16) PICTURE_EDITOR_IMAGE_BASE; searchId <= PICTURE_EDITOR_IMAGE_BASE_END; searchId++)
  2055.         {
  2056.             bFound = FALSE;
  2057.             for (jCount = 0; jCount < MAXIMUM_PICTURE_EDITOR_IMAGES; jCount++)
  2058.             {
  2059.                 if (gPicEditorInfo[jCount].ImagesId == searchId)
  2060.                 {
  2061.                     bFound = TRUE;
  2062.                     break;
  2063.                 }
  2064.             }
  2065.             if (bFound == FALSE)
  2066.             {
  2067.                 break;
  2068.             }
  2069.         }
  2070.         gPicEditorInfo[nIndex].ImagesId = searchId;
  2071.         gPEImageCount++;
  2072.     }
  2073.     memset((S8*) gPicEditorInfo[nIndex].ImageName, '', sizeof(U8) * MAX_IMAGE_NAME_WIDTH);
  2074.     pfnUnicodeStrcpy((S8*) gPicEditorInfo[nIndex].ImageName, fileName);
  2075.     return 1;
  2076. }
  2079. /*****************************************************************************
  2080.  * FUNCTION
  2081.  *  DeletePictureEditorImage
  2082.  * DESCRIPTION
  2083.  *  Deletes Image from image editor images
  2084.  *  
  2085.  *  Returns FALSE if fail else TRUE
  2086.  * PARAMETERS
  2087.  *  ImageId     [IN]        
  2088.  * RETURNS
  2089.  *  S8
  2090.  *****************************************************************************/
  2091. S8 DeletePictureEditorImage(U16 ImageId)
  2092. {
  2093.     /*----------------------------------------------------------------*/
  2094.     /* Local Variables                                                */
  2095.     /*----------------------------------------------------------------*/
  2096.     /* U8 iCount,jCount; */
  2097.     U8 iCount;
  2099.     /*----------------------------------------------------------------*/
  2100.     /* Code Body                                                      */
  2101.     /*----------------------------------------------------------------*/
  2102.     /* for(iCount=0;iCount<gPEImageCount;iCount++) */
  2103.     for (iCount = 0; iCount < MAXIMUM_PICTURE_EDITOR_IMAGES; iCount++)
  2104.     {
  2105.         if (gPicEditorInfo[iCount].ImagesId == ImageId)
  2106.         {
  2107.             break;
  2108.         }
  2109.     }
  2110.     /* if(iCount==gPEImageCount) return 0; */
  2111.     if (iCount == MAXIMUM_PICTURE_EDITOR_IMAGES)
  2112.     {
  2113.         return 0;
  2114.     }
  2115.     //      for(jCount=iCount;jCount<gPEImageCount-1;jCount++)
  2116.     //              memcpy(&gPicEditorInfo[jCount],&gPicEditorInfo[jCount+1],sizeof(DYNIMAGEINFO));
  2117.     //      gPEImageCount--;
  2118.     //      memset(&gPicEditorInfo[gPEImageCount],0,sizeof(DYNIMAGEINFO));
  2119.     memset(&gPicEditorInfo[iCount], 0, sizeof(DYNIMAGEINFO));
  2120.     gPEImageCount--;
  2121.     return 1;
  2122. }
  2125. /*****************************************************************************
  2126.  * FUNCTION
  2127.  *  GetPictureEditorImageInfo
  2128.  * DESCRIPTION
  2129.  *  Gets Image editor Info (Common function)
  2130.  *  
  2131.  *  Return image count
  2132.  * PARAMETERS
  2133.  *  pictureEditorInfo       [IN]        
  2134.  * RETURNS
  2135.  *  U8
  2136.  *****************************************************************************/
  2137. U8 GetPictureEditorImageInfo(DYNIMAGEINFO **pictureEditorInfo)
  2138. {
  2139.     /*----------------------------------------------------------------*/
  2140.     /* Local Variables                                                */
  2141.     /*----------------------------------------------------------------*/
  2143.     /*----------------------------------------------------------------*/
  2144.     /* Code Body                                                      */
  2145.     /*----------------------------------------------------------------*/
  2146.     *pictureEditorInfo = gPicEditorInfo;
  2147.     return gPEImageCount;
  2148. }
  2151. /*****************************************************************************
  2152.  * FUNCTION
  2153.  *  GetPictureEditorImageNameInFileSystem
  2154.  * DESCRIPTION
  2155.  *  Gets image name of the image by image id input
  2156.  *  
  2157.  *  Returns NULL if not found else pointer to the image name
  2158.  * PARAMETERS
  2159.  *  ImageId     [IN]        
  2160.  * RETURNS
  2161.  *  S8*
  2162.  *****************************************************************************/
  2163. S8 *GetPictureEditorImageNameInFileSystem(U16 ImageId)
  2164. {
  2165.     /*----------------------------------------------------------------*/
  2166.     /* Local Variables                                                */
  2167.     /*----------------------------------------------------------------*/
  2168.     int nCount = 0;
  2170.     /*----------------------------------------------------------------*/
  2171.     /* Code Body                                                      */
  2172.     /*----------------------------------------------------------------*/
  2173.     if (ImageId >= PICTURE_EDITOR_IMAGE_BASE && ImageId <= PICTURE_EDITOR_IMAGE_BASE_END)
  2174.     {
  2175.         /* for(nCount=0;nCount<gPEImageCount;nCount++) */
  2176.         for (nCount = 0; nCount < MAXIMUM_PICTURE_EDITOR_IMAGES; nCount++)
  2177.         {
  2178.             if (gPicEditorInfo[nCount].ImagesId == ImageId)
  2179.             {
  2180.                 return (S8*) gPicEditorInfo[nCount].ImageName;
  2181.             }
  2182.         }
  2183.     }
  2184.     return NULL;
  2185. }
  2188. /*****************************************************************************
  2189.  * FUNCTION
  2190.  *  GetPictureEditorImageNameWithPathInFileSystem
  2191.  * DESCRIPTION
  2192.  *  Get image name with full path by image id input
  2193.  *  
  2194.  *  returns poiinter to the image name with full path if found else NULL
  2195.  * PARAMETERS
  2196.  *  ImageId     [IN]        
  2197.  * RETURNS
  2198.  *  S8*
  2199.  *****************************************************************************/
  2200. S8 *GetPictureEditorImageNameWithPathInFileSystem(U16 ImageId)
  2201. {
  2202.     /*----------------------------------------------------------------*/
  2203.     /* Local Variables                                                */
  2204.     /*----------------------------------------------------------------*/
  2205.     U8 *fileName = NULL;
  2206.     static S8 imageData[MAX_IMAGE_NAME_PATH_WIDTH + MAX_IMAGE_NAME_WIDTH];
  2208. #ifdef MMI_ON_HARDWARE_P
  2209.     S8 imagePath[100];
  2210. #endif 
  2211.     int nCount = 0;
  2213.     /*----------------------------------------------------------------*/
  2214.     /* Code Body                                                      */
  2215.     /*----------------------------------------------------------------*/
  2216.     if (ImageId >= PICTURE_EDITOR_IMAGE_BASE && ImageId <= PICTURE_EDITOR_IMAGE_BASE_END)
  2217.     {
  2218.         /* for(nCount=0;nCount<gPEImageCount;nCount++) */
  2219.         for (nCount = 0; nCount < MAXIMUM_PICTURE_EDITOR_IMAGES; nCount++)
  2220.         {
  2221.             if (gPicEditorInfo[nCount].ImagesId == ImageId)
  2222.             {
  2223.                 fileName = (U8*) gPicEditorInfo[nCount].ImageName;
  2224.                 break;
  2225.             }
  2226.         }
  2227.         /* if(nCount==gPEImageCount) return NULL; */
  2228.         if (nCount == MAXIMUM_PICTURE_EDITOR_IMAGES)
  2229.         {
  2230.             return NULL;
  2231.         }
  2233.     #ifdef MMI_ON_HARDWARE_P
  2234.         memset(imagePath, 0, sizeof(imagePath));
  2235.         sprintf(imagePath, "%c:\", MMI_PUBLIC_DRV);
  2236.         AnsiiToUnicodeString(imageData, imagePath);
  2237.         pfnUnicodeStrcat((S8*) imageData, (S8*) FMGR_DEFAULT_FOLDER_IMAGES);
  2238.     #else /* MMI_ON_HARDWARE_P */ 
  2240.     #ifdef __ASCII
  2241.         pfnUnicodeStrcpy((PS8) imageData, PICTURE_EDITOR_PATH);
  2242.     #else 
  2243.         AnsiiToUnicodeString((PS8) imageData, PICTURE_EDITOR_PATH);
  2244.     #endif 
  2245.     #endif /* MMI_ON_HARDWARE_P */ 
  2246.         pfnUnicodeStrcat((PS8) imageData, (PS8) fileName);
  2247.         return imageData;
  2248.     }
  2249.     return NULL;
  2250. }
  2252. #endif /* __MMI_PICTURE_EDITOR_SUPPORT__ */