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

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

MTK

开发平台：

C/C++

History.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  36. /*******************************************************************************
  37.  * Filename:
  38.  * ---------
  39.  *  History.c
  40.  *
  41.  * Project:
  42.  * --------
  43.  *  MAUI
  44.  *
  45.  * Description:
  46.  * ------------
  47.  *  
  48.  *
  49.  * Author:
  50.  * -------
  51.  *  
  52.  *
  53.  *==============================================================================
  54.  *             HISTORY
  55.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!! 
  56.  *------------------------------------------------------------------------------
  57.  * removed!
  58.  *
  59.  * removed!
  60.  * removed!
  61.  * removed!
  62.  *
  63.  * removed!
  64.  * removed!
  65.  * removed!
  66.  *
  67.  * removed!
  68.  * removed!
  69.  * removed!
  70.  *
  71.  * removed!
  72.  * removed!
  73.  * removed!
  74.  *
  75.  * removed!
  76.  * removed!
  77.  * removed!
  78.  *
  79.  * removed!
  80.  * removed!
  81.  * removed!
  82.  *
  83.  * removed!
  84.  * removed!
  85.  * removed!
  86.  *
  87.  * removed!
  88.  * removed!
  89.  * removed!
  90.  *
  91.  * removed!
  92.  * removed!
  93.  * removed!
  94.  *
  95.  * removed!
  96.  * removed!
  97.  * removed!
  98.  *
  99.  * removed!
  100.  * removed!
  101.  * removed!
  102.  *
  103.  * removed!
  104.  * removed!
  105.  * removed!
  106.  *
  107.  * removed!
  108.  * removed!
  109.  * removed!
  110.  *
  111.  * removed!
  112.  * removed!
  113.  * removed!
  114.  *
  115.  * removed!
  116.  * removed!
  117.  * removed!
  118.  *
  119.  * removed!
  120.  * removed!
  121.  * removed!
  122.  *
  123.  * removed!
  124.  * removed!
  125.  * removed!
  126.  *
  127.  * removed!
  128.  * removed!
  129.  * removed!
  130.  *
  131.  * removed!
  132.  * removed!
  133.  * removed!
  134.  *
  135.  * removed!
  136.  * removed!
  137.  * removed!
  138.  *
  139.  * removed!
  140.  * removed!
  141.  * removed!
  142.  *
  143.  * removed!
  144.  * removed!
  145.  * removed!
  146.  *
  147.  * removed!
  148.  * removed!
  149.  * removed!
  150.  *
  151.  * removed!
  152.  * removed!
  153.  * removed!
  154.  *
  155.  * removed!
  156.  * removed!
  157.  * removed!
  158.  *
  159.  * removed!
  160.  * removed!
  161.  * removed!
  162.  *
  163.  * removed!
  164.  * removed!
  165.  * removed!
  166.  *
  167.  * removed!
  168.  * removed!
  169.  * removed!
  170.  *
  171.  * removed!
  172.  * removed!
  173.  * removed!
  174.  *
  175.  * removed!
  176.  * removed!
  177.  * removed!
  178.  *
  179.  * removed!
  180.  * removed!
  181.  * removed!
  182.  *
  183.  * removed!
  184.  * removed!
  185.  * removed!
  186.  *
  187.  * removed!
  188.  * removed!
  189.  * removed!
  190.  *
  191.  * removed!
  192.  * removed!
  193.  * removed!
  194.  *
  195.  * removed!
  196.  * removed!
  197.  * removed!
  198.  * removed!
  199.  *
  200.  * removed!
  201.  * removed!
  202.  * removed!
  203.  *
  204.  * removed!
  205.  * removed!
  206.  * removed!
  207.  *
  208.  * removed!
  209.  * removed!
  210.  * removed!
  211.  *
  212.  * removed!
  213.  * removed!
  214.  * removed!
  215.  *
  216.  * removed!
  217.  * removed!
  218.  * removed!
  219.  *
  220.  * removed!
  221.  * removed!
  222.  * removed!
  223.  *
  224.  * removed!
  225.  * removed!
  226.  * removed!
  227.  * removed!
  228.  * removed!
  229.  * removed!
  230.  * removed!
  231.  * removed!
  232.  * removed!
  233.  * removed!
  234.  * removed!
  235.  * removed!
  236.  * removed!
  237.  * removed!
  238.  * removed!
  239.  * removed!
  240.  * removed!
  241.  * removed!
  242.  * removed!
  243.  * removed!
  244.  *
  245.  * removed!
  246.  * removed!
  247.  * removed!
  248.  *
  249.  * removed!
  250.  * removed!
  251.  * removed!
  252.  *
  253.  * removed!
  254.  * removed!
  255.  * removed!
  256.  *
  257.  * removed!
  258.  * removed!
  259.  * removed!
  260.  *
  261.  * removed!
  262.  * removed!
  263.  * removed!
  264.  *
  265.  * removed!
  266.  * removed!
  267.  * removed!
  268.  *
  269.  * removed!
  270.  * removed!
  271.  * removed!
  272.  *
  273.  * removed!
  274.  * removed!
  275.  * removed!
  276.  *
  277.  * removed!
  278.  * removed!
  279.  * removed!
  280.  *
  281.  * removed!
  282.  * removed!
  283.  * removed!
  284.  *
  285.  * removed!
  286.  * removed!
  287.  * removed!
  288.  *
  289.  * removed!
  290.  * removed!
  291.  * removed!
  292.  *
  293.  * removed!
  294.  * removed!
  295.  * removed!
  296.  *
  297.  * removed!
  298.  * removed!
  299.  * removed!
  300.  *
  301.  * removed!
  302.  * removed!
  303.  * removed!
  304.  *
  305.  *------------------------------------------------------------------------------
  306.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!! 
  307.  *==============================================================================
  308.  *******************************************************************************/
  310. /**
  311.  * Copyright Notice
  312.  * ?2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  313.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  314.  *  (It is illegal to remove this copyright notice from this software or any
  315.  *  portion of it)
  316.  */
  318. /**************************************************************
  320.    FILENAME : History.c
  322.    PURPOSE     : Implementation of Main LCD history stack
  324.    REMARKS     : nil
  326.    AUTHOR      : Manish
  328.    DATE     : Aug' 28, 2002
  330. **************************************************************/
  332. #include "MMI_features.h"
  333. #include "stdC.h"
  334. #include "L4Dr1.h"
  335. #include "GlobalConstants.h"
  336. #include "DebugInitDef.h"
  337. #include "PixtelDataTypes.h"
  338. #include "FrameworkStruct.h"
  339. #include "CustMenuRes.h"
  340. #include "OslMemory.h"
  341. #include "EventsGprot.h"
  343. #include "HistoryGprot.h"
  344. #include "HistoryDef.h"
  345. #include "HistoryDcl.h"
  346. #include "SubLCDHistoryGprot.h"
  347. #include "Unicodexdcl.h"
  348. #include "PixtelDataTypes.h"
  349. #include "l4dr.h"
  350. #include "MMI_trc.h"
  351. #include "gdi_include.h"        /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */
  352. #include "wgui_categories_util.h"       /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */
  353. #include "ProfilingEngine.h"
  357. typedef enum
  358. {
  359.     MMI_HIST_SMALLSCREEN_NONE,
  360.     MMI_HIST_SMALLSCREEN_ACTIVE,
  361.     MMI_HIST_SMALLSCREEN_ACTIVE_IN_EXIT_FUNC,
  362.     
  363.     /* add the enum value above here */
  364.     MMI_HIST_SMALLSCREEN_END
  365. }mmi_hist_smallscreen_state_enum;
  368. /* 
  369.  *   Extern Varibales 
  370.  */
  371. pBOOL IsBackHistory = FALSE;
  373. /* 
  374.  *   Local Variables 
  375.  */
  376. static pBOOL CheckMainLCDHistoryBack = FALSE;
  377. static historyCallback historyCBHandler[MAX_HISTORY];
  378. static historyNode historyData[MAX_HISTORY];    /* array of history data */
  379. static S16 currHistoryIndex = -1;
  380. static pBOOL bRoundOffFlag = 0;
  381. static MMI_BOOL bBackHistoryFlag = MMI_FALSE;
  383. /* static U8 is_del_cb_found = MMI_FALSE; // gilbert --- for modifying decrement() */
  385. /* 
  386.  *   Extern Function 
  387.  */
  389. /* 
  390.  *   Local Functions 
  391.  */
  392. static void ExecutePopHistory(void);
  393. static U8 SearchDelScrnIDCallbackHandler(U16 ScrnID, U16 *found_idx);
  394. static U8 ExecTopScrnCallbackHandler(void);
  395. static U8 ExecHistoryScrnCallBackHandle(U16 HistoryIndex);
  397. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  398. static S32 small_history_node = 0;
  400. /* static S32 check_for_small_history_node=0; */
  401. static mmi_hist_smallscreen_state_enum redrawing_old_screens = 0;
  403. S32 no_small_screen = 0;
  404. S32 small_screen_enabled = 0;
  406. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  408. #ifdef __MMI_UI_TAB_PANE__
  409. S32 disable_history_save = 0;
  410. #endif 
  413. /*****************************************************************************
  414.  * FUNCTION
  415.  *  mmi_free_history_buffer
  416.  * DESCRIPTION
  417.  *  Free history GUI buffer and Input buffer
  418.  *  
  419.  * PARAMETERS
  420.  *  id                [IN]        
  421.  * RETURNS
  422.  *  void
  423.  *****************************************************************************/
  424. void mmi_free_history_buffer(S16 id)
  425. {
  426.     if ((id >= 0) && (id <= currHistoryIndex))
  427.     {
  428.         if (historyData[id].guiBuffer)
  429.         {
  430.             OslMfree(historyData[id].guiBuffer);
  431.             historyData[id].guiBuffer = NULL;
  432.         }
  433.         if (historyData[id].inputBuffer)
  434.         {
  435.             if (historyData[id].mfreeFuncPtr)
  436.             {
  437.                 historyData[id].mfreeFuncPtr(historyData[id].inputBuffer);
  438.             }
  439.             else
  440.             {
  441.                 OslMfree(historyData[id].inputBuffer);
  442.             }
  443.             historyData[id].inputBuffer = NULL;
  444.         }
  445.     }
  446. }
  450. /*****************************************************************************
  451.  * FUNCTION
  452.  *  increment
  453.  * DESCRIPTION
  454.  *  increment the global currHistoryIndex
  455.  *  
  456.  *  increment the global currHistoryIndex
  457.  * PARAMETERS
  458.  *  void
  459.  * RETURNS
  460.  *  S16 - Current history index
  461.  *****************************************************************************/
  462. S16 increment()
  463. {
  465.     /*----------------------------------------------------------------*/
  466.     /* Local Variables                                                */
  467.     /*----------------------------------------------------------------*/
  469.     /*----------------------------------------------------------------*/
  470.     /* Code Body                                                      */
  471.     /*----------------------------------------------------------------*/
  472.     if (currHistoryIndex < MAX_HISTORY - 1)
  473.     {
  474.         ++currHistoryIndex;
  475.     }
  476.     else
  477.     {
  478.         currHistoryIndex = MIN_HISTORY + 1;
  479.         bRoundOffFlag = 1;
  480.     }
  482.     return currHistoryIndex;
  483. }
  486. /*****************************************************************************
  487.  * FUNCTION
  488.  *  decrement
  489.  * DESCRIPTION
  490.  *  decrement the global currHistoryIndex
  491.  *  
  492.  *  decrement the global currHistoryIndex
  493.  * PARAMETERS
  494.  *  void
  495.  * RETURNS
  496.  *  S16 - current history index
  497.  *****************************************************************************/
  498. static U8 decrement(void)
  499. {
  500.     /*----------------------------------------------------------------*/
  501.     /* Local Variables                                                */
  502.     /*----------------------------------------------------------------*/
  503.     U8 is_stop_delete = MMI_HIST_ALLOW_DELETING;  /* JL, if want to stop to run next decrement will return true. */
  504.     static U16 cb_history_idx = 0;
  506.     /*----------------------------------------------------------------*/
  507.     /* Code Body                                                      */
  508.     /*----------------------------------------------------------------*/
  509.     /* found the callback history screen */
  510. #if 0
  511. /* under construction !*/
  512. /* under construction !*/
  513. /* under construction !*/
  514. /* under construction !*/
  515. /* under construction !*/
  516. /* under construction !*/
  517. /* under construction !*/
  518. /* under construction !*/
  519. /* under construction !*/
  520. /* under construction !*/
  521. /* under construction !*/
  522. /* under construction !*/
  523. /* under construction !*/
  524. /* under construction !*/
  525. /* under construction !*/
  526. #endif /* 0 */ 
  527.     {
  528.         /* is_del_cb_found = SearchDelScrnIDCallbackHandler(historyData[currHistoryIndex].scrnID, &cb_history_idx); */
  529.         if (!bBackHistoryFlag)
  530.         {
  531.             if (SearchDelScrnIDCallbackHandler(historyData[currHistoryIndex].scrnID, &cb_history_idx))
  532.             {
  533.                 if (historyCBHandler[cb_history_idx].historydelCBPtr)
  534.                 {
  535.                     is_stop_delete = historyCBHandler[cb_history_idx].historydelCBPtr((void*)MMI_HIST_DELETE_SCREEN_TYPE);
  536.                     if (is_stop_delete == MMI_HIST_STOP_DELETING)
  537.                     {
  538.                         return MMI_HIST_STOP_DELETING;
  539.                     }
  540.                     ClearDelScrnIDCallbackHandler(historyCBHandler[cb_history_idx].scrnID, NULL);
  541.                 }
  542.             }
  543.         }
  544.     }
  546.     mmi_free_history_buffer(currHistoryIndex);
  547.     memset(&historyData[currHistoryIndex], 0, sizeof(historyNode));
  548.     if ((currHistoryIndex > MIN_HISTORY + 1) && (currHistoryIndex < MAX_HISTORY))
  549.     {
  550.         --currHistoryIndex;
  551.     }
  552.     else if ((currHistoryIndex == 1) && (bRoundOffFlag == 0))
  553.     {
  554.         currHistoryIndex = 0;
  556.     }
  557.     else if (currHistoryIndex == 0)
  558.     {
  559.         currHistoryIndex = -1;
  560.         bRoundOffFlag = 0;
  561.     }
  562.     else if (bRoundOffFlag)
  563.     {
  564.         currHistoryIndex = MAX_HISTORY - 1;
  565.         bRoundOffFlag = 0;
  566.     }
  568.     return is_stop_delete;
  569. }
  571. #ifdef OSL_MEMORY_DUMP
  574. /*****************************************************************************
  575.  * FUNCTION
  576.  *  AddHistoryReferenceMemoryRecord
  577.  * DESCRIPTION
  578.  *  adds a history along with memory record
  579.  *  
  580.  *  This is used to add a history
  581.  * PARAMETERS
  582.  *  addHistory      [IN]        
  583.  *  fileName        [IN]        
  584.  *  lineNumber      [IN]        
  585.  * RETURNS
  586.  *  void
  587.  *****************************************************************************/
  588. void AddHistoryReferenceMemoryRecord(history *addHistory, char *fileName, int lineNumber)
  589. {
  590.     /*----------------------------------------------------------------*/
  591.     /* Local Variables                                                */
  592.     /*----------------------------------------------------------------*/
  593.     S32 length = 0;
  595.     /*----------------------------------------------------------------*/
  596.     /* Code Body                                                      */
  597.     /*----------------------------------------------------------------*/
  598. #ifdef __MMI_UI_TAB_PANE__
  599.     if (disable_history_save)
  600.     {
  601.         return;
  602.     }
  603. #endif /* __MMI_UI_TAB_PANE__ */ 
  605. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  606.     if (redraw_in_small_screen_proceduer())
  607.     {
  608.         small_history_node = 0;
  609.         return;
  610.     }
  611. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  613.     /* 1. Check for OK pressed or BACK pressed */
  615.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_ADD_HISTREFMEMREC_HDLR, (IsBackHistory != MMI_TRUE)));
  617.     if (IsBackHistory != MMI_TRUE)
  618.     {
  620.         increment();
  621.         /* 3. Store History to History Data Structure */
  622.         memset(&historyData[currHistoryIndex], 0, sizeof(historyNode));
  623.         historyData[currHistoryIndex].scrnID = addHistory->scrnID;
  624.         historyData[currHistoryIndex].entryFuncPtr = addHistory->entryFuncPtr;
  625.     #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  626.         historyData[currHistoryIndex].isSmallScreen = (U16) small_history_node;
  627.     #endif 
  628.         length = pfnUnicodeStrlen((PS8) addHistory->inputBuffer);
  629.         MMI_ASSERT(length * ENCODING_LENGTH + ENCODING_LENGTH <= MAX_INPUT_BUFFER);
  630.         if (length)
  631.         {
  632.             historyData[currHistoryIndex].inputBuffer = OslMallocCHK(length * ENCODING_LENGTH + ENCODING_LENGTH, fileName, lineNumber);
  633.             pfnUnicodeStrcpy((PS8) historyData[currHistoryIndex].inputBuffer, (PS8) addHistory->inputBuffer);
  634.         }
  635.         historyData[currHistoryIndex].guiBuffer = OslMallocCHK(MAX_GUI_BUFFER, fileName, lineNumber);
  636.         memcpy(historyData[currHistoryIndex].guiBuffer, addHistory->guiBuffer, MAX_GUI_BUFFER);
  637.     }
  638. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  639.     small_history_node = 0;
  640. #endif 
  641.     IsBackHistory = MMI_FALSE;
  642. }
  644. #else /* OSL_MEMORY_DUMP */ 
  647. /*****************************************************************************
  648.  * FUNCTION
  649.  *  AddHistoryReference
  650.  * DESCRIPTION
  651.  *  adds a history
  652.  *  
  653.  *  This is used to add a history
  654.  * PARAMETERS
  655.  *  addHistory      [IN]        
  656.  * RETURNS
  657.  *  void
  658.  *****************************************************************************/
  659. void AddHistoryReference(history *addHistory)
  660. {
  661.     /*----------------------------------------------------------------*/
  662.     /* Local Variables                                                */
  663.     /*----------------------------------------------------------------*/
  664.     S32 length = 0;
  666.     /*----------------------------------------------------------------*/
  667.     /* Code Body                                                      */
  668.     /*----------------------------------------------------------------*/
  669. #ifdef __MMI_UI_TAB_PANE__
  670.     if (disable_history_save)
  671.     {
  672.         return;
  673.     }
  674. #endif /* __MMI_UI_TAB_PANE__ */ 
  676. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  677.     if (redraw_in_small_screen_proceduer())
  678.     {
  679.         small_history_node = 0;
  680.         return;
  681.     }
  682. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  684.     /* 1. Check for OK pressed or BACK pressed */
  686.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_ADD_HISTREF_HDLR, (IsBackHistory != MMI_TRUE)));
  688.     if (IsBackHistory != MMI_TRUE)
  689.     {
  691.         increment();
  692.         /* 3. Store History to History Data Structure */
  693.         memset(&historyData[currHistoryIndex], 0, sizeof(historyNode));
  694.         historyData[currHistoryIndex].scrnID = addHistory->scrnID;
  695.         historyData[currHistoryIndex].entryFuncPtr = addHistory->entryFuncPtr;
  696.     #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  697.         historyData[currHistoryIndex].isSmallScreen = (U16) small_history_node;
  698.     #endif 
  699.         length = pfnUnicodeStrlen((PS8) addHistory->inputBuffer);
  700.         MMI_ASSERT(length * ENCODING_LENGTH + ENCODING_LENGTH <= MAX_INPUT_BUFFER);
  701.         if (length)
  702.         {
  703.             historyData[currHistoryIndex].inputBuffer = OslMalloc(length * ENCODING_LENGTH + ENCODING_LENGTH);
  704.             pfnUnicodeStrcpy((PS8) historyData[currHistoryIndex].inputBuffer, (PS8) addHistory->inputBuffer);
  705.         }
  706.         historyData[currHistoryIndex].guiBuffer = OslMalloc(MAX_GUI_BUFFER);
  707.         memcpy(historyData[currHistoryIndex].guiBuffer, addHistory->guiBuffer, MAX_GUI_BUFFER);
  708.     }
  709. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  710.     small_history_node = 0;
  711. #endif 
  712.     IsBackHistory = MMI_FALSE;
  713. }
  715. #endif /* OSL_MEMORY_DUMP */ 
  718. /*****************************************************************************
  719.  * FUNCTION
  720.  *  AddNHistory_ext
  721.  * DESCRIPTION
  722.  *  adds a history with user specified size
  723.  *  
  724.  *  This is used to add a history where user specifies the size
  725.  * PARAMETERS
  726.  *  addHistory      [IN]        
  727.  *  size            [IN]        
  728.  * RETURNS
  729.  *  void
  730.  *****************************************************************************/
  731. /* MTK Leo add 0511, to reduce stack size */
  732. void AddNHistory_ext(history *addHistory, U16 size)
  733. /* MTK Leo end 0511 */
  734. {
  735.     /*----------------------------------------------------------------*/
  736.     /* Local Variables                                                */
  737.     /*----------------------------------------------------------------*/
  739.     /*----------------------------------------------------------------*/
  740.     /* Code Body                                                      */
  741.     /*----------------------------------------------------------------*/
  742. #ifdef __MMI_UI_TAB_PANE__
  743.     if (disable_history_save)
  744.     {
  745.         return;
  746.     }
  747. #endif /* __MMI_UI_TAB_PANE__ */ 
  749. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  750.     if (redraw_in_small_screen_proceduer())
  751.     {
  752.         small_history_node = 0;
  753.         return;
  754.     }
  755. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  757.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_ADD_NHIST_HDLR, size, (IsBackHistory != MMI_TRUE)));
  758.     /* 1. Check for OK pressed or BACK pressed */
  760.     if (IsBackHistory != MMI_TRUE)
  761.     {
  763.         increment();
  764.         /* 3. Store History to History Data Structure */
  765.         memset(&historyData[currHistoryIndex], 0, sizeof(historyNode));
  766.         historyData[currHistoryIndex].scrnID = addHistory->scrnID;
  767.         historyData[currHistoryIndex].entryFuncPtr = addHistory->entryFuncPtr;
  769.         /* PMT START MAUI_00157013_AND_MAUI_00157021 PATCH */
  770.     #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  771.         historyData[currHistoryIndex].isSmallScreen = (U16) small_history_node;
  772.     #endif 
  774.         MMI_ASSERT(size + ENCODING_LENGTH + 2 <= MAX_INPUT_BUFFER);
  775.         historyData[currHistoryIndex].inputBuffer = OslMalloc(size + ENCODING_LENGTH + 2);
  776.         memcpy(historyData[currHistoryIndex].inputBuffer, &size, 2);
  777.         memcpy((PS8) (historyData[currHistoryIndex].inputBuffer + 2), (PS8) addHistory->inputBuffer, (U32) size);
  779.         historyData[currHistoryIndex].guiBuffer = OslMalloc(MAX_GUI_BUFFER);
  780.         memcpy(historyData[currHistoryIndex].guiBuffer, addHistory->guiBuffer, MAX_GUI_BUFFER);
  781.     }
  782. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  783.     small_history_node = 0;
  784. #endif 
  785.     IsBackHistory = MMI_FALSE;
  787. }
  790. /*****************************************************************************
  791.  * FUNCTION
  792.  *  AddHistoryEx
  793.  * DESCRIPTION
  794.  *  adds a history with 
  795.  *  
  796.  *  The applications could assign the related function pointer
  797.  *  and let the MMI framework to get history data
  798.  * PARAMETERS
  799.  *  addHistory      [IN]        
  800.  *  size            [IN]        
  801.  * RETURNS
  802.  *  void
  803.  *****************************************************************************/
  804. MMI_BOOL AddHistoryEx(
  805.             U16 scrnID,                             /* the screen id */
  806.             FuncPtr entryFuncPtr,                   /* the screenˇs entry function */
  807.             HistoryGetData getGuiFuncPtr,           /* the function to get GUI data */
  808.             HistoryGetSize getInputBufSizeFuncPtr,  /* the function to get input buffer size */
  809.             HistoryGetData getInputBufFuncPtr,      /* the function to get input buffer */
  810.             MemAlloc mallocFuncPtr,                 /* the function to allocate memory */
  811.             MemFree mfreeFuncPtr)                  /* the function to free memory */
  812. {
  813.     /*----------------------------------------------------------------*/
  814.     /* Local Variables                                                */
  815.     /*----------------------------------------------------------------*/
  816.     S16 inputBuf_size;
  817.     /*----------------------------------------------------------------*/
  818.     /* Code Body                                                      */
  819.     /*----------------------------------------------------------------*/
  820. #ifdef __MMI_UI_TAB_PANE__
  821.     if (disable_history_save)
  822.     {
  823.         return MMI_TRUE;
  824.     }
  825. #endif /* __MMI_UI_TAB_PANE__ */ 
  827. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  828.     if (redraw_in_small_screen_proceduer())
  829.     {
  830.         small_history_node = 0;
  831.         return MMI_TRUE;
  832.     }
  833. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  835.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_ADD_HIST_EX_HDLR, (IsBackHistory != MMI_TRUE)));
  836.     /* Check for OK pressed or BACK pressed */
  837.     if (IsBackHistory != MMI_TRUE)
  838.     {
  839.         increment();
  840.         /* Store History to History Data Structure */
  841.         memset(&historyData[currHistoryIndex], 0, sizeof(historyNode));
  842.         historyData[currHistoryIndex].scrnID = scrnID;
  843.         historyData[currHistoryIndex].entryFuncPtr = entryFuncPtr;
  845.     #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  846.         historyData[currHistoryIndex].isSmallScreen = (U16) small_history_node;
  847.     #endif
  848.         MMI_ASSERT(getGuiFuncPtr);
  849.         historyData[currHistoryIndex].guiBuffer = OslMalloc(MAX_GUI_BUFFER);
  850.         getGuiFuncPtr(historyData[currHistoryIndex].guiBuffer);
  852.         historyData[currHistoryIndex].mallcFuncPtr = mallocFuncPtr;
  853.         historyData[currHistoryIndex].mfreeFuncPtr = mfreeFuncPtr;
  854.         if (getInputBufSizeFuncPtr)
  855.         {
  856.             MMI_ASSERT(getInputBufFuncPtr);
  857.             inputBuf_size = (S16)getInputBufSizeFuncPtr();
  858.             if(mallocFuncPtr)
  859.             {
  860.                 /* Check memory free function pointer is valid */
  861.                 MMI_ASSERT(mfreeFuncPtr);
  862.                 historyData[currHistoryIndex].inputBuffer = (U8*)mallocFuncPtr(inputBuf_size + ENCODING_LENGTH + 2);
  863.             }
  864.             else
  865.             {
  866.                 historyData[currHistoryIndex].inputBuffer = OslMalloc(inputBuf_size + ENCODING_LENGTH + 2);
  867.             }
  868.             memcpy(historyData[currHistoryIndex].inputBuffer, &inputBuf_size, 2);
  869.             getInputBufFuncPtr(historyData[currHistoryIndex].inputBuffer + 2);
  870.         }
  871.     }
  872. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  873.     small_history_node = 0;
  874. #endif 
  875.     IsBackHistory = MMI_FALSE;
  877.     return MMI_TRUE;
  878. }
  881. /*****************************************************************************
  882.  * FUNCTION
  883.  *  GetHistory
  884.  * DESCRIPTION
  885.  *  Used to get the history buffer for a screen id
  886.  * PARAMETERS
  887.  *  scrnID          [IN]        
  888.  *  ptrHistory      [IN]        
  889.  * RETURNS
  890.  *  U8 - Status , success or failure
  891.  *****************************************************************************/
  892. U8 GetHistory(U16 scrnID, history *ptrHistory)
  893. {
  894.     /*----------------------------------------------------------------*/
  895.     /* Local Variables                                                */
  896.     /*----------------------------------------------------------------*/
  897.     S16 count = 0;
  898.     U8 Status = ST_FAILURE;
  899.     U16 nSize;
  901.     /*----------------------------------------------------------------*/
  902.     /* Code Body                                                      */
  903.     /*----------------------------------------------------------------*/
  904.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_GET_HIST_HDLR, scrnID, currHistoryIndex));
  906.     count = currHistoryIndex;
  907.     do
  908.     {
  909.         if (scrnID == historyData[count].scrnID)
  910.         {
  911.             ptrHistory->entryFuncPtr = historyData[count].entryFuncPtr;
  912.             ptrHistory->scrnID = historyData[count].scrnID;
  913.             if (historyData[count].guiBuffer)
  914.             {
  915.                 memcpy(ptrHistory->guiBuffer, historyData[count].guiBuffer, MAX_GUI_BUFFER);
  916.             }
  917.             else
  918.             {
  919.                 memset(ptrHistory->guiBuffer, 0, MAX_GUI_BUFFER);
  920.             }
  921.             if (historyData[count].inputBuffer)
  922.                 /* 2 Bytes Are Added By UI To Keep Size Of InputBuffer Internally In AddNHistory */
  923.             {
  924.                 memcpy(&nSize, historyData[count].inputBuffer, 2);
  925.                 memcpy(
  926.                     ptrHistory->inputBuffer,
  927.                     historyData[count].inputBuffer + 2,
  928.                     (nSize > MAX_INPUT_BUFFER) ? MAX_INPUT_BUFFER : nSize);
  929.             }
  930.             else
  931.             {
  932.                 memset(ptrHistory->inputBuffer, 0, MAX_INPUT_BUFFER);
  933.             }
  934.             Status = ST_SUCCESS;
  935.             break;
  936.         }
  938.         if (count > MIN_HISTORY + 1 && count < MAX_HISTORY)
  939.         {
  940.             --count;
  941.         }
  942.         else
  943.         {
  944.             if (bRoundOffFlag)
  945.             {
  946.                 count = MAX_HISTORY - 1;
  947.             }
  948.             else
  949.             {
  950.                 break;  /* Status is by default FAILURE so no need to set again */
  951.             }
  952.         }
  954.     } while ((count != currHistoryIndex) && (historyData[count].entryFuncPtr != NULL));
  956.     return Status;
  958. }
  961. /*****************************************************************************
  962.  * FUNCTION
  963.  *  GetHistoryPointer
  964.  * DESCRIPTION
  965.  *  Used to get the reference of the history buffer for a screen id
  966.  * PARAMETERS
  967.  *  scrnID          [IN]        
  968.  *  ptrHistory      [IN]        
  969.  * RETURNS
  970.  *  U8 - Status
  971.  *****************************************************************************/
  972. U8 GetHistoryPointer(U16 scrnID, historyNode **ptrHistory)
  973. {
  974.     /*----------------------------------------------------------------*/
  975.     /* Local Variables                                                */
  976.     /*----------------------------------------------------------------*/
  977.     S16 count = 0;
  978.     U8 Status = ST_FAILURE;
  980.     /*----------------------------------------------------------------*/
  981.     /* Code Body                                                      */
  982.     /*----------------------------------------------------------------*/
  983.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_GET_HIST_SCRID_HDLR, scrnID, currHistoryIndex));
  985.     count = currHistoryIndex;
  986.     do
  987.     {
  988.         if (scrnID == historyData[count].scrnID)
  989.         {
  990.             *ptrHistory = &historyData[count];
  991.             Status = ST_SUCCESS;
  992.             break;
  993.         }
  995.         if (count > MIN_HISTORY + 1 && count < MAX_HISTORY)
  996.         {
  997.             --count;
  998.         }
  999.         else
  1000.         {
  1001.             if (bRoundOffFlag)
  1002.             {
  1003.                 count = MAX_HISTORY - 1;
  1004.             }
  1005.             else
  1006.             {
  1007.                 break;  /* Status is by default FAILURE so no need to set again */
  1008.             }
  1009.         }
  1011.     } while ((count != currHistoryIndex) && (historyData[count].entryFuncPtr != NULL));
  1013.     return Status;
  1015. }
  1018. /*****************************************************************************
  1019.  * FUNCTION
  1020.  *  GetHistoryScrID
  1021.  * DESCRIPTION
  1022.  *  Used to get the reference of the history buffer for a screen id
  1023.  *  
  1024.  *  Please change to use GetHistoryPointer,
  1025.  *  rather than GetHistoryScrID
  1026.  * PARAMETERS
  1027.  *  scrnID          [IN]        
  1028.  *  ptrHistory      [IN]        
  1029.  * RETURNS
  1030.  *  U8 - Status
  1031.  *****************************************************************************/
  1032. U8 GetHistoryScrID(U16 scrnID, historyNode **ptrHistory)
  1033. {
  1034.     /*----------------------------------------------------------------*/
  1035.     /* Local Variables                                                */
  1036.     /*----------------------------------------------------------------*/
  1038.     /*----------------------------------------------------------------*/
  1039.     /* Code Body                                                      */
  1040.     /*----------------------------------------------------------------*/
  1041.     return GetHistoryPointer(scrnID, ptrHistory);
  1042. }
  1045. /*****************************************************************************
  1046.  * FUNCTION
  1047.  *  GetNHistory
  1048.  * DESCRIPTION
  1049.  *  Used to get the history for a screen id, and also the history buffer size
  1050.  * PARAMETERS
  1051.  *  scrnID          [IN]        
  1052.  *  ptrHistory      [IN]        
  1053.  * RETURNS
  1054.  *  U8 - Status
  1055.  *****************************************************************************/
  1056. U8 GetNHistory(U16 scrnID, history *ptrHistory)
  1057. {
  1058.     /*----------------------------------------------------------------*/
  1059.     /* Local Variables                                                */
  1060.     /*----------------------------------------------------------------*/
  1061.     S16 count = 0;
  1062.     U8 Status = ST_FAILURE;
  1063.     U16 size;
  1065.     /*----------------------------------------------------------------*/
  1066.     /* Code Body                                                      */
  1067.     /*----------------------------------------------------------------*/
  1068.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_GET_NHIST_HDLR, scrnID, currHistoryIndex));
  1070.     count = currHistoryIndex;
  1071.     do
  1072.     {
  1073.         if (scrnID == historyData[count].scrnID)
  1074.         {
  1075.             ptrHistory->entryFuncPtr = historyData[count].entryFuncPtr;
  1076.             ptrHistory->scrnID = historyData[count].scrnID;
  1077.             if (historyData[count].guiBuffer)
  1078.             {
  1079.                 memcpy(ptrHistory->guiBuffer, historyData[count].guiBuffer, MAX_GUI_BUFFER);
  1080.             }
  1081.             else
  1082.             {
  1083.                 memset(ptrHistory->guiBuffer, 0, MAX_GUI_BUFFER);
  1084.             }
  1085.             if (historyData[count].inputBuffer)
  1086.             {
  1087.                 memcpy((PS8) & size, historyData[count].inputBuffer, 2);
  1088.                 memcpy(ptrHistory->inputBuffer, (PS8) (historyData[count].inputBuffer + 2), size);
  1089.             }
  1090.             else
  1091.             {
  1092.                 memset(ptrHistory->inputBuffer, 0, MAX_INPUT_BUFFER);
  1093.             }
  1094.             Status = ST_SUCCESS;
  1095.             break;
  1096.         }
  1098.         if (count > MIN_HISTORY + 1 && count < MAX_HISTORY)
  1099.         {
  1100.             --count;
  1101.         }
  1102.         else
  1103.         {
  1104.             if (bRoundOffFlag)
  1105.             {
  1106.                 count = MAX_HISTORY - 1;
  1107.             }
  1108.             else
  1109.             {
  1110.                 break;  /* Status is by default FAILURE so no need to set again */
  1111.             }
  1112.         }
  1114.     } while ((count != currHistoryIndex) && (historyData[count].entryFuncPtr != NULL));
  1116.     return Status;
  1118. }
  1121. /*****************************************************************************
  1122.  * FUNCTION
  1123.  *  CheckIsBackHistory
  1124.  * DESCRIPTION
  1125.  *  Is in GoBackHistory
  1126.  *  
  1127.  *  This is typically used by entry function
  1128.  * PARAMETERS
  1129.  *  void
  1130.  * RETURNS
  1131.  *  pBOOL
  1132.  *****************************************************************************/
  1133. pBOOL CheckIsBackHistory(void)
  1134. {
  1135.     /*----------------------------------------------------------------*/
  1136.     /* Local Variables                                                */
  1137.     /*----------------------------------------------------------------*/
  1139.     /*----------------------------------------------------------------*/
  1140.     /* Code Body                                                      */
  1141.     /*----------------------------------------------------------------*/
  1142.     return IsBackHistory;
  1143. }
  1146. /*****************************************************************************
  1147.  * FUNCTION
  1148.  *  GoBackHistory
  1149.  * DESCRIPTION
  1150.  *  deletes previous screen history
  1151.  *  
  1152.  *  This is used to delete previous screen history
  1153.  * PARAMETERS
  1154.  *  void
  1155.  * RETURNS
  1156.  *  void
  1157.  *****************************************************************************/
  1158. #if defined(__DIRECT_ENTRY_FACTORY_MODE_ON_BOOTUP__)
  1159. extern BOOL DirectMode;
  1160. extern void CallBackPowerOnAnimationCompleteWrapper(void);
  1161. #endif /* defined(__DIRECT_ENTRY_FACTORY_MODE_ON_BOOTUP__) */ 
  1163. void GoBackHistory(void)
  1164. {
  1165.     /*----------------------------------------------------------------*/
  1166.     /* Local Variables                                                */
  1167.     /*----------------------------------------------------------------*/
  1168. #if defined(__DIRECT_ENTRY_FACTORY_MODE_ON_BOOTUP__)
  1169.     BOOL Exit_From_FM = (DirectMode && currHistoryIndex == -1);
  1170. #endif 
  1172.     /*----------------------------------------------------------------*/
  1173.     /* Code Body                                                      */
  1174.     /*----------------------------------------------------------------*/
  1175. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1176.     if (redraw_in_small_screen_proceduer())
  1177.     {
  1178.         return;
  1179.     }
  1180. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1182.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_GO_BACK_HIST_HDLR));
  1184.     ExecutePopHistory();
  1186. #if defined(__DIRECT_ENTRY_FACTORY_MODE_ON_BOOTUP__)
  1187.     if (Exit_From_FM)
  1188.     {
  1189.         CallBackPowerOnAnimationCompleteWrapper();
  1190.     }
  1191. #endif /* defined(__DIRECT_ENTRY_FACTORY_MODE_ON_BOOTUP__) */ 
  1193. }
  1196. /*****************************************************************************
  1197.  * FUNCTION
  1198.  *  GoBackToHistory
  1199.  * DESCRIPTION
  1200.  *  Goes back to specified screen
  1201.  * PARAMETERS
  1202.  *  scrnid      [IN]        
  1203.  * RETURNS
  1204.  *  void
  1205.  *****************************************************************************/
  1206. U8 GoBackToHistory(U16 scrnid)
  1207. {
  1208.     /*----------------------------------------------------------------*/
  1209.     /* Local Variables                                                */
  1210.     /*----------------------------------------------------------------*/
  1211.     S16 count = 0;
  1212.     U8 Status = ST_FAILURE;
  1214.     /*----------------------------------------------------------------*/
  1215.     /* Code Body                                                      */
  1216.     /*----------------------------------------------------------------*/
  1217. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1218.     if (redraw_in_small_screen_proceduer())
  1219.     {
  1220.         return ST_SUCCESS;
  1221.     }
  1222. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1224.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_GO_BACK_TO_HIST_HDLR, scrnid));
  1226.     count = currHistoryIndex;
  1228.     do
  1229.     {
  1230.         if (historyData[currHistoryIndex].scrnID == scrnid)
  1231.         {
  1232.             Status = ST_SUCCESS;
  1233.             break;
  1234.         }
  1236.         /* Chack added when amit is doing testing on h/w for call management */
  1237.         if (currHistoryIndex > 0)
  1238.         {
  1239.             if (decrement() == MMI_HIST_STOP_DELETING)
  1240.             {
  1241.                 /* We abort the process here and don't handle original requirement */
  1242.                 Status = ST_SUCCESS;
  1243.                 break;
  1244.             }
  1245.         }
  1246.     } while ((count != currHistoryIndex) && (historyData[currHistoryIndex].entryFuncPtr != NULL)
  1247.              && (currHistoryIndex > 0));
  1249.     if (Status)
  1250.     {
  1251.         ExecutePopHistory();
  1252.     }
  1253.     else if (currHistoryIndex > -1)
  1254.     {
  1255.         /* To make sure the callback will run at topist screen */
  1256.         ExecTopScrnCallbackHandler();
  1257.         (*(historyData[0].entryFuncPtr)) ();
  1258.         currHistoryIndex = -1;
  1259.     }
  1261.     return Status;
  1262. }
  1265. /*****************************************************************************
  1266.  * FUNCTION
  1267.  *  GoBacknHistory
  1268.  * DESCRIPTION
  1269.  *  Goes 'n' screens back
  1270.  * PARAMETERS
  1271.  *  nHistory        [IN]        
  1272.  * RETURNS
  1273.  *  void
  1274.  *****************************************************************************/
  1275. void GoBacknHistory(U16 nHistory)
  1276. {
  1277.     /*----------------------------------------------------------------*/
  1278.     /* Local Variables                                                */
  1279.     /*----------------------------------------------------------------*/
  1280.     S16 Index = 0;
  1281.     S16 Count = 0;
  1283.     /*----------------------------------------------------------------*/
  1284.     /* Code Body                                                      */
  1285.     /*----------------------------------------------------------------*/
  1286. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1287.     if (redraw_in_small_screen_proceduer())
  1288.     {
  1289.         return;
  1290.     }
  1291. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1293.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_GO_BACK_NHIST_HDLR, nHistory));
  1295.     if (bRoundOffFlag)
  1296.     {
  1297.         Index = MAX_HISTORY + currHistoryIndex;
  1298.     }
  1299.     else
  1300.     {
  1301.         Index = currHistoryIndex;
  1302.     }
  1304.     if (Index >= nHistory)
  1305.     {
  1306.         for (Count = nHistory; Count >= 1; --Count)
  1307.         {
  1308.             /* JL, if want to stop to run next decrement will return true. */
  1309.             if (decrement() == MMI_HIST_STOP_DELETING)
  1310.             {
  1311.                 /* We abort the process here and don't handle original requirement */
  1312.                 break;
  1313.             }
  1314.         }
  1315.         ExecutePopHistory();
  1316.     }
  1317. }
  1320. /*****************************************************************************
  1321.  * FUNCTION
  1322.  *  ExecutePopHistory
  1323.  * DESCRIPTION
  1324.  *  executes current scrn & then deletes from history
  1325.  * PARAMETERS
  1326.  *  void
  1327.  * RETURNS
  1328.  *  void
  1329.  *****************************************************************************/
  1330. static void ExecutePopHistory(void)
  1331. {
  1332.     /*----------------------------------------------------------------*/
  1333.     /* Local Variables                                                */
  1334.     /*----------------------------------------------------------------*/
  1336.     /*----------------------------------------------------------------*/
  1337.     /* Code Body                                                      */
  1338.     /*----------------------------------------------------------------*/
  1339. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1340.     if (redraw_in_small_screen_proceduer())
  1341.     {
  1342.         return;
  1343.     }
  1344. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1346.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_EXE_POP_HIST_HDLR, GetActiveScreenId(), GetExitScrnID(), IsBackHistory, CheckMainLCDHistoryBack));
  1348.     IsBackHistory = MMI_TRUE;
  1349.     CheckMainLCDHistoryBack = MMI_TRUE;
  1350.     bBackHistoryFlag = MMI_TRUE;
  1352.     if (historyData[currHistoryIndex].entryFuncPtr && currHistoryIndex > 0)
  1353.     {
  1354.         U16 id;
  1356.         /* To make sure the callback will run at topist screen */
  1357.         ExecTopScrnCallbackHandler();
  1359.         //entryFuncPtr = (*(historyData[currHistoryIndex].entryFuncPtr));
  1360.         //decrement(MMI_TRUE);
  1361.         //entryFuncPtr();
  1363.         id = historyData[currHistoryIndex].scrnID;
  1364.     #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1365.         if (historyData[currHistoryIndex].isSmallScreen)
  1366.         {
  1367.             S32 i;
  1368.             S32 tmp = currHistoryIndex;
  1370.             i = currHistoryIndex - 1;
  1371.             while (historyData[i].isSmallScreen && i > 0)
  1372.             {
  1373.                 i--;
  1374.             }
  1375.             if ((currHistoryIndex == 0) || (i == 0 && historyData[i].isSmallScreen))
  1376.             {
  1377.                 clear_screen();
  1378.             }
  1380.             redrawing_old_screens = MMI_HIST_SMALLSCREEN_ACTIVE;
  1381.             MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_EXE_SMALL_SCREEN_BEGIN, currHistoryIndex, i));
  1382.             gdi_lcd_freeze(TRUE);
  1383.         #ifdef __MMI_INTERACTIVE_PROFILNG__
  1384.             mmi_frm_profiling_interactive_start();
  1385.         #endif 
  1386.             while ((i < currHistoryIndex) && (i >= 0))
  1387.             {
  1388.                 currHistoryIndex = i;
  1389.                 IsBackHistory = MMI_TRUE;
  1390.                 CheckMainLCDHistoryBack = MMI_TRUE;
  1391.                 if (historyData[i].entryFuncPtr)
  1392.                 {
  1393.                     (*(historyData[i].entryFuncPtr)) ();
  1394.                 }
  1395.                 i++;
  1396.             }
  1397.             gdi_lcd_freeze(FALSE);
  1398.             IsBackHistory = MMI_TRUE;
  1399.             CheckMainLCDHistoryBack = MMI_TRUE;
  1400.             redrawing_old_screens = MMI_HIST_SMALLSCREEN_ACTIVE_IN_EXIT_FUNC;
  1401.             currHistoryIndex = tmp;
  1402.             MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_EXE_SMALL_SCREEN_END, historyData[currHistoryIndex].scrnID, historyData[currHistoryIndex].entryFuncPtr));
  1403.             if (historyData[currHistoryIndex].entryFuncPtr)
  1404.             {
  1405.                 (*(historyData[currHistoryIndex].entryFuncPtr)) ();
  1406.             }
  1407.         #ifdef __MMI_INTERACTIVE_PROFILNG__
  1408.             mmi_frm_profiling_interactive_end();
  1409.             mmi_frm_profiling_interactive_show((U8*) L"S", MMI_FRM_PROFILING_MASK_1);
  1410.         #endif /* __MMI_INTERACTIVE_PROFILNG__ */ 
  1412.             if (id == historyData[currHistoryIndex].scrnID)
  1413.             {
  1414.                 decrement();
  1415.             }
  1416.             /*
  1417.              * We changet the small screen procedure state here.
  1418.              * When we execute the last entry function, 
  1419.              * it also executed the previous exit function.
  1420.              * We still don't want to add the history in that case.
  1421.              */
  1422.              redrawing_old_screens = MMI_HIST_SMALLSCREEN_NONE;
  1423.         }
  1424.         else
  1425.     #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1426.         {
  1427.         #ifdef __MMI_INTERACTIVE_PROFILNG__
  1428.             mmi_frm_profiling_interactive_start();
  1429.             if (historyData[currHistoryIndex].entryFuncPtr)
  1430.             {
  1431.                 (*(historyData[currHistoryIndex].entryFuncPtr)) ();
  1432.             }
  1433.             mmi_frm_profiling_interactive_end();
  1434.             mmi_frm_profiling_interactive_show((U8*) L"S", MMI_FRM_PROFILING_MASK_1);
  1435.         #else /* __MMI_INTERACTIVE_PROFILNG__ */ 
  1436.             if (historyData[currHistoryIndex].entryFuncPtr)
  1437.             {
  1438.                 (*(historyData[currHistoryIndex].entryFuncPtr)) ();
  1439.             }
  1440.         #endif /* __MMI_INTERACTIVE_PROFILNG__ */ 
  1441.             if (id == historyData[currHistoryIndex].scrnID)
  1442.             {
  1443.                 decrement();
  1444.             }
  1445.         }
  1446.     }
  1447.     else
  1448.     {
  1449.         extern void EntryIdleScreen(void);
  1450.         
  1451.         /* To make sure the callback will run at topist screen */
  1452.         ExecTopScrnCallbackHandler();
  1453.         /* Go to idle screen */
  1454.         currHistoryIndex = -1;
  1455.         if ((historyData[0].entryFuncPtr))
  1456.         {
  1457.         #ifdef __MMI_INTERACTIVE_PROFILNG__
  1458.             mmi_frm_profiling_interactive_start();
  1459.             (*(historyData[0].entryFuncPtr)) ();
  1460.             mmi_frm_profiling_interactive_end();
  1461.             mmi_frm_profiling_interactive_show((U8*) L"S", MMI_FRM_PROFILING_MASK_1);
  1462.         #else /* __MMI_INTERACTIVE_PROFILNG__ */ 
  1463.             (*(historyData[0].entryFuncPtr)) ();
  1464.         #endif /* __MMI_INTERACTIVE_PROFILNG__ */ 
  1465.         }
  1466.         if (historyData[0].entryFuncPtr != EntryIdleScreen)
  1467.         {
  1468.             /* EntryIdleScreen() will add the history in entry function */
  1469.             mmi_free_history_buffer(0);
  1470.             memset(&historyData[0], 0, sizeof(historyNode));
  1471.         }
  1473.         IsBackHistory = MMI_FALSE;
  1475.     }
  1477.     CheckMainLCDHistoryBack = MMI_FALSE;
  1478.     bBackHistoryFlag = MMI_FALSE;
  1479.     // reset delete CB flag, while go back screen.
  1480.     //is_del_cb_found = MMI_FALSE; // gilbert --- for modifying decrement()
  1482. }
  1485. /*****************************************************************************
  1486.  * FUNCTION
  1487.  *  GetCurrScrnId
  1488.  * DESCRIPTION
  1489.  *  Gets the id of the screen on the top of history stack.
  1490.  *  
  1491.  *  This is used to get current screen input buffer
  1492.  * PARAMETERS
  1493.  *  void
  1494.  * RETURNS
  1495.  *  U16 - Current Screen Id
  1496.  *****************************************************************************/
  1497. U16 GetCurrScrnId(void)
  1498. {
  1499.     /*----------------------------------------------------------------*/
  1500.     /* Local Variables                                                */
  1501.     /*----------------------------------------------------------------*/
  1503.     /*----------------------------------------------------------------*/
  1504.     /* Code Body                                                      */
  1505.     /*----------------------------------------------------------------*/
  1506.     return (historyData[currHistoryIndex].scrnID);
  1507. }
  1510. /*****************************************************************************
  1511.  * FUNCTION
  1512.  *  DeleteScreens
  1513.  * DESCRIPTION
  1514.  *  Deletes the screen IDs in the history
  1515.  *  The start screen ID and end screen ID will be deleted.
  1516.  *  If all screen IDs in the history are deleted
  1517.  *  successfully, the function returns ST_SUCCESS.
  1518.  *  If the parameters are error or someone screen
  1519.  *  ID can't be deleted successfully, the function
  1520.  *  returns ST_FAILURE.
  1521.  * PARAMETERS
  1522.  *  start_scrnid        [IN]        IN  the start screen ID (small number)
  1523.  *  end_scrnid          [IN]        IN  the end screen ID (big number)
  1524.  * RETURNS
  1525.  *  U8 - status
  1526.  *****************************************************************************/
  1527. U8 DeleteScreens(U16 start_scrnid, U16 end_scrnid)
  1528. {
  1529.     /*----------------------------------------------------------------*/
  1530.     /* Local Variables                                                */
  1531.     /*----------------------------------------------------------------*/
  1532.     S16 count = 0, del_cnt = 0, i = 0;
  1533.     U8 Status = ST_SUCCESS;
  1535.     /*----------------------------------------------------------------*/
  1536.     /* Code Body                                                      */
  1537.     /*----------------------------------------------------------------*/
  1539. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1540.     if (redraw_in_small_screen_proceduer())
  1541.     {
  1542.         return ST_SUCCESS;
  1543.     }
  1544. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1546.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_DEL_SCRS_HDLR, start_scrnid, end_scrnid));
  1548.     count = currHistoryIndex;
  1550.     if (start_scrnid > end_scrnid)
  1551.     {
  1552.         return ST_FAILURE;
  1553.     }
  1555.     while (count)
  1556.     {
  1557.         if ((start_scrnid <= historyData[count].scrnID) && (historyData[count].scrnID <= end_scrnid))
  1558.         {
  1559.             if (ExecHistoryScrnCallBackHandle(count) == MMI_HIST_STOP_DELETING)
  1560.             {
  1561.                 /*
  1562.                  * The screen won't want to delete. 
  1563.                  * We stop continue to delete the screens.
  1564.                  */
  1565.                 Status = ST_FAILURE;
  1566.                 break;
  1567.             }
  1568.             del_cnt++;
  1569.             /* Deleting the node */
  1570.             mmi_free_history_buffer(count);
  1571.             /* Shifting All the nodes by one notch */
  1572.             for (i = 0; i <= (currHistoryIndex - count); i++)
  1573.             {
  1574.                 memcpy(&historyData[count + i], &historyData[count + i + 1], sizeof(historyNode));
  1575.             }
  1576.         }
  1577.         count--;
  1578.     }
  1580.     currHistoryIndex -= del_cnt;
  1581.     MMI_ASSERT(currHistoryIndex>=0);
  1582.     memset(&historyData[currHistoryIndex + 1], 0, sizeof(historyNode));
  1584.     return Status;
  1585. }
  1588. /*****************************************************************************
  1589.  * FUNCTION
  1590.  *  DeleteBeyondScrTillScr
  1591.  * DESCRIPTION
  1592.  *  To delete scrns beyond scrn A
  1593.  *  till scrn B
  1594.  * PARAMETERS
  1595.  *  beyondScrnid        [IN]        
  1596.  *  tillScrnid          [IN]        
  1597.  * RETURNS
  1598.  *  U8 - status
  1599.  *****************************************************************************/
  1600. U8 DeleteBeyondScrTillScr(U16 beyondScrnid, U16 tillScrnid)
  1601. {
  1603.     /*----------------------------------------------------------------*/
  1604.     /* Local Variables                                                */
  1605.     /*----------------------------------------------------------------*/
  1606.     U8 Status = ST_SUCCESS;
  1607.     U16 count = 0, count1 = 0;
  1608.     S16 endScreenPresent = -1, startScreenPresent = -1;
  1609.     U16 screensDeleted = 0;
  1611.     /*----------------------------------------------------------------*/
  1612.     /* Code Body                                                      */
  1613.     /*----------------------------------------------------------------*/
  1615. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1616.     if (redraw_in_small_screen_proceduer())
  1617.     {
  1618.         return ST_SUCCESS;
  1619.     }
  1620. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1622.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_DEL_BEYOND_SCR_TILL_SCR_HDLR, beyondScrnid, tillScrnid));
  1624.     if (currHistoryIndex > 0)
  1625.     {
  1626.         count = currHistoryIndex;
  1627.         count1 = currHistoryIndex;
  1628.     }
  1630.     while (count)
  1631.     {
  1632.         if (historyData[count].scrnID == beyondScrnid)
  1633.         {
  1634.             startScreenPresent = count;
  1635.             break;
  1636.         }
  1637.         --count;
  1638.     }
  1640.     if (startScreenPresent > 0)
  1641.     {
  1642.         --count;
  1643.         /* if tillscrn is at index 0 */
  1644.         while (count || ((count == 0) && (historyData[0].scrnID == tillScrnid)))
  1645.         {
  1646.             if (historyData[count].scrnID == tillScrnid)
  1647.             {
  1648.                 endScreenPresent = count;
  1649.                 break;
  1650.             }
  1651.             --count;
  1652.         }
  1653.     }
  1654.     else
  1655.     {
  1656.         return ST_FAILURE;
  1657.     }
  1658.     MMI_ASSERT((startScreenPresent != -1) && (endScreenPresent != -1));
  1660.     for (count = startScreenPresent - 1; count >= endScreenPresent; count--)
  1661.     {
  1662.         if (ExecHistoryScrnCallBackHandle(count) == MMI_HIST_STOP_DELETING)
  1663.         {
  1664.             /*
  1665.              * The screen won't want to delete. 
  1666.              * We stop continue to delete the screens.
  1667.              */
  1668.             endScreenPresent = count + 1;
  1669.             Status = ST_FAILURE;
  1670.             break;
  1671.         }
  1672.         mmi_free_history_buffer(count);
  1673.         memset(&historyData[count], 0, sizeof(historyNode));
  1674.         currHistoryIndex--;
  1675.         screensDeleted++;
  1676.         if (count == 0)
  1677.         {
  1678.             /* count is U16 not S16 */
  1679.             break;
  1680.         }
  1681.     }
  1683.     memcpy(
  1684.         historyData + endScreenPresent,
  1685.         historyData + startScreenPresent,
  1686.         sizeof(historyNode) * (count1 - startScreenPresent + 1));
  1687.     memset(historyData + (currHistoryIndex + 1), 0, (sizeof(historyNode) * screensDeleted));
  1689.     return Status;
  1690. }
  1693. /*****************************************************************************
  1694.  * FUNCTION
  1695.  *  DeleteBetweenScreen
  1696.  * DESCRIPTION
  1697.  *  Deletes Between two Screens including the boundaries
  1698.  * PARAMETERS
  1699.  *  StartScrId      [IN]        
  1700.  *  EndScrId        [IN]        
  1701.  * RETURNS
  1702.  *  U16 - status
  1703.  *****************************************************************************/
  1704. U16 DeleteBetweenScreen(U16 StartScrId, U16 EndScrId)
  1705. {
  1706.     /*----------------------------------------------------------------*/
  1707.     /* Local Variables                                                */
  1708.     /*----------------------------------------------------------------*/
  1709.     U8 Status = ST_SUCCESS;
  1710.     U16 count = 0, count1 = 0;
  1711.     S16 endScreenPresent = -1, startScreenPresent = -1;
  1712.     U16 screensDeleted = 0;
  1714.     /*----------------------------------------------------------------*/
  1715.     /* Code Body                                                      */
  1716.     /*----------------------------------------------------------------*/
  1718. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1719.     if (redraw_in_small_screen_proceduer())
  1720.     {
  1721.         return ST_SUCCESS;
  1722.     }
  1723. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1725.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_DEL_BETWEEN_SCR_HDLR, StartScrId, EndScrId));
  1727.     if (currHistoryIndex > 0)
  1728.     {
  1729.         count = currHistoryIndex;
  1730.         count1 = currHistoryIndex;
  1731.     }
  1733.     while (count)
  1734.     {
  1735.         if (historyData[count].scrnID == EndScrId)
  1736.         {
  1737.             startScreenPresent = count;
  1738.             break;
  1739.         }
  1740.         --count;
  1741.     }
  1743.     if (startScreenPresent >= 0)
  1744.     {
  1745.         while (count)
  1746.         {
  1747.             if (historyData[count].scrnID == StartScrId)
  1748.             {
  1749.                 endScreenPresent = count;
  1750.                 break;
  1751.             }
  1752.             --count;
  1753.         }
  1754.     }
  1755.     else
  1756.     {
  1757.         return ST_FAILURE;
  1758.     }
  1760.     MMI_ASSERT((startScreenPresent != -1) && (endScreenPresent != -1));
  1761.     for (count = startScreenPresent; count >= endScreenPresent; count--)
  1762.     {
  1763.         if (ExecHistoryScrnCallBackHandle(count) == MMI_HIST_STOP_DELETING)
  1764.         {
  1765.             /*
  1766.              * The screen won't want to delete. 
  1767.              * We stop continue to delete the screens.
  1768.              */
  1769.             endScreenPresent = count + 1;
  1770.             Status = ST_FAILURE;
  1771.             break;
  1772.         }
  1774.         mmi_free_history_buffer(count);
  1775.         currHistoryIndex--;
  1776.         screensDeleted++;
  1777.         if (count == 0)
  1778.         {
  1779.             /* count is U16 not S16 */
  1780.             break;
  1781.         }
  1782.     }
  1783.     memcpy(
  1784.         historyData + endScreenPresent,
  1785.         historyData + startScreenPresent + 1,
  1786.         sizeof(historyNode) * (count1 - startScreenPresent + 1));
  1787.     memset(historyData + (currHistoryIndex + 1), 0, (sizeof(historyNode) * screensDeleted));
  1789.     return ST_SUCCESS;
  1790. }
  1793. /*****************************************************************************
  1794.  * FUNCTION
  1795.  *  DeleteScreenIfPresent
  1796.  * DESCRIPTION
  1797.  *  Deletes Screen from History
  1798.  * PARAMETERS
  1799.  *  ScrId       [IN]        
  1800.  * RETURNS
  1801.  *  U16 - status
  1802.  *****************************************************************************/
  1803. U16 DeleteScreenIfPresent(U16 ScrId)
  1804. {
  1805.     /*----------------------------------------------------------------*/
  1806.     /* Local Variables                                                */
  1807.     /*----------------------------------------------------------------*/
  1808.     U16 count, i;
  1810.     /*----------------------------------------------------------------*/
  1811.     /* Code Body                                                      */
  1812.     /*----------------------------------------------------------------*/
  1814. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1815.     if (redraw_in_small_screen_proceduer())
  1816.     {
  1817.         return ST_SUCCESS;
  1818.     }
  1819. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1821.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_DEL_SCR_IF_PRESENT_HDLR, ScrId));
  1823.     if (!IsScreenPresent(ScrId))
  1824.     {
  1825.         return ST_FAILURE;
  1826.     }
  1828.     count = currHistoryIndex;
  1830.     /* Locating the screen */
  1831.     while (count)
  1832.     {
  1833.         if (historyData[count].scrnID == ScrId)
  1834.         {
  1836.             break;
  1837.         }
  1838.         --count;
  1839.     }
  1841.     /*
  1842.      * Not support for stop callback at this funciton 
  1843.      * Because the application want to delete the special screen in the history,
  1844.      * we don't need to check the return value of the delete callback function.
  1845.      */
  1846.     ExecHistoryScrnCallBackHandle(count);
  1848.     /* Deleting the node */
  1849.     mmi_free_history_buffer(count);
  1851.     /* Shifting All the nodes by one notch */
  1852.     for (i = count + 1; i <= currHistoryIndex; i++, count++)
  1853.     {
  1854.         memcpy(&historyData[count], &historyData[i], sizeof(historyNode));
  1855.     }
  1857.     --currHistoryIndex;
  1858.     memset(&historyData[currHistoryIndex + 1], 0, sizeof(historyNode));
  1859.     return ST_SUCCESS;
  1860. }
  1863. /*****************************************************************************
  1864.  * FUNCTION
  1865.  *  DeleteScreenFromToNnodes
  1866.  * DESCRIPTION
  1867.  *  Deletes N nodes from  History starting from a particular screen
  1868.  * PARAMETERS
  1869.  *  ScrId           [IN]        
  1870.  *  num_nodes       [IN]        
  1871.  * RETURNS
  1872.  *  U16 - status
  1873.  *****************************************************************************/
  1874. U16 DeleteScreenFromToNnodes(U16 ScrId, U16 num_nodes)
  1875. {
  1876.     /*----------------------------------------------------------------*/
  1877.     /* Local Variables                                                */
  1878.     /*----------------------------------------------------------------*/
  1879.     U16 count, i;
  1880.     U16 temp = 0;
  1881.     U16 k = 0;
  1883.     /*----------------------------------------------------------------*/
  1884.     /* Code Body                                                      */
  1885.     /*----------------------------------------------------------------*/
  1887. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1888.     if (redraw_in_small_screen_proceduer())
  1889.     {
  1890.         return ST_SUCCESS;
  1891.     }
  1892. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1894.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_DEL_SCR_FROM_TO_N_NODE_HDLR, ScrId, num_nodes));
  1896.     if (!IsScreenPresent(ScrId))
  1897.     {
  1898.         return ST_FAILURE;
  1899.     }
  1901.     count = currHistoryIndex;
  1903.     /* Locating the screen */
  1904.     while (count)
  1905.     {
  1906.         if (historyData[count].scrnID == ScrId)
  1907.         {
  1908.             break;
  1909.         }
  1910.         --count;
  1911.     }
  1913.     for (temp = 0; temp < num_nodes; temp++)
  1914.     {
  1915.         /* Not support for stop callback at this funciton */
  1916.         if (ExecHistoryScrnCallBackHandle(count) == MMI_HIST_STOP_DELETING)
  1917.         {
  1918.             /*
  1919.              * The screen won't want to delete. 
  1920.              * We stop continue to delete the screens.
  1921.              */
  1922.             return ST_FAILURE;
  1923.         }
  1925.         /* Deleting the node */
  1926.         mmi_free_history_buffer(count);
  1928.         /* Shifting All the nodes by one notch */
  1929.         k = count;
  1930.         for (i = k + 1; i <= currHistoryIndex; i++, k++)
  1931.         {
  1932.             memcpy(&historyData[k], &historyData[i], sizeof(historyNode));
  1933.         }
  1935.         currHistoryIndex--;
  1936.         memset(&historyData[currHistoryIndex + 1], 0, sizeof(historyNode));
  1938.         count--;
  1939.         if ((count == 0) && ((temp + 1) < num_nodes))
  1940.         {
  1941.             return ST_FAILURE;
  1942.         }
  1943.     }
  1945.     return ST_SUCCESS;
  1946. }
  1949. /*****************************************************************************
  1950.  * FUNCTION
  1951.  *  DeleteFromScrUptoScr
  1952.  * DESCRIPTION
  1953.  *  Deletes screen from start scrnid to before end scrnid
  1954.  *  (include start scrnid but not include end scrnid)
  1955.  * PARAMETERS
  1956.  *  start_scrnid        [IN]        
  1957.  *  upto_scrnid         [IN]        
  1958.  * RETURNS
  1959.  *  U16 - status
  1960.  *****************************************************************************/
  1961. U8 DeleteFromScrUptoScr(U16 start_scrnid, U16 upto_scrnid)
  1962. {
  1964.     /*----------------------------------------------------------------*/
  1965.     /* Local Variables                                                */
  1966.     /*----------------------------------------------------------------*/
  1967.     U8 Status = ST_SUCCESS;
  1968.     S16 count = 0, count1 = 0;
  1969.     S16 endScreenPresent = -1, startScreenPresent = -1;
  1970.     U16 screensDeleted = 0;
  1972.     /*----------------------------------------------------------------*/
  1973.     /* Code Body                                                      */
  1974.     /*----------------------------------------------------------------*/
  1976. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1977.     if (redraw_in_small_screen_proceduer())
  1978.     {
  1979.         return ST_SUCCESS;
  1980.     }
  1981. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1983.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_DEL_FROM_SCR_UPTO_SCR_HDLR, start_scrnid, upto_scrnid));
  1985.     if (currHistoryIndex > 0)
  1986.     {
  1987.         count = currHistoryIndex;
  1988.         count1 = currHistoryIndex;
  1989.     }
  1991.     while (count)
  1992.     {
  1993.         if (historyData[count].scrnID == start_scrnid)
  1994.         {
  1995.             startScreenPresent = count;
  1996.             break;
  1997.         }
  1998.         --count;
  1999.     }
  2001.     if (startScreenPresent > 0)
  2002.     {
  2003.         --count;
  2004.         /* if tillscrn is at index 0 */
  2005.         while (count || ((count == 0) && (historyData[0].scrnID == upto_scrnid)))
  2006.         {
  2007.             if (historyData[count].scrnID == upto_scrnid)
  2008.             {
  2009.                 endScreenPresent = count;
  2010.                 break;
  2011.             }
  2012.             --count;
  2013.         }
  2014.     }
  2015.     else
  2016.     {
  2017.         return ST_FAILURE;
  2018.     }
  2020.     MMI_ASSERT((startScreenPresent != -1) && (endScreenPresent != -1));
  2021.     for (count = startScreenPresent; count > endScreenPresent; count--)
  2022.     {
  2023.         if (ExecHistoryScrnCallBackHandle(count) == MMI_HIST_STOP_DELETING)
  2024.         {
  2025.             /*
  2026.              * The screen won't want to delete. 
  2027.              * We stop continue to delete the screens.
  2028.              */
  2029.             endScreenPresent = count + 1;
  2030.             Status = ST_FAILURE;
  2031.             break;
  2032.         }
  2033.         mmi_free_history_buffer(count);
  2034.         memset(&historyData[count], 0, sizeof(historyNode));
  2035.         currHistoryIndex--;
  2036.         screensDeleted++;
  2037.     }
  2039.     memcpy(
  2040.         historyData + endScreenPresent + 1,
  2041.         historyData + startScreenPresent + 1,
  2042.         sizeof(historyNode) * (count1 - startScreenPresent));
  2043.     memset(historyData + (currHistoryIndex + 1), 0, (sizeof(historyNode) * screensDeleted));
  2045.     return Status;
  2046. }
  2049. /*****************************************************************************
  2050.  * FUNCTION
  2051.  *  InsertHistoryBeforeThisScrnReference
  2052.  * DESCRIPTION
  2053.  *  Insert new screen into history before this screen
  2054.  * PARAMETERS
  2055.  *  scrnId          [IN]        
  2056.  *  addHistory      [IN]         
  2057.  * RETURNS
  2058.  *  void
  2059.  *****************************************************************************/
  2060. void InsertHistoryBeforeThisScrnReference(U16 scrnId, history *addHistory)
  2061. {
  2062.     /*----------------------------------------------------------------*/
  2063.     /* Local Variables                                                */
  2064.     /*----------------------------------------------------------------*/
  2065.     U16 count = 0;
  2066.     U16 i = 0;
  2067.     S32 len = 0;
  2069.     /*----------------------------------------------------------------*/
  2070.     /* Code Body                                                      */
  2071.     /*----------------------------------------------------------------*/
  2073.     /* find this screen in history */
  2074.     if (!IsScreenPresent(scrnId))
  2075.     {
  2076.         return;
  2077.     }
  2078.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_INSERT_HIST_BEFORE_SCREEN_HDLR, scrnId));
  2079.     count = currHistoryIndex;
  2080.     /* Locating the screen */
  2081.     while (count)
  2082.     {
  2083.         if (historyData[count].scrnID == scrnId)
  2084.         {
  2085.             break;
  2086.         }
  2087.         --count;
  2088.     }
  2089.     increment();
  2090.     /* Shifting All the nodes by one notch */
  2091.     for (i = currHistoryIndex; i != count; i--)
  2092.     {
  2093.         memcpy(&historyData[i], &historyData[i - 1], sizeof(historyNode));
  2094.     }
  2095.     /* insert new screen in hostory   */
  2096.     memset(&historyData[count], 0, sizeof(historyNode));
  2097.     historyData[count].scrnID = addHistory->scrnID;
  2098.     historyData[count].entryFuncPtr = addHistory->entryFuncPtr;
  2099.     len = pfnUnicodeStrlen((PS8) addHistory->inputBuffer);
  2100.     if (len)
  2101.     {
  2102.         historyData[count].inputBuffer = OslMalloc(len * ENCODING_LENGTH + ENCODING_LENGTH);
  2103.         pfnUnicodeStrcpy((PS8) historyData[count].inputBuffer, (PS8) addHistory->inputBuffer);
  2104.     }
  2105.     historyData[count].guiBuffer = OslMalloc(MAX_GUI_BUFFER);
  2106.     memcpy(historyData[count].guiBuffer, addHistory->guiBuffer, MAX_GUI_BUFFER);
  2107.     /* return success */
  2108.     return;
  2109. }
  2112. /*****************************************************************************
  2113.  * FUNCTION
  2114.  *  GetScreenCountInHistory
  2115.  * DESCRIPTION
  2116.  *  Get the screen numbers in the history
  2117.  * PARAMETERS
  2118.  *  void
  2119.  * RETURNS
  2120.  *  S16 - screen count
  2121.  *****************************************************************************/
  2122. S16 GetScreenCountInHistory(void)
  2123. {
  2124.     /*----------------------------------------------------------------*/
  2125.     /* Local Variables                                                */
  2126.     /*----------------------------------------------------------------*/
  2128.     /*----------------------------------------------------------------*/
  2129.     /* Code Body                                                      */
  2130.     /*----------------------------------------------------------------*/
  2131.     return (currHistoryIndex + 1);
  2132. }
  2135. /*****************************************************************************
  2136.  * FUNCTION
  2137.  *  GetCurrInputBuffer
  2138.  * DESCRIPTION
  2139.  *  gets current screen input buffer
  2140.  *  
  2141.  *  This is used to get current screen input buffer
  2142.  * PARAMETERS
  2143.  *  scrnid      [IN]        
  2144.  * RETURNS
  2145.  *  U8* - history buffer
  2146.  *****************************************************************************/
  2147. U8 *GetCurrInputBuffer(U16 scrnid)
  2148. {
  2149.     /*----------------------------------------------------------------*/
  2150.     /* Local Variables                                                */
  2151.     /*----------------------------------------------------------------*/
  2152.     S16 count = 0;
  2154.     /*----------------------------------------------------------------*/
  2155.     /* Code Body                                                      */
  2156.     /*----------------------------------------------------------------*/
  2157.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_GET_CUR_INPUT_BUF_HDLR, scrnid));
  2159.     count = currHistoryIndex;
  2161.     if (historyData[currHistoryIndex].scrnID == scrnid)
  2162.     {
  2163.         return (historyData[count].inputBuffer);
  2164.     }
  2165.     else
  2166.     {
  2167.         return NULL;
  2168.     }
  2169. }
  2172. /*****************************************************************************
  2173.  * FUNCTION
  2174.  *  GetCurrNInputBuffer
  2175.  * DESCRIPTION
  2176.  *  Retrieve the input current screen input buffer
  2177.  *  
  2178.  *  Buffer can contain several null terminated
  2179.  *  strings , so along with pointer size is also
  2180.  *  returned
  2181.  * PARAMETERS
  2182.  *  scrnid      [IN]        
  2183.  *  size        [IN]        
  2184.  * RETURNS
  2185.  *  U8*
  2186.  *****************************************************************************/
  2187. U8 *GetCurrNInputBuffer(U16 scrnid, U16 *size)
  2188. {
  2189.     /*----------------------------------------------------------------*/
  2190.     /* Local Variables                                                */
  2191.     /*----------------------------------------------------------------*/
  2192.     S16 count = currHistoryIndex;
  2194.     /*----------------------------------------------------------------*/
  2195.     /* Code Body                                                      */
  2196.     /*----------------------------------------------------------------*/
  2197.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_GET_CUR_NINPUT_BUF_HDLR, scrnid));
  2199.     if (historyData[currHistoryIndex].scrnID == scrnid)
  2200.     {
  2201.         memcpy(size, historyData[count].inputBuffer, 2);
  2202.         return ((historyData[count].inputBuffer) + 2);
  2203.     }
  2204.     else
  2205.     {
  2206.         return NULL;
  2207.     }
  2208. }
  2211. /*****************************************************************************
  2212.  * FUNCTION
  2213.  *  GetCurrGuiBuffer
  2214.  * DESCRIPTION
  2215.  *  gets current screen gui buffer
  2216.  *  
  2217.  *  This is used to get current screen gui buffer
  2218.  * PARAMETERS
  2219.  *  scrnid      [IN]        
  2220.  * RETURNS
  2221.  *  U8*
  2222.  *****************************************************************************/
  2223. U8 *GetCurrGuiBuffer(U16 scrnid)
  2224. {
  2225.     /*----------------------------------------------------------------*/
  2226.     /* Local Variables                                                */
  2227.     /*----------------------------------------------------------------*/
  2228.     S16 count = 0;
  2230.     /*----------------------------------------------------------------*/
  2231.     /* Code Body                                                      */
  2232.     /*----------------------------------------------------------------*/
  2233.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_GET_CUR_GUI_BUF_HDLR, scrnid, currHistoryIndex));
  2235.     count = currHistoryIndex;
  2237.     if (historyData[count].scrnID == scrnid)
  2238.     {
  2239.         return (historyData[count].guiBuffer);
  2240.     }
  2241.     else
  2242.     {
  2243.         return NULL;
  2244.     }
  2245. }
  2248. /*****************************************************************************
  2249.  * FUNCTION
  2250.  *  InitHistory
  2251.  * DESCRIPTION
  2252.  *  Initialize the history data structure
  2253.  *  
  2254.  *  Initialize the history data structure
  2255.  * PARAMETERS
  2256.  *  main_root_ptr       [IN]        
  2257.  *  sub_root_ptr        [IN]        
  2258.  * RETURNS
  2259.  *  void
  2260.  *****************************************************************************/
  2261. void InitHistory(MainLcdHistoryCBPtr main_root_ptr, SubLcdHistoryCBPtr sub_root_ptr)
  2262. {
  2264.     /*----------------------------------------------------------------*/
  2265.     /* Local Variables                                                */
  2266.     /*----------------------------------------------------------------*/
  2267.     /* U16 count =0; */
  2269.     /*----------------------------------------------------------------*/
  2270.     /* Code Body                                                      */
  2271.     /*----------------------------------------------------------------*/
  2272. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  2273.     if (redraw_in_small_screen_proceduer())
  2274.     {
  2275.         return;
  2276.     }
  2277. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  2279.     memset(historyData, 0, sizeof(historyNode) * MAX_HISTORY);
  2280.     /* MTK added by JL for history callback */
  2281.     memset(historyCBHandler, 0, sizeof(historyCallback) * MAX_HISTORY);
  2283.     InitSubLCDHistory(sub_root_ptr);
  2285. }
  2288. /*****************************************************************************
  2289.  * FUNCTION
  2290.  *  HistoryDump
  2291.  * DESCRIPTION
  2292.  *  Dumps the history to file or debug window
  2293.  *  
  2294.  *  HistoryDump will be used for dbugging purposes
  2295.  * PARAMETERS
  2296.  *  void
  2297.  * RETURNS
  2298.  *  void
  2299.  *****************************************************************************/
  2300. void HistoryDump(void)
  2301. {
  2303.     /*----------------------------------------------------------------*/
  2304.     /* Local Variables                                                */
  2305.     /*----------------------------------------------------------------*/
  2306.     S16 count = 0;
  2308.     /*----------------------------------------------------------------*/
  2309.     /* Code Body                                                      */
  2310.     /*----------------------------------------------------------------*/
  2311.     count = currHistoryIndex;
  2312.     do
  2313.     {
  2314.         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_DUMP_HDLR, count, historyData[count].scrnID));
  2316.         if (count > MIN_HISTORY && count < MAX_HISTORY)
  2317.         {
  2318.             --count;
  2319.         }
  2320.         else
  2321.         {
  2322.             if (bRoundOffFlag)
  2323.             {
  2324.                 count = MAX_HISTORY - 1;
  2325.             }
  2326.             else
  2327.             {
  2328.                 break;
  2329.             }
  2330.         }
  2332.     } while ((count != currHistoryIndex) && (historyData[count].entryFuncPtr != NULL));
  2334.     SubLCDHistoryDump();
  2335. }
  2338. /*****************************************************************************
  2339.  * FUNCTION
  2340.  *  HistoryReplace
  2341.  * DESCRIPTION
  2342.  *  To replace a specific history
  2343.  *  
  2344.  *  HistoryReplace will be used for a exist history
  2345.  * PARAMETERS
  2346.  *  out_scrn_id     [IN]        
  2347.  *  in_scrn_id      [IN]        
  2348.  *  in_src_func     [IN]        
  2349.  * RETURNS
  2350.  *  pBool
  2351.  *****************************************************************************/
  2352. pBOOL HistoryReplace(U16 out_scrn_id, U16 in_scrn_id, FuncPtr in_src_func)
  2353. {
  2355.     /*----------------------------------------------------------------*/
  2356.     /* Local Variables                                                */
  2357.     /*----------------------------------------------------------------*/
  2358.     S16 count = 0;
  2360.     /*----------------------------------------------------------------*/
  2361.     /* Code Body                                                      */
  2362.     /*----------------------------------------------------------------*/
  2364.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_HIST_REPLACE_HDLR, out_scrn_id, in_scrn_id));
  2366.     for (count = 0; ((count < MAX_HISTORY) && ((count <= currHistoryIndex) && (currHistoryIndex != -1))); count++)
  2367.     {
  2368.         /* Find the matched source history and then to write into destinate history */
  2369.         if (historyData[count].scrnID == out_scrn_id)
  2370.         {
  2371.             ClearDelScrnIDCallbackHandler(out_scrn_id, NULL);
  2372.             historyData[count].scrnID = in_scrn_id;
  2373.             historyData[count].entryFuncPtr = in_src_func;
  2374.             mmi_free_history_buffer(count);
  2375.             return MMI_TRUE;
  2376.         }
  2377.     }
  2379.     return MMI_FALSE;
  2381. }
  2384. /*****************************************************************************
  2385.  * FUNCTION
  2386.  *  ExecutecurrHisIndEntryFunc
  2387.  * DESCRIPTION
  2388.  *  executes current history handles  Entry function
  2389.  *  
  2390.  *  This is used to executes current history handles  Entry function.
  2391.  * PARAMETERS
  2392.  *  void
  2393.  * RETURNS
  2394.  *  void
  2395.  *****************************************************************************/
  2396. void ExecutecurrHisIndEntryFunc(void)
  2397. {
  2398.     /*----------------------------------------------------------------*/
  2399.     /* Local Variables                                                */
  2400.     /*----------------------------------------------------------------*/
  2402.     /*----------------------------------------------------------------*/
  2403.     /* Code Body                                                      */
  2404.     /*----------------------------------------------------------------*/
  2405.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EXEC_CURR_HIST_HDLR));
  2406.     if (historyData[currHistoryIndex].entryFuncPtr)
  2407.     {
  2408.         (*(historyData[currHistoryIndex].entryFuncPtr)) ();
  2409.     }
  2410. }
  2413. /*****************************************************************************
  2414.  * FUNCTION
  2415.  *  DeleteNHistory
  2416.  * DESCRIPTION
  2417.  *  Deletes 'n' history nodes from current history index
  2418.  *  
  2419.  *  This shall pop 'n' history nodes without invoking
  2420.  *  entry functions of the deleted nodes
  2421.  * PARAMETERS
  2422.  *  DeleteCount     [IN]        
  2423.  * RETURNS
  2424.  *  void
  2425.  *****************************************************************************/
  2426. void DeleteNHistory(U16 DeleteCount)
  2427. {
  2428.     /*----------------------------------------------------------------*/
  2429.     /* Local Variables                                                */
  2430.     /*----------------------------------------------------------------*/
  2431.     S16 Index = 0;
  2432.     S16 Count = 0;
  2434.     /*----------------------------------------------------------------*/
  2435.     /* Code Body                                                      */
  2436.     /*----------------------------------------------------------------*/
  2438. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  2439.     if (redraw_in_small_screen_proceduer())
  2440.     {
  2441.         return ;
  2442.     }
  2443. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  2445.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_DEL_NHIST_HDLR, DeleteCount));
  2447.     if (bRoundOffFlag)
  2448.     {
  2449.         Index = MAX_HISTORY + currHistoryIndex;
  2450.     }
  2451.     else
  2452.     {
  2453.         Index = currHistoryIndex;
  2454.     }
  2456.     if (Index >= DeleteCount)
  2457.     {
  2458.         for (Count = DeleteCount; Count >= 1; --Count)
  2459.         {
  2460.             /* JL, if want to stop to run next decrement will return true. */
  2461.             if (decrement() == MMI_HIST_STOP_DELETING)
  2462.             {
  2463.                 /* We abort the process here and don't handle original requirement */
  2464.                 break;
  2465.             }
  2466.         }
  2467.     }
  2468. }
  2471. /*****************************************************************************
  2472.  * FUNCTION
  2473.  *  DeleteUptoScrID
  2474.  * DESCRIPTION
  2475.  *  Go to a screen and delete historyall ahead of it
  2476.  * PARAMETERS
  2477.  *  scrnid      [IN]        
  2478.  * RETURNS
  2479.  *  U8 - status
  2480.  *****************************************************************************/
  2481. U8 DeleteUptoScrID(U16 scrnid)
  2482. {
  2483.     /*----------------------------------------------------------------*/
  2484.     /* Local Variables                                                */
  2485.     /*----------------------------------------------------------------*/
  2486.     S16 count = 0;
  2487.     U8 Status = ST_FAILURE;
  2489.     /*----------------------------------------------------------------*/
  2490.     /* Code Body                                                      */
  2491.     /*----------------------------------------------------------------*/
  2493. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  2494.     if (redraw_in_small_screen_proceduer())
  2495.     {
  2496.         return ST_SUCCESS;
  2497.     }
  2498. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  2500.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_DEL_UPTO_SCRID_HDLR, scrnid, currHistoryIndex));
  2502.     count = currHistoryIndex;
  2504.     if (!IsScreenPresent(scrnid))
  2505.     {
  2506.         return ST_FAILURE;
  2507.     }
  2509.     do
  2510.     {
  2511.         if (historyData[currHistoryIndex].scrnID == scrnid)
  2512.         {
  2513.             Status = ST_SUCCESS;
  2514.             break;
  2515.         }
  2516.         /* JL, if want to stop to run next decrement will return true. */
  2517.         if (decrement() == MMI_HIST_STOP_DELETING)
  2518.         {
  2519.             /* We abort the process here and don't handle original requirement */
  2520.             Status = ST_SUCCESS;
  2521.             break;
  2522.         }
  2524.     } while ((count != currHistoryIndex) && (historyData[currHistoryIndex].entryFuncPtr != NULL));
  2525.     return Status;
  2526. }
  2529. /*****************************************************************************
  2530.  * FUNCTION
  2531.  *  DeleteNScrId
  2532.  * DESCRIPTION
  2533.  *  Deletes up to screen id and go  beyond it one node
  2534.  * PARAMETERS
  2535.  *  scrnid      [IN]        
  2536.  * RETURNS
  2537.  *  U8 - status
  2538.  *****************************************************************************/
  2539. U8 DeleteNScrId(U16 scrnid)
  2540. {
  2541.     /*----------------------------------------------------------------*/
  2542.     /* Local Variables                                                */
  2543.     /*----------------------------------------------------------------*/
  2544.     S16 count = 0;
  2545.     U8 Status = ST_FAILURE;
  2547.     /*----------------------------------------------------------------*/
  2548.     /* Code Body                                                      */
  2549.     /*----------------------------------------------------------------*/
  2551. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  2552.     if (redraw_in_small_screen_proceduer())
  2553.     {
  2554.         return ST_SUCCESS;
  2555.     }
  2556. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  2558.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_DEL_NSCRID_HDLR, scrnid, currHistoryIndex));
  2560.     count = currHistoryIndex;
  2562.     if (!IsScreenPresent(scrnid))
  2563.     {
  2564.         return ST_FAILURE;
  2565.     }
  2567.     do
  2568.     {
  2569.         if (historyData[currHistoryIndex].scrnID == scrnid)
  2570.         {
  2571.             Status = ST_SUCCESS;
  2572.             break;
  2573.         }
  2574.         /* JL, if want to stop to run next decrement will return true. */
  2575.         if (decrement() == MMI_HIST_STOP_DELETING)
  2576.         {
  2577.             /* We abort the process here and don't handle original requirement */
  2578.             Status = ST_FAILURE;
  2579.             break;
  2580.         }
  2582.     } while ((count != currHistoryIndex) && (historyData[currHistoryIndex].entryFuncPtr != NULL));
  2584.     if (Status)
  2585.     {
  2586.         decrement();
  2587.     }
  2588.     return ST_SUCCESS;
  2589. }
  2592. /*****************************************************************************
  2593.  * FUNCTION
  2594.  *  GoBeyondMarkerScr
  2595.  * DESCRIPTION
  2596.  *  Go one node beyond  marker screen
  2597.  * PARAMETERS
  2598.  *  scrnid      [IN]        
  2599.  * RETURNS
  2600.  *  U8 - status
  2601.  *****************************************************************************/
  2602. U8 GoBeyondMarkerScr(U16 scrnid)
  2603. {
  2604.     /*----------------------------------------------------------------*/
  2605.     /* Local Variables                                                */
  2606.     /*----------------------------------------------------------------*/
  2607.     S16 count = 0;
  2608.     U8 Status = ST_FAILURE;
  2610.     /*----------------------------------------------------------------*/
  2611.     /* Code Body                                                      */
  2612.     /*----------------------------------------------------------------*/
  2613. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  2614.     if (redraw_in_small_screen_proceduer())
  2615.     {
  2616.         return ST_SUCCESS;
  2617.     }
  2618. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  2620.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_GO_BEYOND_MARKER_SCR_HDLR, scrnid, currHistoryIndex));
  2622.     count = currHistoryIndex;
  2624.     if (!IsScreenPresent(scrnid))
  2625.     {
  2626.         return ST_FAILURE;
  2627.     }
  2629.     do
  2630.     {
  2631.         if (historyData[currHistoryIndex].scrnID == scrnid)
  2632.         {
  2633.             Status = ST_SUCCESS;
  2634.             break;
  2635.         }
  2636.         /* JL, if want to stop to run next decrement will return true. */
  2637.         if (decrement() == MMI_HIST_STOP_DELETING)
  2638.         {
  2639.             /* We abort the process here and don't handle original requirement */
  2640.             Status = ST_FAILURE;
  2641.             break;
  2642.         }
  2644.     } while ((count != currHistoryIndex) && (historyData[currHistoryIndex].entryFuncPtr != NULL));
  2646.     if (Status)
  2647.     {
  2648.         decrement();
  2649.     }
  2650.     ExecutePopHistory();
  2652.     return ST_SUCCESS;
  2653. }
  2657. /*****************************************************************************
  2658.  * FUNCTION
  2659.  *  IsScreenPresent
  2660.  * DESCRIPTION
  2661.  *  Queries history for presence of a screen Id
  2662.  * PARAMETERS
  2663.  *  scrnId          [IN]        
  2664.  * RETURNS
  2665.  *  pBOOL
  2666.  *****************************************************************************/
  2667. pBOOL IsScreenPresent(U16 scrnId)
  2668. {
  2669.     /*----------------------------------------------------------------*/
  2670.     /* Local Variables                                                */
  2671.     /*----------------------------------------------------------------*/
  2672.     S16 count;
  2674.     /*----------------------------------------------------------------*/
  2675.     /* Code Body                                                      */
  2676.     /*----------------------------------------------------------------*/
  2677.     for (count = 0; ((count < MAX_HISTORY) && ((count <= currHistoryIndex) && (currHistoryIndex != -1))); count++)
  2678.     {
  2679.         if (historyData[count].scrnID == scrnId)
  2680.         {
  2681.             MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_IS_SCR_PRESENT_HDLR, scrnId, MMI_TRUE));
  2682.             return MMI_TRUE;
  2683.         }
  2684.     }
  2685.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_IS_SCR_PRESENT_HDLR, scrnId, MMI_FALSE));
  2686.     return MMI_FALSE;
  2688. }
  2691. /*****************************************************************************
  2692.  * FUNCTION
  2693.  *  IsMainLCDHistoryBack
  2694.  * DESCRIPTION
  2695.  *  Queries MainLCD history is back now or not
  2696.  * PARAMETERS
  2697.  *  void
  2698.  * RETURNS
  2699.  *  pBOOL
  2700.  *****************************************************************************/
  2701. pBOOL IsMainLCDHistoryBack(void)
  2702. {
  2703.     /*----------------------------------------------------------------*/
  2704.     /* Local Variables                                                */
  2705.     /*----------------------------------------------------------------*/
  2707.     /*----------------------------------------------------------------*/
  2708.     /* Code Body                                                      */
  2709.     /*----------------------------------------------------------------*/
  2710.     return CheckMainLCDHistoryBack;
  2712. }
  2715. /*****************************************************************************
  2716.  * FUNCTION
  2717.  *  GetPreviousScrnIdOf
  2718.  * DESCRIPTION
  2719.  *  Queries previous scrn id of this Id
  2720.  * PARAMETERS
  2721.  *  scrnId              [IN]        
  2722.  *  previousScrnId      [OUT]         
  2723.  * RETURNS
  2724.  *  pBOOL
  2725.  *****************************************************************************/
  2726. pBOOL GetPreviousScrnIdOf(U16 scrnId, U16 *previousScrnId)
  2727. {
  2728.     /*----------------------------------------------------------------*/
  2729.     /* Local Variables                                                */
  2730.     /*----------------------------------------------------------------*/
  2731.     S16 count;
  2733.     /*----------------------------------------------------------------*/
  2734.     /* Code Body                                                      */
  2735.     /*----------------------------------------------------------------*/
  2736.     for (count = 0; ((count < MAX_HISTORY) && ((count <= currHistoryIndex) && (currHistoryIndex != -1))); count++)
  2737.     {
  2738.         if (historyData[count].scrnID == scrnId)
  2739.         {
  2740.             if ((count - 1) >= 0)
  2741.             {
  2742.                 *previousScrnId = historyData[count - 1].scrnID;
  2743.                 MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_GET_PREVIOUS_SCR_IDOF_HDLR, scrnId,
  2744.                            historyData[count - 1].scrnID));
  2745.                 return MMI_TRUE;
  2746.             }
  2747.             MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_GET_PREVIOUS_SCR_IDOF_2_HDLR, scrnId));
  2748.             return MMI_FALSE;
  2749.         }
  2750.     }
  2751.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_GET_PREVIOUS_SCR_IDOF_2_HDLR, scrnId));
  2752.     return MMI_FALSE;
  2753. }
  2756. /*****************************************************************************
  2757.  * FUNCTION
  2758.  *  GetNextScrnIdOf
  2759.  * DESCRIPTION
  2760.  *  Queries next scrn id of this Id
  2761.  * PARAMETERS
  2762.  *  scrnId          [IN]        
  2763.  *  nextScrnId      [OUT]         
  2764.  * RETURNS
  2765.  *  pBOOL
  2766.  *****************************************************************************/
  2767. pBOOL GetNextScrnIdOf(U16 scrnId, U16 *nextScrnId)
  2768. {
  2769.     /*----------------------------------------------------------------*/
  2770.     /* Local Variables                                                */
  2771.     /*----------------------------------------------------------------*/
  2772.     S16 count;
  2774.     /*----------------------------------------------------------------*/
  2775.     /* Code Body                                                      */
  2776.     /*----------------------------------------------------------------*/
  2777.     for (count = 0; ((count < MAX_HISTORY) && ((count <= currHistoryIndex) && (currHistoryIndex != -1))); count++)
  2778.     {
  2779.         if (historyData[count].scrnID == scrnId)
  2780.         {
  2781.             if ((count + 1) <= currHistoryIndex)
  2782.             {
  2783.                 *nextScrnId = historyData[count + 1].scrnID;
  2784.                 return MMI_TRUE;
  2785.             }
  2786.             return MMI_FALSE;
  2787.         }
  2788.     }
  2789.     return MMI_FALSE;
  2790. }
  2793. /*****************************************************************************
  2794.  * FUNCTION
  2795.  *  IsCurrMarkerScreen
  2796.  * DESCRIPTION
  2797.  *  Check if the current screen is  marker screen.
  2798.  * PARAMETERS
  2799.  *  scrnid      [IN]        
  2800.  * RETURNS
  2801.  *  U8
  2802.  *****************************************************************************/
  2803. U8 IsCurrMarkerScreen(U16 scrnid)
  2804. {
  2805.     /*----------------------------------------------------------------*/
  2806.     /* Local Variables                                                */
  2807.     /*----------------------------------------------------------------*/
  2809.     /*----------------------------------------------------------------*/
  2810.     /* Code Body                                                      */
  2811.     /*----------------------------------------------------------------*/
  2812.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_IS_CUR_MARKER_SCR_HDLR, scrnid, historyData[currHistoryIndex].scrnID));
  2813.     return (historyData[currHistoryIndex].scrnID == scrnid);
  2814. }
  2817. /*****************************************************************************
  2818.  * FUNCTION
  2819.  *  ExecuteRootMainHistoryScreen
  2820.  * DESCRIPTION
  2821.  *  To execute the root history screen.
  2822.  * PARAMETERS
  2823.  *  funcPtr     [IN]        Reserve not use
  2824.  * RETURNS
  2825.  *  U8
  2826.  *****************************************************************************/
  2827. U8 ExecuteRootMainHistoryScreen(void *funcPtr)
  2828. {
  2829.     /*----------------------------------------------------------------*/
  2830.     /* Local Variables                                                */
  2831.     /*----------------------------------------------------------------*/
  2832.     U8 Status = ST_SUCCESS;
  2833.     S16 count = currHistoryIndex;
  2835.     /*----------------------------------------------------------------*/
  2836.     /* Code Body                                                      */
  2837.     /*----------------------------------------------------------------*/
  2838.     /* reserve not decrement: Memory is not being released bcos of one particular case of keypad lock */
  2840. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  2841.     if (redraw_in_small_screen_proceduer())
  2842.     {
  2843.         return ST_SUCCESS;
  2844.     }
  2845. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  2847.     /* To make sure the callback will run at topist screen, and callback for APP */
  2848.     ExecTopScrnCallbackHandler();
  2849.     if (currHistoryIndex <= 0)
  2850.     {
  2851.         if (historyData[0].entryFuncPtr)
  2852.         {
  2853.             (*(historyData[0].entryFuncPtr)) ();
  2854.         }
  2855.         return ST_SUCCESS;
  2857.     }
  2859.     /* down popup all others history to callback for APP */
  2860.     bBackHistoryFlag = MMI_TRUE;
  2861.     do
  2862.     {
  2863.         if (count == 0)
  2864.         {
  2865.             Status = ST_SUCCESS;
  2866.             break;
  2867.         }
  2868.         if (count > 0)
  2869.         {
  2870.             if (ExecHistoryScrnCallBackHandle(count) == MMI_HIST_STOP_DELETING)
  2871.             {
  2872.                 Status = ST_FAILURE;
  2873.                 break;
  2874.             }
  2875.         }
  2876.         /* To make sure back to idle screen will be free the history */
  2877.         mmi_free_history_buffer(count);
  2879.         count--;
  2880.     } while ((historyData[count].entryFuncPtr != NULL) && (count > 0));
  2882.     currHistoryIndex = count;
  2883.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EXEC_ROOT_HIST_HDLR, currHistoryIndex, Status));
  2884.     
  2885.     IsBackHistory = MMI_TRUE;
  2886.     if (Status == ST_FAILURE)
  2887.     {
  2888.         #if 0 /* we may need to keep guiBuffer and inputBuffer */
  2889. /* under construction !*/
  2890. /* under construction !*/
  2891.         #endif
  2893.         /* entry itself */
  2894.         if (historyData[count].entryFuncPtr)
  2895.         {
  2896.             (*(historyData[count].entryFuncPtr)) ();
  2897.         }
  2898.         #if 0 /* We may not need to remove one more node */
  2899. /* under construction !*/
  2900. /* under construction !*/
  2901.         #endif
  2902.         decrement();
  2903.         #if 0
  2904. /* under construction !*/
  2905. /* under construction !*/
  2906. /* under construction !*/
  2907. /* under construction !*/
  2908. /* under construction !*/
  2909. /* under construction !*/
  2910. /* under construction !*/
  2911. /* under construction !*/
  2912. /* under construction !*/
  2913. /* under construction !*/
  2914. /* under construction !*/
  2915. /* under construction !*/
  2916. /* under construction !*/
  2917. /* under construction !*/
  2918. /* under construction !*/
  2919. /* under construction !*/
  2920. /* under construction !*/
  2921. /* under construction !*/
  2922. /* under construction !*/
  2923. /* under construction !*/
  2924. /* under construction !*/
  2925.         #endif
  2927.     }
  2928.     else
  2929.     {
  2930.         if (historyData[currHistoryIndex].entryFuncPtr)
  2931.         {
  2932.             (*(historyData[currHistoryIndex].entryFuncPtr)) ();
  2933.         }
  2934.     }
  2935.     bBackHistoryFlag = MMI_FALSE;
  2936.     IsBackHistory = MMI_FALSE;
  2938.     return Status;
  2939. }
  2942. /*****************************************************************************
  2943.  * FUNCTION
  2944.  *  DinitHistory
  2945.  * DESCRIPTION
  2946.  *  Free the history node
  2947.  * PARAMETERS
  2948.  *  void
  2949.  * RETURNS
  2950.  *  void
  2951.  *****************************************************************************/
  2952. void DinitHistory(void)
  2953. {
  2955.     /*----------------------------------------------------------------*/
  2956.     /* Local Variables                                                */
  2957.     /*----------------------------------------------------------------*/
  2958.     U16 count = 0;
  2960.     /*----------------------------------------------------------------*/
  2961.     /* Code Body                                                      */
  2962.     /*----------------------------------------------------------------*/
  2963. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  2964.     if (redraw_in_small_screen_proceduer())
  2965.     {
  2966.         return;
  2967.     }
  2968. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  2970.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_DINIT_HIST_HDLR));
  2972.     if (currHistoryIndex > 0)
  2973.     {
  2974.         for (count = currHistoryIndex; count > 0; --count)
  2975.         {
  2976.             mmi_free_history_buffer(count);
  2977.             memset(&historyData[count], 0, sizeof(historyNode));
  2979.         }
  2981.     }
  2983.     /*
  2984.      * Free historyData[0] memory:
  2985.      * Here can't use mmi_free_history_buffer() 
  2986.      * because currHistoryIndex may be -1 in ExecutePopHistory and then
  2987.      * invoke DinitHistory() in EntryIdleScreen()
  2988.      */
  2989.     if (historyData[0].guiBuffer)
  2990.     {
  2991.         OslMfree(historyData[0].guiBuffer);
  2992.     }
  2993.     if (historyData[0].inputBuffer)
  2994.     {
  2995.         OslMfree(historyData[0].inputBuffer);
  2996.     }
  2998.     memset(&historyData[0], 0, sizeof(historyData));
  2999.     currHistoryIndex = -1;
  3000. }
  3003. /*****************************************************************************
  3004.  * FUNCTION
  3005.  *  SetDelScrnIDCallbackHandler
  3006.  * DESCRIPTION
  3007.  *  Register callback fucntion for delete screen occur.
  3008.  * PARAMETERS
  3009.  *  ScrnID      [IN]        
  3010.  *  funcPtr     [IN]        
  3011.  * RETURNS
  3012.  *  U8 - status
  3013.  *****************************************************************************/
  3014. U8 SetDelScrnIDCallbackHandler(U16 ScrnID, HistoryDelCBPtr funcPtr)
  3015. {
  3016.     /*----------------------------------------------------------------*/
  3017.     /* Local Variables                                                */
  3018.     /*----------------------------------------------------------------*/
  3019.     U16 count;
  3021.     /*----------------------------------------------------------------*/
  3022.     /* Code Body                                                      */
  3023.     /*----------------------------------------------------------------*/
  3025.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SET_SCREEN_ID_CB_HDLR, ScrnID, funcPtr));
  3027.     /* MTK added by JL for history callback */
  3028.     for (count = 0; count < MAX_HISTORY; count++)
  3029.     {
  3030.         /* add new one, while scrnID and historydelCBPtr is NULL, means not found we can add a new one. */
  3031.         if ((historyCBHandler[count].scrnID == 0) && (historyCBHandler[count].historydelCBPtr == NULL))
  3032.         {
  3033.             historyCBHandler[count].scrnID = ScrnID;
  3034.             historyCBHandler[count].historydelCBPtr = funcPtr;
  3035.             return MMI_TRUE;
  3036.         }
  3038.         /* already exist, to overwrite, while ScrnID and funcPtr are not NULL, and fount ScrnID. */
  3039.         /*
  3040.          * Leo remove, each screen can only have one callback.
  3041.          * if ( (historyCBHandler[count].scrnID == ScrnID) && (historyCBHandler[count].historydelCBPtr != NULL) )
  3042.          */
  3043.         if (historyCBHandler[count].scrnID == ScrnID)
  3044.         {
  3045.             historyCBHandler[count].historydelCBPtr = funcPtr;
  3046.             return MMI_TRUE;
  3047.         }
  3049.     }
  3051.     MMI_ASSERT(MMI_FALSE);
  3053.     return MMI_FALSE;
  3055. }
  3058. /*****************************************************************************
  3059.  * FUNCTION
  3060.  *  ClearDelScrnIDCallbackHandler
  3061.  * DESCRIPTION
  3062.  *  Clear callback fucntion for delete screen occur.
  3063.  * PARAMETERS
  3064.  *  ScrnID      [IN]        
  3065.  *  funcPtr     [IN]        
  3066.  * RETURNS
  3067.  *  U8 - status
  3068.  *****************************************************************************/
  3069. U8 ClearDelScrnIDCallbackHandler(U16 ScrnID, HistoryDelCBPtr funcPtr)
  3070. {
  3071.     /*----------------------------------------------------------------*/
  3072.     /* Local Variables                                                */
  3073.     /*----------------------------------------------------------------*/
  3074.     U16 count, found_idx;
  3076.     /*----------------------------------------------------------------*/
  3077.     /* Code Body                                                      */
  3078.     /*----------------------------------------------------------------*/
  3080.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_CLR_SCREEN_ID_CB_HDLR, ScrnID, funcPtr));
  3082.     /* MTK added by JL for history callback */
  3083.     for (count = 0; count < MAX_HISTORY; count++)
  3084.     {
  3085.         /* found the delete one. */
  3086.         if (historyCBHandler[count].scrnID == ScrnID)
  3087.         {
  3088.             break;
  3089.         }
  3090.     }
  3092.     for (found_idx = count; found_idx < MAX_HISTORY - 1; found_idx++)
  3093.     {
  3094.         historyCBHandler[found_idx].scrnID = historyCBHandler[found_idx + 1].scrnID;
  3095.         historyCBHandler[found_idx].historydelCBPtr = historyCBHandler[found_idx + 1].historydelCBPtr;
  3096.     }
  3097.     /* set the last one. */
  3098.     historyCBHandler[MAX_HISTORY - 1].scrnID = 0;
  3099.     historyCBHandler[MAX_HISTORY - 1].historydelCBPtr = NULL;
  3101.     return 0;
  3102. }
  3105. /*****************************************************************************
  3106.  * FUNCTION
  3107.  *  SearchDelScrnIDCallbackHandler
  3108.  * DESCRIPTION
  3109.  *  Search index of the delete callback screen.
  3110.  * PARAMETERS
  3111.  *  ScrnID          [IN]        
  3112.  *  found_idx       [OUT]        
  3113.  * RETURNS
  3114.  *  U8 - status
  3115.  *****************************************************************************/
  3116. static U8 SearchDelScrnIDCallbackHandler(U16 ScrnID, U16 *found_idx)
  3117. {
  3118.     /*----------------------------------------------------------------*/
  3119.     /* Local Variables                                                */
  3120.     /*----------------------------------------------------------------*/
  3121.     U16 count;
  3123.     /*----------------------------------------------------------------*/
  3124.     /* Code Body                                                      */
  3125.     /*----------------------------------------------------------------*/
  3127. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  3128.     if (redraw_in_small_screen_proceduer())
  3129.     {
  3130.         return MMI_FALSE;
  3131.     }
  3132. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  3134.     for (count = 0; count < MAX_HISTORY; count++)
  3135.     {
  3136.         /* found the delete one. */
  3137.         if (historyCBHandler[count].scrnID == ScrnID)
  3138.         {
  3139.             MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SRCH_DEL_SCRN_CB_HDLR, ScrnID, count));
  3141.             *found_idx = count;
  3142.             return MMI_TRUE;
  3143.         }
  3144.     }
  3146.     return MMI_FALSE;
  3148. }
  3151. /*****************************************************************************
  3152.  * FUNCTION
  3153.  *  ExecTopScrnCallbackHandler
  3154.  * DESCRIPTION
  3155.  *  Check if topist view screen exist in delete screen will be callback.
  3156.  * PARAMETERS
  3157.  *  void
  3158.  * RETURNS
  3159.  *  U8 - status
  3160.  *****************************************************************************/
  3161. static U8 ExecTopScrnCallbackHandler(void)
  3162. {
  3163.     /*----------------------------------------------------------------*/
  3164.     /* Local Variables                                                */
  3165.     /*----------------------------------------------------------------*/
  3167.     /*----------------------------------------------------------------*/
  3168.     /* Code Body                                                      */
  3169.     /*----------------------------------------------------------------*/
  3170.     return ExecTopScrnCallbackHandler_ex(1);
  3171. }
  3174. /*****************************************************************************
  3175.  * FUNCTION
  3176.  *  ExecTopScrnCallbackHandler_ex
  3177.  * DESCRIPTION
  3178.  *  
  3179.  * PARAMETERS
  3180.  *  is_main_hist        [IN]        
  3181.  * RETURNS
  3182.  *  
  3183.  *****************************************************************************/
  3184. U8 ExecTopScrnCallbackHandler_ex(U8 is_main_hist)
  3185. {
  3186.     /*----------------------------------------------------------------*/
  3187.     /* Local Variables                                                */
  3188.     /*----------------------------------------------------------------*/
  3189.     U8 is_stop_delete = MMI_FALSE;
  3190.     U16 cb_history_index;
  3191.     U16 scrnID;
  3193.     /*----------------------------------------------------------------*/
  3194.     /* Code Body                                                      */
  3195.     /*----------------------------------------------------------------*/
  3197.     if (is_main_hist)
  3198.     {
  3199.         scrnID = GetExitScrnID();
  3200.     }
  3201.     else
  3202.     {
  3203.         scrnID = GetSubLCDExitScrnId();
  3204.     }
  3206.     if (SearchDelScrnIDCallbackHandler(scrnID, &cb_history_index))
  3207.     {
  3208.         if (historyCBHandler[cb_history_index].historydelCBPtr)
  3209.         {
  3210.             is_stop_delete = historyCBHandler[cb_history_index].historydelCBPtr((void*)MMI_HIST_EXIT_SCREEN_TYPE);
  3211.         }
  3213.         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EXEC_TOP_SCRN_CB_HDLR, is_stop_delete));
  3215.         ClearDelScrnIDCallbackHandler(historyCBHandler[cb_history_index].scrnID, NULL);
  3216.     }
  3218.     return is_stop_delete;
  3219. }
  3222. /*****************************************************************************
  3223.  * FUNCTION
  3224.  *  ExecHistoryScrnCallBackHandle
  3225.  * DESCRIPTION
  3226.  *  Check if the history screen exist in delete screen will be callback.
  3227.  * PARAMETERS
  3228.  *  HistoryIndex        [IN]        
  3229.  * RETURNS
  3230.  *  U8 - status
  3231.  *****************************************************************************/
  3232. static U8 ExecHistoryScrnCallBackHandle(U16 HistoryIndex)
  3233. {
  3234.     /*----------------------------------------------------------------*/
  3235.     /* Local Variables                                                */
  3236.     /*----------------------------------------------------------------*/
  3238.     /*----------------------------------------------------------------*/
  3239.     /* Code Body                                                      */
  3240.     /*----------------------------------------------------------------*/
  3241.     return ExecHistoryScrnCallBackHandle_ex(HistoryIndex, 1);
  3242. }
  3245. /*****************************************************************************
  3246.  * FUNCTION
  3247.  *  ExecHistoryScrnCallBackHandle_ex
  3248.  * DESCRIPTION
  3249.  *  
  3250.  * PARAMETERS
  3251.  *  HistoryIndex        [IN]        
  3252.  *  is_main_hist        [IN]        
  3253.  * RETURNS
  3254.  *  
  3255.  *****************************************************************************/
  3256. U8 ExecHistoryScrnCallBackHandle_ex(U16 HistoryIndex, U8 is_main_hist)
  3257. {
  3258.     /*----------------------------------------------------------------*/
  3259.     /* Local Variables                                                */
  3260.     /*----------------------------------------------------------------*/
  3261.     /* Not support for stop callback at this funciton */
  3262.     U16 cb_history_index;
  3263.     U16 scrnID;
  3264.     U8 is_stop_allow = MMI_FALSE;
  3266.     /*----------------------------------------------------------------*/
  3267.     /* Code Body                                                      */
  3268.     /*----------------------------------------------------------------*/
  3270.     if (is_main_hist)
  3271.     {
  3272.         /* main LCD history */
  3273.         scrnID = historyData[HistoryIndex].scrnID;
  3274.     }
  3275.     else
  3276.     {
  3277.         /* sub LCD history */
  3278.         scrnID = GetSubLCDScrnId(HistoryIndex);
  3279.     }
  3281.     if (SearchDelScrnIDCallbackHandler(scrnID, &cb_history_index))
  3282.     {
  3283.         if (historyCBHandler[cb_history_index].historydelCBPtr)
  3284.         {
  3285.             is_stop_allow = historyCBHandler[cb_history_index].historydelCBPtr((void*)MMI_HIST_DELETE_SCREEN_TYPE);
  3286.         }
  3287.         ClearDelScrnIDCallbackHandler(historyCBHandler[cb_history_index].scrnID, NULL);
  3288.     }
  3290.     if (is_stop_allow == MMI_TRUE)
  3291.     {
  3292.         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EXEC_HIST_SCRN_CB_HDLR, HistoryIndex));
  3293.     }
  3295.     return is_stop_allow;
  3296. }
  3299. /*****************************************************************************
  3300.  * FUNCTION
  3301.  *  set_small_screen
  3302.  * DESCRIPTION
  3303.  *  Called by category to tell history that the screen being drawn is small.
  3304.  * PARAMETERS
  3305.  *  void
  3306.  * RETURNS
  3307.  *  void
  3308.  *****************************************************************************/
  3309. void set_small_screen(void)
  3310. {
  3311. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  3312.     /*----------------------------------------------------------------*/
  3313.     /* Local Variables                                                */
  3314.     /*----------------------------------------------------------------*/
  3316.     /*----------------------------------------------------------------*/
  3317.     /* Code Body                                                      */
  3318.     /*----------------------------------------------------------------*/
  3319.     if (no_small_screen)
  3320.     {
  3321.         return;
  3322.     }
  3324.     if (currHistoryIndex == -1)
  3325.     {
  3326.         clear_screen();
  3327.     }
  3328.     small_history_node = 1;
  3329. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  3330. }
  3333. /*****************************************************************************
  3334.  * FUNCTION
  3335.  *  mmi_is_redrawing_bk_screens
  3336.  * DESCRIPTION
  3337.  *  
  3338.  * PARAMETERS
  3339.  *  void
  3340.  * RETURNS
  3341.  *  
  3342.  *****************************************************************************/
  3343. S32 mmi_is_redrawing_bk_screens()
  3344. {
  3345. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  3346.     /*----------------------------------------------------------------*/
  3347.     /* Local Variables                                                */
  3348.     /*----------------------------------------------------------------*/
  3350.     /*----------------------------------------------------------------*/
  3351.     /* Code Body                                                      */
  3352.     /*----------------------------------------------------------------*/
  3353.     if (mmi_execute_scrn_exit_func())
  3354.     {
  3355.         if (redrawing_old_screens == MMI_HIST_SMALLSCREEN_ACTIVE ||
  3356.             redrawing_old_screens == MMI_HIST_SMALLSCREEN_ACTIVE_IN_EXIT_FUNC)
  3357.         {
  3358.             return 1;
  3359.         }
  3360.         else
  3361.         {
  3362.             return 0;
  3363.         }
  3364.     }
  3365.     else
  3366.     {
  3367.         return (redrawing_old_screens == MMI_HIST_SMALLSCREEN_ACTIVE) ? 1 : 0;
  3368.     }
  3369. #else /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  3370.     return 0;
  3371. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  3372. }
  3375. /*****************************************************************************
  3376.  * FUNCTION
  3377.  *  is_redrawing_old_screens
  3378.  * DESCRIPTION
  3379.  *  
  3380.  * PARAMETERS
  3381.  *  void
  3382.  * RETURNS
  3383.  *  
  3384.  *****************************************************************************/
  3385. S32 is_redrawing_old_screens()
  3386. {
  3387.     /*----------------------------------------------------------------*/
  3388.     /* Local Variables                                                */
  3389.     /*----------------------------------------------------------------*/
  3391.     /*----------------------------------------------------------------*/
  3392.     /* Code Body                                                      */
  3393.     /*----------------------------------------------------------------*/
  3394.     return mmi_is_redrawing_bk_screens();
  3395. }
  3398. /*****************************************************************************
  3399.  * FUNCTION
  3400.  *  reset_small_screen
  3401.  * DESCRIPTION
  3402.  *  Called by category to tell history that it is exiting from small screen.
  3403.  * PARAMETERS
  3404.  *  void
  3405.  * RETURNS
  3406.  *  void
  3407.  *****************************************************************************/
  3408. void reset_small_screen(void)
  3409. {
  3410. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  3411.     /*----------------------------------------------------------------*/
  3412.     /* Local Variables                                                */
  3413.     /*----------------------------------------------------------------*/
  3415.     /*----------------------------------------------------------------*/
  3416.     /* Code Body                                                      */
  3417.     /*----------------------------------------------------------------*/
  3418.     small_history_node = 0;
  3419.     no_small_screen = 0;
  3420. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  3421. }
  3424. /*****************************************************************************
  3425.  * FUNCTION
  3426.  *  restore_small_screen
  3427.  * DESCRIPTION
  3428.  *  Restores small screen
  3429.  * PARAMETERS
  3430.  *  void
  3431.  * RETURNS
  3432.  *  void
  3433.  *****************************************************************************/
  3434. void restore_small_screen(void)
  3435. {
  3436.     /*----------------------------------------------------------------*/
  3437.     /* Local Variables                                                */
  3438.     /*----------------------------------------------------------------*/
  3440.     /*----------------------------------------------------------------*/
  3441.     /* Code Body                                                      */
  3442.     /*----------------------------------------------------------------*/
  3443. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  3444.     no_small_screen = 0;
  3445. #endif 
  3446. }
  3449. /*****************************************************************************
  3450.  * FUNCTION
  3451.  *  force_no_small_screen
  3452.  * DESCRIPTION
  3453.  *  Called by Application to disable small screen history saving.
  3454.  * PARAMETERS
  3455.  *  void
  3456.  * RETURNS
  3457.  *  void
  3458.  *****************************************************************************/
  3459. void force_no_small_screen(void)
  3460. {
  3461.     /*----------------------------------------------------------------*/
  3462.     /* Local Variables                                                */
  3463.     /*----------------------------------------------------------------*/
  3465.     /*----------------------------------------------------------------*/
  3466.     /* Code Body                                                      */
  3467.     /*----------------------------------------------------------------*/
  3468. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  3469.     no_small_screen = 1;
  3470. #endif 
  3471. }
  3474. /*****************************************************************************
  3475.  * FUNCTION
  3476.  *  redraw_in_small_screen_proceduer
  3477.  * DESCRIPTION
  3478.  *  Check if in small screen procedure
  3479.  * PARAMETERS
  3480.  *  void
  3481.  * RETURNS
  3482.  *  if in small screen procedure
  3483.  *****************************************************************************/
  3484. MMI_BOOL redraw_in_small_screen_proceduer(void)
  3485. {
  3486.     /*----------------------------------------------------------------*/
  3487.     /* Local Variables                                                */
  3488.     /*----------------------------------------------------------------*/
  3490.     /*----------------------------------------------------------------*/
  3491.     /* Code Body                                                      */
  3492.     /*----------------------------------------------------------------*/
  3493.     if (is_redrawing_old_screens())
  3494.     {
  3495.         return MMI_TRUE;
  3496.     }
  3497.     return MMI_FALSE;
  3498. }
  3500. /* 
  3501.  * enable_resized_small_screen(), disable_resized_small_screen(), and whether_no_small_screen()
  3502.  * There is no relation with small screen process in history.
  3503.  * It's only used for tha WGUI and application and decide to 
  3504.  * show the small screen or the normal screen.
  3505.  */
  3508. /*****************************************************************************
  3509.  * FUNCTION
  3510.  *  enable_resized_small_screen
  3511.  * DESCRIPTION
  3512.  *  Called by application to enable the small screen.
  3513.  * PARAMETERS
  3514.  *  void
  3515.  * RETURNS
  3516.  *  void
  3517.  *****************************************************************************/
  3518. void enable_resized_small_screen(void)
  3519. {
  3520.     /*----------------------------------------------------------------*/
  3521.     /* Local Variables                                                */
  3522.     /*----------------------------------------------------------------*/
  3524.     /*----------------------------------------------------------------*/
  3525.     /* Code Body                                                      */
  3526.     /*----------------------------------------------------------------*/
  3527. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  3528.     small_screen_enabled = 1;
  3529. #endif 
  3530. }
  3533. /*****************************************************************************
  3534.  * FUNCTION
  3535.  *  disable_resized_small_screen
  3536.  * DESCRIPTION
  3537.  *  Called on exiting the small screen.
  3538.  * PARAMETERS
  3539.  *  void
  3540.  * RETURNS
  3541.  *  void
  3542.  *****************************************************************************/
  3543. void disable_resized_small_screen(void)
  3544. {
  3545.     /*----------------------------------------------------------------*/
  3546.     /* Local Variables                                                */
  3547.     /*----------------------------------------------------------------*/
  3549.     /*----------------------------------------------------------------*/
  3550.     /* Code Body                                                      */
  3551.     /*----------------------------------------------------------------*/
  3552. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  3553.     small_screen_enabled = 0;
  3554. #endif 
  3555. }
  3558. /*****************************************************************************
  3559.  * FUNCTION
  3560.  *  whether_no_small_screen
  3561.  * DESCRIPTION
  3562.  *  Tells whether small screen is enabled or not
  3563.  * PARAMETERS
  3564.  *  void
  3565.  * RETURNS
  3566.  *  void
  3567.  *****************************************************************************/
  3568. S32 whether_no_small_screen(void)
  3569. {
  3570. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  3571.     /*----------------------------------------------------------------*/
  3572.     /* Local Variables                                                */
  3573.     /*----------------------------------------------------------------*/
  3575.     /*----------------------------------------------------------------*/
  3576.     /* Code Body                                                      */
  3577.     /*----------------------------------------------------------------*/
  3578.     return small_screen_enabled;
  3579. #else /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  3580.     return 0;
  3581. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  3582. }
  3586. #ifdef __MMI_UI_TAB_PANE__
  3589. /*****************************************************************************
  3590.  * FUNCTION
  3591.  *  disable_history_saving
  3592.  * DESCRIPTION
  3593.  *  Disable history saving
  3594.  * PARAMETERS
  3595.  *  void
  3596.  * RETURNS
  3597.  *  void
  3598.  *****************************************************************************/
  3599. void disable_history_saving(void)
  3600. {
  3601.     /*----------------------------------------------------------------*/
  3602.     /* Local Variables                                                */
  3603.     /*----------------------------------------------------------------*/
  3605.     /*----------------------------------------------------------------*/
  3606.     /* Code Body                                                      */
  3607.     /*----------------------------------------------------------------*/
  3608.     disable_history_save = 1;
  3609. }
  3612. /*****************************************************************************
  3613.  * FUNCTION
  3614.  *  enable_history_saving
  3615.  * DESCRIPTION
  3616.  *  Enables history saving
  3617.  * PARAMETERS
  3618.  *  void
  3619.  * RETURNS
  3620.  *  void
  3621.  *****************************************************************************/
  3622. void enable_history_saving(void)
  3623. {
  3624.     /*----------------------------------------------------------------*/
  3625.     /* Local Variables                                                */
  3626.     /*----------------------------------------------------------------*/
  3628.     /*----------------------------------------------------------------*/
  3629.     /* Code Body                                                      */
  3630.     /*----------------------------------------------------------------*/
  3631.     disable_history_save = 0;
  3632. }
  3635. /*****************************************************************************
  3636.  * FUNCTION
  3637.  *  change_curr_gui_buffer
  3638.  * DESCRIPTION
  3639.  *  Changes the current gui buffer of the current screen
  3640.  *  
  3641.  *  This is used by tab pane as as tab pane history is on top of the screen.
  3642.  * PARAMETERS
  3643.  *  gui_buffer      [IN]     
  3644.  * RETURNS
  3645.  *  void
  3646.  *****************************************************************************/
  3647. void change_curr_gui_buffer(U8 *gui_buffer)
  3648. {
  3649.     /*----------------------------------------------------------------*/
  3650.     /* Local Variables                                                */
  3651.     /*----------------------------------------------------------------*/
  3653.     /*----------------------------------------------------------------*/
  3654.     /* Code Body                                                      */
  3655.     /*----------------------------------------------------------------*/
  3656.     memcpy(historyData[currHistoryIndex].guiBuffer, gui_buffer, MAX_GUI_BUFFER);
  3657. }
  3658. #endif /* __MMI_UI_TAB_PANE__ */