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

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

MTK

开发平台：

C/C++

SubLCDHistory.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.  *
  38.  * Filename:
  39.  * ---------
  40.  * SubLCDHistory.c
  41.  *
  42.  * Project:
  43.  * --------
  44.  *   MAUI
  45.  *
  46.  * Description:
  47.  * ------------
  48.  *   This file is intends for sublcd history control
  49.  *
  50.  * Author:
  51.  * -------
  52.  * -------
  53.  *
  54.  *============================================================================
  55.  *             HISTORY
  56.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  57.  *------------------------------------------------------------------------------
  58.  * removed!
  59.  *
  60.  * removed!
  61.  * removed!
  62.  * removed!
  63.  *
  64.  * removed!
  65.  * removed!
  66.  * removed!
  67.  *
  68.  * removed!
  69.  * removed!
  70.  * removed!
  71.  *
  72.  * removed!
  73.  * removed!
  74.  * removed!
  75.  *
  76.  * removed!
  77.  * removed!
  78.  * removed!
  79.  *
  80.  * removed!
  81.  * removed!
  82.  * removed!
  83.  *
  84.  * removed!
  85.  * removed!
  86.  * removed!
  87.  *
  88.  * removed!
  89.  * removed!
  90.  * removed!
  91.  *
  92.  * removed!
  93.  * removed!
  94.  * removed!
  95.  *
  96.  * removed!
  97.  * removed!
  98.  * removed!
  99.  *
  100.  * removed!
  101.  * removed!
  102.  * removed!
  103.  *
  104.  * removed!
  105.  * removed!
  106.  * removed!
  107.  *
  108.  * removed!
  109.  * removed!
  110.  * removed!
  111.  *
  112.  * removed!
  113.  * removed!
  114.  * removed!
  115.  *
  116.  * removed!
  117.  * removed!
  118.  * removed!
  119.  * removed!
  120.  * removed!
  121.  * removed!
  122.  * removed!
  123.  * removed!
  124.  * removed!
  125.  * removed!
  126.  * removed!
  127.  * removed!
  128.  * removed!
  129.  * removed!
  130.  * removed!
  131.  * removed!
  132.  * removed!
  133.  * removed!
  134.  * removed!
  135.  * removed!
  136.  * removed!
  137.  *
  138.  * removed!
  139.  * removed!
  140.  * removed!
  141.  *
  142.  * removed!
  143.  * removed!
  144.  * removed!
  145.  *
  146.  * removed!
  147.  * removed!
  148.  * removed!
  149.  *
  150.  * removed!
  151.  * removed!
  152.  * removed!
  153.  *
  154.  * removed!
  155.  * removed!
  156.  * removed!
  157.  *
  158.  * removed!
  159.  * removed!
  160.  * removed!
  161.  *
  162.  * removed!
  163.  * removed!
  164.  * removed!
  165.  *
  166.  * removed!
  167.  * removed!
  168.  * removed!
  169.  *
  170.  * removed!
  171.  * removed!
  172.  * removed!
  173.  *
  174.  * removed!
  175.  * removed!
  176.  * removed!
  177.  *
  178.  * removed!
  179.  * removed!
  180.  * removed!
  181.  *
  182.  *------------------------------------------------------------------------------
  183.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  184.  *============================================================================
  185.  ****************************************************************************/
  186. /**
  187.  * Copyright Notice
  188.  * ?2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  189.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  190.  *  (It is illegal to remove this copyright notice from this software or any
  191.  *  portion of it)
  192.  */
  194. /**************************************************************
  196.    FILENAME : SubLCDHistory.c
  198.    PURPOSE     : Implementation of Sub-LCD history stack
  200.    REMARKS     : nil
  202.    AUTHOR      : Deepali
  204.    DATE     : Sept 23, 2003
  206. **************************************************************/
  208. #include "MMI_features.h"
  209. #include "stdC.h"
  210. #include "L4Dr1.h"
  211. #include "PixtelDataTypes.h"
  212. #include "DebugInitDef.h"
  213. #include "FrameworkStruct.h"
  214. #include "HistoryGprot.h"
  215. #include "HistoryDcl.h"
  216. #include "SubLCDHistoryDef.h"
  217. #include "SubLCDHistoryGprot.h"
  218. #include "Unicodexdcl.h"
  219. #include "l4dr.h"
  220. #include "MMI_trc.h"
  222. #define SUB_LCD_DUMMY_SCRNID     (0x9999)
  224. /* 
  225.  *   Extern Varibales 
  226.  */
  228. /* 
  229.  *   Local Variables 
  230.  */
  231. #ifdef __MMI_SUBLCD__
  232. static SubLCDHistoryInternalNode SubLCDHistoryData[MAX_SUBLCD_HISTORY]; /* array of history data */
  233. static pBOOL IsBackSubLCDHistory = FALSE;
  234. static signed char NodeIndex = -1;
  235. static U16 gCurrTopSubLCDScrnID = 0;
  236. static U16 gCurrExitSubLCDScrnID = 0;
  237. static FuncPtr gCurrExitSubLCDFn = NULL;
  238. static FuncPtr gCurrEntrySubLCDFn = NULL;
  239. static SubLcdHistoryCBPtr ExecuteRootSubLcdHistoryScreenPtr = NULL;
  241. #ifdef __MMI_UI_TAB_PANE__
  242. S32 disable_subLCD_history_save = 0;
  243. #endif 
  245. #endif /* __MMI_SUBLCD__ */ 
  248. /*****************************************************************************
  249.  * FUNCTION
  250.  *  ExecSubLCDCurrExitHandler
  251.  * DESCRIPTION
  252.  *  Execute the Current Exit handler of SubLCD
  253.  * PARAMETERS
  254.  *  void
  255.  * RETURNS
  256.  *  void
  257.  *****************************************************************************/
  258. void ExecSubLCDCurrExitHandler(void)
  259. {
  260. #ifdef __MMI_SUBLCD__
  261.     /*----------------------------------------------------------------*/
  262.     /* Local Variables                                                */
  263.     /*----------------------------------------------------------------*/
  265.     /*----------------------------------------------------------------*/
  266.     /* Code Body                                                      */
  267.     /*----------------------------------------------------------------*/
  269.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_EXE_SUBLCD_CUR_EXIT_HDLR));
  271.     /*
  272.      * When goback history in subLCD, we should execute current exit handler but
  273.      * not allow to add the history.
  274.      */
  275.     if (gCurrExitSubLCDFn != NULL)
  276.     {
  277.         gCurrExitSubLCDFn();
  278.         gCurrExitSubLCDFn = NULL;
  279.     }
  280.     IsBackSubLCDHistory = FALSE;
  281. #endif /* __MMI_SUBLCD__ */ 
  282. }
  285. /*****************************************************************************
  286.  * FUNCTION
  287.  *  AddSubLCDHistory
  288.  * DESCRIPTION
  289.  *  Saves Sublcd function in History
  290.  * PARAMETERS
  291.  *  CurrSubLCDHistory       [IN]        
  292.  * RETURNS
  293.  *  void
  294.  *****************************************************************************/
  295. void AddSubLCDHistory(SubLCDHistoryNode *CurrSubLCDHistory)
  296. {
  297. #ifdef __MMI_SUBLCD__
  298.     /*----------------------------------------------------------------*/
  299.     /* Local Variables                                                */
  300.     /*----------------------------------------------------------------*/
  302.     /*----------------------------------------------------------------*/
  303.     /* Code Body                                                      */
  304.     /*----------------------------------------------------------------*/
  305. #ifdef __MMI_UI_TAB_PANE__
  306.     if (disable_subLCD_history_save)
  307.     {
  308.         return;
  309.     }
  310. #endif /* __MMI_UI_TAB_PANE__ */ 
  312. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  313.     if (redraw_in_small_screen_proceduer())
  314.     {
  315.         return;
  316.     }
  317. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  319.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_ADD_SUBLCD_HIST_HDLR));
  321.     /* MTK added by JL for back history. */
  322.     if (IsBackSubLCDHistory != TRUE)
  323.     {
  324.         FuncPtr CurrSubLCDEntryFn = CurrSubLCDHistory->entryFuncPtr;
  326.         if (CurrSubLCDEntryFn != NULL)
  327.         {
  328.             SubLCDHistoryData[++NodeIndex].entryFuncPtr = CurrSubLCDEntryFn;
  329.             SubLCDHistoryData[NodeIndex].scrnID = SUB_LCD_DUMMY_SCRNID;
  330.             SubLCDHistoryData[NodeIndex].guiLen = 0;
  331.             SubLCDHistoryData[NodeIndex].guiBuffer = NULL;
  332.         }
  333.     }
  334.     IsBackSubLCDHistory = FALSE;
  335. #endif /* __MMI_SUBLCD__ */ 
  336. }
  339. /*****************************************************************************
  340.  * FUNCTION
  341.  *  AddSubLCDHistoryWithScrID
  342.  * DESCRIPTION
  343.  *  Saves Sublcd function in History with ScrID
  344.  * PARAMETERS
  345.  *  CurrSubLCDHistory       [IN]        
  346.  *  scrID                   [IN]        
  347.  * RETURNS
  348.  *  void
  349.  *****************************************************************************/
  350. void AddSubLCDHistoryWithScrID(SubLCDHistoryNode *CurrSubLCDHistory, U16 scrID)
  351. {
  352. #ifdef __MMI_SUBLCD__
  353.     /*----------------------------------------------------------------*/
  354.     /* Local Variables                                                */
  355.     /*----------------------------------------------------------------*/
  356.     SubLCDHistoryNodeEx subLCDHistory = {0};
  358.     /*----------------------------------------------------------------*/
  359.     /* Code Body                                                      */
  360.     /*----------------------------------------------------------------*/
  361. #ifdef __MMI_UI_TAB_PANE__
  362.     if (disable_subLCD_history_save)
  363.     {
  364.         return;
  365.     }
  366. #endif /* __MMI_UI_TAB_PANE__ */ 
  368. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  369.     if (redraw_in_small_screen_proceduer())
  370.     {
  371.         return;
  372.     }
  373. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  375.     subLCDHistory.entryFuncPtr = CurrSubLCDHistory->entryFuncPtr;
  376.     subLCDHistory.scrnID = scrID;
  377.     AddSubLCDHistoryWithScrIDEx(&subLCDHistory, scrID);
  378. #endif /* __MMI_SUBLCD__ */ 
  379. }
  382. /*****************************************************************************
  383.  * FUNCTION
  384.  *  AddSubLCDHistoryWithScrIDEx
  385.  * DESCRIPTION
  386.  *  
  387.  * PARAMETERS
  388.  *  CurrSubLCDHistory       [?]         
  389.  *  scrID                   [IN]        
  390.  * RETURNS
  391.  *  void
  392.  *****************************************************************************/
  393. void AddSubLCDHistoryWithScrIDEx(SubLCDHistoryNodeEx *CurrSubLCDHistory, U16 scrID)
  394. {
  395. #ifdef __MMI_SUBLCD__
  396.     /*----------------------------------------------------------------*/
  397.     /* Local Variables                                                */
  398.     /*----------------------------------------------------------------*/
  400.     /*----------------------------------------------------------------*/
  401.     /* Code Body                                                      */
  402.     /*----------------------------------------------------------------*/
  403. #ifdef __MMI_UI_TAB_PANE__
  404.     if (disable_subLCD_history_save)
  405.     {
  406.         return;
  407.     }
  408. #endif /* __MMI_UI_TAB_PANE__ */ 
  410. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  411.     if (redraw_in_small_screen_proceduer())
  412.     {
  413.         return;
  414.     }
  415. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  417.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_ADD_SUBLCD_HIST_WITHSCRID_HDLR, scrID));
  419.     /* MTK added by JL for back history. */
  420.     if (IsBackSubLCDHistory != TRUE)
  421.     {
  422.         FuncPtr CurrSubLCDEntryFn = CurrSubLCDHistory->entryFuncPtr;
  424.         if (CurrSubLCDEntryFn != NULL)
  425.         {
  426.             SubLCDHistoryData[++NodeIndex].entryFuncPtr = CurrSubLCDEntryFn;
  427.             SubLCDHistoryData[NodeIndex].scrnID = scrID;
  429.             SubLCDHistoryData[NodeIndex].guiLen = 0;
  430.             SubLCDHistoryData[NodeIndex].guiBuffer = NULL;
  431.             if (pfnUnicodeStrlen((PS8) (CurrSubLCDHistory->guiBuffer)))
  432.             {
  433.                 SubLCDHistoryData[NodeIndex].guiLen = MAX_GUI_BUFFER;
  434.                 SubLCDHistoryData[NodeIndex].guiBuffer = OslMalloc(MAX_GUI_BUFFER);
  435.                 memcpy(SubLCDHistoryData[NodeIndex].guiBuffer, CurrSubLCDHistory->guiBuffer, MAX_GUI_BUFFER);
  436.             }
  437.         }
  438.     }
  439.     IsBackSubLCDHistory = FALSE;
  440. #endif /* __MMI_SUBLCD__ */ 
  441. }
  444. /*****************************************************************************
  445.  * FUNCTION
  446.  *  SetSubLCDExitHandler
  447.  * DESCRIPTION
  448.  *  Set Exit handler for Current screen
  449.  * PARAMETERS
  450.  *  CurrSubLCDFn        [IN]        
  451.  * RETURNS
  452.  *  void
  453.  *****************************************************************************/
  454. void SetSubLCDExitHandler(FuncPtr CurrSubLCDFn)
  455. {
  456. #ifdef __MMI_SUBLCD__
  457.     /*----------------------------------------------------------------*/
  458.     /* Local Variables                                                */
  459.     /*----------------------------------------------------------------*/
  461.     /*----------------------------------------------------------------*/
  462.     /* Code Body                                                      */
  463.     /*----------------------------------------------------------------*/
  465.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_ADD_SUBLCD_EXIT_HDLR, CurrSubLCDFn));
  467.     gCurrExitSubLCDFn = CurrSubLCDFn;
  468. #endif /* __MMI_SUBLCD__ */ 
  469. }
  472. /*****************************************************************************
  473.  * FUNCTION
  474.  *  SetSubLCDEntryHandler
  475.  * DESCRIPTION
  476.  *  Set Entry handler for Current screen
  477.  * PARAMETERS
  478.  *  CurrSubLCDFn                [IN]        
  479.  *  CurrSubLCDEntryFn(?)        [IN]        
  480.  * RETURNS
  481.  *  void
  482.  *****************************************************************************/
  483. void SetSubLCDEntryHandler(FuncPtr CurrSubLCDFn)
  484. {
  485. #ifdef __MMI_SUBLCD__
  486.     /*----------------------------------------------------------------*/
  487.     /* Local Variables                                                */
  488.     /*----------------------------------------------------------------*/
  490.     /*----------------------------------------------------------------*/
  491.     /* Code Body                                                      */
  492.     /*----------------------------------------------------------------*/
  494.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_ADD_SUBLCD_ENTRY_HDLR, CurrSubLCDFn));
  496.     gCurrEntrySubLCDFn = CurrSubLCDFn;
  497. #endif /* __MMI_SUBLCD__ */ 
  498. }
  501. /*****************************************************************************
  502.  * FUNCTION
  503.  *  DecrementSubLCD
  504.  * DESCRIPTION
  505.  *  decrement the global history index of sub-LCD
  506.  *  
  507.  *  decrement the global NodeIndex
  508.  * PARAMETERS
  509.  *  void
  510.  * RETURNS
  511.  *  void
  512.  *****************************************************************************/
  513. static void DecrementSubLCD(void)
  514. {
  515. #ifdef __MMI_SUBLCD__
  516.     /*----------------------------------------------------------------*/
  517.     /* Local Variables                                                */
  518.     /*----------------------------------------------------------------*/
  520.     /*----------------------------------------------------------------*/
  521.     /* Code Body                                                      */
  522.     /*----------------------------------------------------------------*/
  523.     if (NodeIndex >= 0)
  524.     {
  525.         if (SubLCDHistoryData[NodeIndex].guiBuffer)
  526.         {
  527.             OslMfree(SubLCDHistoryData[NodeIndex].guiBuffer);
  528.         }
  529.         memset(&SubLCDHistoryData[NodeIndex], 0, sizeof(SubLCDHistoryNode));
  530.         NodeIndex--;
  531.     }
  532. #endif /* __MMI_SUBLCD__ */ 
  533. }
  536. /*****************************************************************************
  537.  * FUNCTION
  538.  *  InitSubLCDHistory
  539.  * DESCRIPTION
  540.  *  De-intialize SubLCD Screen history
  541.  * PARAMETERS
  542.  *  sublcd_root_screen_cb_ptr       [IN]        
  543.  * RETURNS
  544.  *  void
  545.  *****************************************************************************/
  546. void InitSubLCDHistory(SubLcdHistoryCBPtr sublcd_root_screen_cb_ptr)
  547. {
  548. #ifdef __MMI_SUBLCD__
  549.     /*----------------------------------------------------------------*/
  550.     /* Local Variables                                                */
  551.     /*----------------------------------------------------------------*/
  553.     /*----------------------------------------------------------------*/
  554.     /* Code Body                                                      */
  555.     /*----------------------------------------------------------------*/
  556. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  557.     if (redraw_in_small_screen_proceduer())
  558.     {
  559.         return;
  560.     }
  561. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  563.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_INIT, sublcd_root_screen_cb_ptr));
  565.     ExecuteRootSubLcdHistoryScreenPtr = sublcd_root_screen_cb_ptr;
  566. #endif /* __MMI_SUBLCD__ */ 
  568. }
  571. /*****************************************************************************
  572.  * FUNCTION
  573.  *  DinitSubLCDHistory
  574.  * DESCRIPTION
  575.  *  De-intialize SubLCD Screen history
  576.  * PARAMETERS
  577.  *  void
  578.  * RETURNS
  579.  *  void
  580.  *****************************************************************************/
  581. void DinitSubLCDHistory(void)
  582. {
  583. #ifdef __MMI_SUBLCD__
  584.     /*----------------------------------------------------------------*/
  585.     /* Local Variables                                                */
  586.     /*----------------------------------------------------------------*/
  587.     signed char count;
  589.     /*----------------------------------------------------------------*/
  590.     /* Code Body                                                      */
  591.     /*----------------------------------------------------------------*/
  592. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  593.     if (redraw_in_small_screen_proceduer())
  594.     {
  595.         return;
  596.     }
  597. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  599.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_DEINIT));
  601.     if (NodeIndex > -1)
  602.     {
  603.         for (count = NodeIndex; count >= 0; count--)
  604.         {
  605.             /* don't check the return value of delCBHandler */
  606.             ExecHistoryScrnCallBackHandle_ex(NodeIndex, 0);
  607.             DecrementSubLCD();
  608.         }
  609.         NodeIndex = -1;
  610.     }
  611. #endif /* __MMI_SUBLCD__ */ 
  612. }
  615. /*****************************************************************************
  616.  * FUNCTION
  617.  *  ShowSubLCDScreen
  618.  * DESCRIPTION
  619.  *  Calls entry function of the specified screen on the
  620.  *  sub-LCD screen
  621.  * PARAMETERS
  622.  *  SubLCDEntryFn       [IN]        
  623.  * RETURNS
  624.  *  void
  625.  *****************************************************************************/
  626. void ShowSubLCDScreen(FuncPtr SubLCDEntryFn)
  627. {
  628. #ifdef __MMI_SUBLCD__
  629.     /*----------------------------------------------------------------*/
  630.     /* Local Variables                                                */
  631.     /*----------------------------------------------------------------*/
  633.     /*----------------------------------------------------------------*/
  634.     /* Code Body                                                      */
  635.     /*----------------------------------------------------------------*/
  637.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_SHOW_SUBLCD_HDLR, SubLCDEntryFn));
  638.     DisplaySubLCDScreen(SUB_LCD_DUMMY_SCRNID, SubLCDEntryFn, 0);
  640. #if 0   /* when new sub LCD API are OK, remove the below code */
  641. /* under construction !*/
  642. /* under construction !*/
  643. /* under construction !*/
  644. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__//010706 small screen Calvin
  645. /* under construction !*/
  646. /* under construction !*/
  647. /* under construction !*/
  648. /* under construction !*/
  649. #endif
  650. /* under construction !*/
  651. /* under construction !*/
  652. /* under construction !*/
  653. /* under construction !*/
  654. /* under construction !*/
  655. /* under construction !*/
  656. /* under construction !*/
  657. /* under construction !*/
  658. /* under construction !*/
  659. /* under construction !*/
  660. /* under construction !*/
  661. #endif /* 0 */ /* #if 0 */
  663. #endif /* __MMI_SUBLCD__ */ 
  664. }
  667. /*****************************************************************************
  668.  * FUNCTION
  669.  *  ForceSubLCDScreen
  670.  * DESCRIPTION
  671.  *  force to call entry function of a screen SubLCD Screen
  672.  * PARAMETERS
  673.  *  SubLCDEntryFn       [IN]        
  674.  * RETURNS
  675.  *  void
  676.  *****************************************************************************/
  677. void ForceSubLCDScreen(FuncPtr SubLCDEntryFn)
  678. {
  679. #ifdef __MMI_SUBLCD__
  680.     /*----------------------------------------------------------------*/
  681.     /* Local Variables                                                */
  682.     /*----------------------------------------------------------------*/
  684.     /*----------------------------------------------------------------*/
  685.     /* Code Body                                                      */
  686.     /*----------------------------------------------------------------*/
  688.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_FORCE_SUBLCD_HDLR, SubLCDEntryFn));
  689.     DisplaySubLCDScreen(SUB_LCD_DUMMY_SCRNID, SubLCDEntryFn, 1);
  691. #if 0   /* when new sub LCD API are OK, remove the below code */
  692. /* under construction !*/
  693. /* under construction !*/
  694. /* under construction !*/
  695. /* under construction !*/
  696. /* under construction !*/
  697. /* under construction !*/
  698. /* under construction !*/
  699. /* under construction !*/
  700. #if 0//111405 Calvin removed
  701. /* under construction !*/
  702. /* under construction !*/
  703. /* under construction !*/
  704. /* under construction !*/
  705. /* under construction !*/
  706. #endif
  707. /* under construction !*/
  708. /* under construction !*/
  709. /* under construction !*/
  710. /* under construction !*/
  711. /* under construction !*/
  712. /* under construction !*/
  713. #endif /* 0 */ /* #if 0 */
  715. #endif /* __MMI_SUBLCD__ */ 
  716. }
  719. /*****************************************************************************
  720.  * FUNCTION
  721.  *  DisplaySubLCDScreen
  722.  * DESCRIPTION
  723.  *  Display a screen SubLCD Screen
  724.  * PARAMETERS
  725.  *  scrnId              [IN]        
  726.  *  SubLCDEntryFn       [IN]        
  727.  *  is_force            [IN]        
  728.  * RETURNS
  729.  *  void
  730.  *****************************************************************************/
  731. void DisplaySubLCDScreen(U16 scrnId, FuncPtr SubLCDEntryFn, MMI_BOOL is_force)
  732. {
  733. #ifdef __MMI_SUBLCD__
  734.     /*----------------------------------------------------------------*/
  735.     /* Local Variables                                                */
  736.     /*----------------------------------------------------------------*/
  737.     MMI_BOOL flag = MMI_TRUE;
  739.     /*----------------------------------------------------------------*/
  740.     /* Code Body                                                      */
  741.     /*----------------------------------------------------------------*/
  743.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_DISPLAY_SUBLCD_HDLR, SubLCDEntryFn, scrnId, is_force));
  744.     if (!is_force)
  745.     {
  746.         /* refer ShowSubLCDScreen() */
  747.     #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__  /* 010706 small screen Calvin */
  748.         if (is_redrawing_old_screens())
  749.         {
  750.             return;
  751.         }
  752.     #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  753.     }
  755.     if (!is_force)
  756.     {
  757.         /* refer ShowSubLCDScreen() */
  758.         if (IsMainLCDHistoryBack())
  759.         {
  760.             /* no need to display the sub LCD screen */
  761.             flag = MMI_FALSE;
  762.         }
  763.     }
  765.     if (flag)
  766.     {
  767.         gCurrTopSubLCDScrnID = scrnId;
  768.         gCurrEntrySubLCDFn = SubLCDEntryFn;
  769.         SubLCDEntryFn();
  770.         gCurrExitSubLCDScrnID = scrnId;
  771.     }
  772. #endif /* __MMI_SUBLCD__ */ 
  773. }
  776. /*****************************************************************************
  777.  * FUNCTION
  778.  *  GoBackSubLCDHistory
  779.  * DESCRIPTION
  780.  *  Go back to history On SubLCD Screen
  781.  * PARAMETERS
  782.  *  void
  783.  * RETURNS
  784.  *  void
  785.  *****************************************************************************/
  786. void GoBackSubLCDHistory(void)
  787. {
  788. #ifdef __MMI_SUBLCD__
  789.     /*----------------------------------------------------------------*/
  790.     /* Local Variables                                                */
  791.     /*----------------------------------------------------------------*/
  792.     U16 scrnId;
  794.     /*----------------------------------------------------------------*/
  795.     /* Code Body                                                      */
  796.     /*----------------------------------------------------------------*/
  797. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  798.     if (redraw_in_small_screen_proceduer())
  799.     {
  800.         return;
  801.     }
  802. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  804.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_GO_BACK_SUBLCD_HDLR));
  806.     if (NodeIndex >= 0)
  807.     {
  808.         IsBackSubLCDHistory = TRUE;
  810.         ExecTopScrnCallbackHandler_ex(0);
  811.         scrnId = SubLCDHistoryData[NodeIndex].scrnID;
  812.         if (SubLCDHistoryData[NodeIndex].entryFuncPtr)
  813.         {
  814.             gCurrTopSubLCDScrnID = scrnId;
  815.             gCurrEntrySubLCDFn = SubLCDHistoryData[NodeIndex].entryFuncPtr;
  816.             SubLCDHistoryData[NodeIndex].entryFuncPtr();
  817.             gCurrExitSubLCDScrnID = scrnId;
  818.         }
  820.         if (SubLCDHistoryData[NodeIndex].scrnID == scrnId)
  821.         {
  822.             DecrementSubLCD();
  823.         }
  824.     }
  825.     else
  826.     {
  827.         ExecTopScrnCallbackHandler_ex(0);
  828.         if (ExecuteRootSubLcdHistoryScreenPtr != NULL)
  829.         {
  830.             gCurrTopSubLCDScrnID = SUB_LCD_DUMMY_SCRNID;
  831.             gCurrEntrySubLCDFn = (FuncPtr) ExecuteRootSubLcdHistoryScreenPtr;
  832.             ExecuteRootSubLcdHistoryScreenPtr(NULL);
  833.             gCurrExitSubLCDScrnID = SUB_LCD_DUMMY_SCRNID;
  834.         }
  835.         NodeIndex = -1;
  836.     }
  837. #endif /* __MMI_SUBLCD__ */ 
  838. }
  841. /*****************************************************************************
  842.  * FUNCTION
  843.  *  GoBacknSubLCDHistory
  844.  * DESCRIPTION
  845.  *  Go back 'n' history On SubLCD Screen
  846.  * PARAMETERS
  847.  *  nHistory        [IN]        
  848.  * RETURNS
  849.  *  void
  850.  *****************************************************************************/
  851. void GoBacknSubLCDHistory(U16 nHistory)
  852. {
  853. #ifdef __MMI_SUBLCD__
  854.     /*----------------------------------------------------------------*/
  855.     /* Local Variables                                                */
  856.     /*----------------------------------------------------------------*/
  857.     S16 Count = 0;
  859.     /*----------------------------------------------------------------*/
  860.     /* Code Body                                                      */
  861.     /*----------------------------------------------------------------*/
  862. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  863.     if (redraw_in_small_screen_proceduer())
  864.     {
  865.         return;
  866.     }
  867. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  869.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_GO_BACK_N_SUBLCD_HDLR, nHistory));
  871.     if (NodeIndex >= nHistory)
  872.     {
  873.         IsBackSubLCDHistory = TRUE;
  874.         for (Count = nHistory; Count >= 0; --Count)
  875.         {
  876.             /* JL, if want to stop to run next decrement will return true. */
  877.             if (ExecHistoryScrnCallBackHandle_ex(NodeIndex, 0) == MMI_HIST_STOP_DELETING)
  878.             {
  879.                 break;
  880.             }
  881.             DecrementSubLCD();
  882.         }
  884.         GoBackSubLCDHistory();
  885.     }
  886. #endif /* __MMI_SUBLCD__ */ 
  887. }
  890. /*****************************************************************************
  891.  * FUNCTION
  892.  *  GoBackToSubLCDHistory
  893.  * DESCRIPTION
  894.  *  Goes back to specified screen on sub-LCD
  895.  * PARAMETERS
  896.  *  scrnid      [IN]        
  897.  * RETURNS
  898.  *  U8 - status
  899.  *****************************************************************************/
  900. U8 GoBackToSubLCDHistory(U16 scrnid)
  901. {
  902.     /*----------------------------------------------------------------*/
  903.     /* Local Variables                                                */
  904.     /*----------------------------------------------------------------*/
  905.     U8 Status = ST_FAILURE;
  907. #ifdef __MMI_SUBLCD__
  908.     S16 count = 0;
  910.     /*----------------------------------------------------------------*/
  911.     /* Code Body                                                      */
  912.     /*----------------------------------------------------------------*/
  913. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  914.     if (redraw_in_small_screen_proceduer())
  915.     {
  916.         return ST_SUCCESS;
  917.     }
  918. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  920.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_GO_BACK_TO_SUBLCD_HDLR, scrnid));
  922.     count = NodeIndex;
  924.     if (!IsSubLCDScreenPresent(scrnid))
  925.     {
  926.         return ST_FAILURE;
  927.     }
  929.     do
  930.     {
  931.         if (NodeIndex >= 0)
  932.         {
  933.             if (SubLCDHistoryData[NodeIndex].scrnID == scrnid)
  934.             {
  935.                 Status = ST_SUCCESS;
  936.                 break;
  937.             }
  939.             if (ExecHistoryScrnCallBackHandle_ex(NodeIndex, 0) == MMI_HIST_STOP_DELETING)
  940.             {
  941.                 Status = ST_SUCCESS;
  942.                 break;
  943.             }
  944.             DecrementSubLCD();
  945.         }
  947.     } while ((count != NodeIndex) && (SubLCDHistoryData[NodeIndex].entryFuncPtr != NULL) && (NodeIndex > 0));
  948.     GoBackSubLCDHistory();
  949. #endif /* __MMI_SUBLCD__ */ 
  951.     return Status;
  953. }
  956. /*****************************************************************************
  957.  * FUNCTION
  958.  *  GoBeyondSubLCDMarkerScr
  959.  * DESCRIPTION
  960.  *  Go one node beyond  marker screen on sub-LCD
  961.  * PARAMETERS
  962.  *  scrnid      [IN]        
  963.  * RETURNS
  964.  *  U8 - status
  965.  *****************************************************************************/
  966. U8 GoBeyondSubLCDMarkerScr(U16 scrnid)
  967. {
  968.     /*----------------------------------------------------------------*/
  969.     /* Local Variables                                                */
  970.     /*----------------------------------------------------------------*/
  971.     U8 Status = ST_FAILURE;
  973. #ifdef __MMI_SUBLCD__
  974.     S16 count = 0;
  976.     /*----------------------------------------------------------------*/
  977.     /* Code Body                                                      */
  978.     /*----------------------------------------------------------------*/
  979. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  980.     if (redraw_in_small_screen_proceduer())
  981.     {
  982.         return ST_SUCCESS;
  983.     }
  984. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  986.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_GO_BEYOND_SUBLCD_HDLR, scrnid));
  988.     count = NodeIndex;
  990.     if (!IsSubLCDScreenPresent(scrnid))
  991.     {
  992.         return ST_FAILURE;
  993.     }
  995.     do
  996.     {
  997.         if (NodeIndex > 0)
  998.         {
  999.             if (SubLCDHistoryData[NodeIndex].scrnID == scrnid)
  1000.             {
  1001.                 Status = ST_SUCCESS;
  1002.                 break;
  1003.             }
  1004.             if (ExecHistoryScrnCallBackHandle_ex(NodeIndex, 0) == MMI_HIST_STOP_DELETING)
  1005.             {
  1006.                 Status = ST_FAILURE;
  1007.                 break;
  1008.             }
  1009.             DecrementSubLCD();
  1010.         }
  1011.     } while ((count != NodeIndex) && (SubLCDHistoryData[NodeIndex].entryFuncPtr != NULL));
  1013.     MMI_ASSERT(NodeIndex >= 0);
  1015.     if (Status)
  1016.     {
  1017.         /* go one node beyond  marker screen */
  1018.         if (ExecHistoryScrnCallBackHandle_ex(NodeIndex, 0) == MMI_HIST_ALLOW_DELETING)
  1019.         {
  1020.             DecrementSubLCD();
  1021.         }
  1022.     }
  1023.     Status = ST_SUCCESS;
  1025.     GoBackSubLCDHistory();
  1027. #endif /* __MMI_SUBLCD__ */ 
  1029.     return Status;
  1031. }
  1034. /*****************************************************************************
  1035.  * FUNCTION
  1036.  *  GoBackBothLCDHistory
  1037.  * DESCRIPTION
  1038.  *  Go back to history on Main LCD & SubLCD Screen
  1039.  * PARAMETERS
  1040.  *  void
  1041.  * RETURNS
  1042.  *  void
  1043.  *****************************************************************************/
  1044. void GoBackBothLCDHistory(void)
  1045. {
  1046.     /*----------------------------------------------------------------*/
  1047.     /* Local Variables                                                */
  1048.     /*----------------------------------------------------------------*/
  1050.     /*----------------------------------------------------------------*/
  1051.     /* Code Body                                                      */
  1052.     /*----------------------------------------------------------------*/
  1053. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1054.     if (redraw_in_small_screen_proceduer())
  1055.     {
  1056.         return;
  1057.     }
  1058. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1060.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_BACK_BOTHLCD_HIST_HDLR));
  1061. #ifdef __MMI_SUBLCD__
  1062.     GoBackSubLCDHistory();
  1063. #endif 
  1064.     GoBackHistory();
  1065. }
  1068. /*****************************************************************************
  1069.  * FUNCTION
  1070.  *  DeleteUptoSubLCDScrID
  1071.  * DESCRIPTION
  1072.  *  Go to a screen on sub-LCD and delete history of all ahead of it
  1073.  * PARAMETERS
  1074.  *  scrnid      [IN]        
  1075.  * RETURNS
  1076.  *  U8 - status
  1077.  *****************************************************************************/
  1078. U8 DeleteUptoSubLCDScrID(U16 scrnid)
  1079. {
  1080.     /*----------------------------------------------------------------*/
  1081.     /* Local Variables                                                */
  1082.     /*----------------------------------------------------------------*/
  1083.     U8 Status = ST_FAILURE;
  1085. #ifdef __MMI_SUBLCD__
  1086.     S16 count = 0;
  1088.     /*----------------------------------------------------------------*/
  1089.     /* Code Body                                                      */
  1090.     /*----------------------------------------------------------------*/
  1092. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1093.     if (redraw_in_small_screen_proceduer())
  1094.     {
  1095.         return ST_SUCCESS;
  1096.     }
  1097. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1099.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_DEL_UPTO_SUBLCD_SCR_HDLR, scrnid));
  1101.     count = NodeIndex;
  1102.     if (!IsSubLCDScreenPresent(scrnid))
  1103.     {
  1104.         return ST_FAILURE;
  1105.     }
  1107.     do
  1108.     {
  1109.         if (SubLCDHistoryData[NodeIndex].scrnID == scrnid)
  1110.         {
  1112.             Status = ST_SUCCESS;
  1113.             break;
  1114.         }
  1115.         if (ExecHistoryScrnCallBackHandle_ex(NodeIndex, 0) == MMI_HIST_STOP_DELETING)
  1116.         {
  1117.             Status = ST_SUCCESS;
  1118.             break;
  1119.         }
  1120.         DecrementSubLCD();
  1122.     } while ((count != NodeIndex) && (SubLCDHistoryData[NodeIndex].entryFuncPtr != NULL));
  1124. #endif /* __MMI_SUBLCD__ */ 
  1126.     return Status;
  1128. }
  1131. /*****************************************************************************
  1132.  * FUNCTION
  1133.  *  DeleteNSubLCDScrId
  1134.  * DESCRIPTION
  1135.  *  Deletes up to screen id on sub-LCD and go  beyond it one node
  1136.  * PARAMETERS
  1137.  *  scrnid      [IN]        
  1138.  * RETURNS
  1139.  *  U8 - status
  1140.  *****************************************************************************/
  1141. U8 DeleteNSubLCDScrId(U16 scrnid)
  1142. {
  1143.     /*----------------------------------------------------------------*/
  1144.     /* Local Variables                                                */
  1145.     /*----------------------------------------------------------------*/
  1146.     U8 Status = ST_FAILURE;
  1148. #ifdef __MMI_SUBLCD__
  1149.     S16 count = 0;
  1151.     /*----------------------------------------------------------------*/
  1152.     /* Code Body                                                      */
  1153.     /*----------------------------------------------------------------*/
  1155. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1156.     if (redraw_in_small_screen_proceduer())
  1157.     {
  1158.         return ST_SUCCESS;
  1159.     }
  1160. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1162.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_DEL_N_SUBLCD_SCR_HDLR, scrnid));
  1164.     count = NodeIndex;
  1166.     if (!IsSubLCDScreenPresent(scrnid))
  1167.     {
  1168.         return ST_FAILURE;
  1169.     }
  1171.     do
  1172.     {
  1173.         if (SubLCDHistoryData[NodeIndex].scrnID == scrnid)
  1174.         {
  1175.             Status = ST_SUCCESS;
  1176.             break;
  1177.         }
  1178.         if (ExecHistoryScrnCallBackHandle_ex(NodeIndex, 0) == MMI_HIST_STOP_DELETING)
  1179.         {
  1180.             Status = ST_FAILURE;
  1181.             break;
  1182.         }
  1183.         DecrementSubLCD();
  1185.     } while ((count != NodeIndex) && (SubLCDHistoryData[NodeIndex].entryFuncPtr != NULL));
  1187.     if (Status)
  1188.     {
  1189.         /* delete the one more scrnid of SubLCD history */
  1190.         if (ExecHistoryScrnCallBackHandle_ex(NodeIndex, 0) == MMI_HIST_ALLOW_DELETING)
  1191.         {
  1192.             DecrementSubLCD();
  1193.         }
  1194.     }
  1195. #endif /* __MMI_SUBLCD__ */ 
  1196.     return Status;
  1197. }
  1200. /*****************************************************************************
  1201.  * FUNCTION
  1202.  *  DeleteSubLCDScreen
  1203.  * DESCRIPTION
  1204.  *  Deletes Screen from sub-LCD history
  1205.  *  This screen id won't be deleted
  1206.  * PARAMETERS
  1207.  *  ScrId       [IN]        
  1208.  * RETURNS
  1209.  *  U16 - status
  1210.  * REMARK
  1211.  *  The behavior is the same with DeleteScreenIfPresent()
  1212.  *****************************************************************************/
  1213. U16 DeleteSubLCDScreen(U16 ScrId)
  1214. {
  1215.     U8 Status = ST_SUCCESS;
  1217. #ifdef __MMI_SUBLCD__
  1218.     /*----------------------------------------------------------------*/
  1219.     /* Local Variables                                                */
  1220.     /*----------------------------------------------------------------*/
  1221.     S16 count, i;
  1223.     /*----------------------------------------------------------------*/
  1224.     /* Code Body                                                      */
  1225.     /*----------------------------------------------------------------*/
  1227. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1228.     if (redraw_in_small_screen_proceduer())
  1229.     {
  1230.         return ST_SUCCESS;
  1231.     }
  1232. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1234.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_DEL_SUBLCD_SCR_HDLR, ScrId));
  1236.     if (!IsSubLCDScreenPresent(ScrId))
  1237.     {
  1238.         return ST_FAILURE;
  1239.     }
  1241.     count = NodeIndex;
  1243.     /* Locating the screen */
  1244.     while (count)
  1245.     {
  1246.         if (SubLCDHistoryData[count].scrnID == ScrId)
  1247.         {
  1248.             /*
  1249.              * Not support for stop callback at this funciton 
  1250.              * Because the application want to delete the special screen in the history,
  1251.              * we don't need to check the return value of the delete callback function.
  1252.              * the behavior is the same with DeleteScreenIfPresent()
  1253.              */
  1254.             ExecHistoryScrnCallBackHandle_ex(count, 0);
  1255.             break;
  1256.         }
  1257.         --count;
  1258.     }
  1260.     if (Status)
  1261.     {
  1262.         /* Shifting All the nodes by one notch */
  1263.         for (i = count + 1; i <= NodeIndex; i++, count++)
  1264.         {
  1265.             memcpy(&SubLCDHistoryData[count], &SubLCDHistoryData[i], sizeof(SubLCDHistoryNode));
  1266.         }
  1268.         --NodeIndex;
  1269.         memset(&SubLCDHistoryData[NodeIndex + 1], 0, sizeof(SubLCDHistoryNode));
  1270.     }
  1271. #endif /* __MMI_SUBLCD__ */ 
  1272.     return Status;
  1273. }
  1276. /*****************************************************************************
  1277.  * FUNCTION
  1278.  *  DeleteNSubLCDHistory
  1279.  * DESCRIPTION
  1280.  *  Deletes 'n' history nodes from current Sub LCDhistory index
  1281.  *  
  1282.  *  This shall pop 'n' history nodes without invoking
  1283.  *  entry functions of the deleted nodes
  1284.  * PARAMETERS
  1285.  *  DeleteCount     [IN]        
  1286.  *  n(?)            [IN]        
  1287.  * RETURNS
  1288.  *  void
  1289.  *****************************************************************************/
  1290. void DeleteNSubLCDHistory(U16 DeleteCount)
  1291. {
  1292. #ifdef __MMI_SUBLCD__
  1293.     /*----------------------------------------------------------------*/
  1294.     /* Local Variables                                                */
  1295.     /*----------------------------------------------------------------*/
  1296.     S16 Count = 0;
  1298.     /*----------------------------------------------------------------*/
  1299.     /* Code Body                                                      */
  1300.     /*----------------------------------------------------------------*/
  1302. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1303.     if (redraw_in_small_screen_proceduer())
  1304.     {
  1305.         return ;
  1306.     }
  1307. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1309.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_DEL_SUBLCD_SCR_NUM, DeleteCount));
  1311.     if (NodeIndex >= DeleteCount)
  1312.     {
  1313.         /* To make sure the callback will run at topist screen */
  1314.         ExecTopScrnCallbackHandler_ex(0);
  1316.         for (Count = DeleteCount; Count >= 1; --Count)
  1317.         {
  1318.             /* JL, if want to stop to run next decrement will return true. */
  1319.             if (ExecHistoryScrnCallBackHandle_ex(NodeIndex, 0) == MMI_HIST_STOP_DELETING)
  1320.             {
  1321.                 break;
  1322.             }
  1323.             DecrementSubLCD();
  1324.         }
  1325.     }
  1326. #endif /* __MMI_SUBLCD__ */ 
  1327. }
  1330. /*****************************************************************************
  1331.  * FUNCTION
  1332.  *  DeleteBeyondSubLCDScrTillScr
  1333.  * DESCRIPTION
  1334.  *  To delete scrns beyond scrn A
  1335.  *  till scrn B
  1336.  * PARAMETERS
  1337.  *  beyondScrnid        [IN]        
  1338.  *  tillScrnid          [IN]        
  1339.  *  scrnid1(?)          [IN]        
  1340.  *  scrnid2(?)          [IN]        
  1341.  * RETURNS
  1342.  *  U16 - status
  1343.  *****************************************************************************/
  1344. U8 DeleteBeyondSubLCDScrTillScr(U16 beyondScrnid, U16 tillScrnid)
  1345. {
  1346.     U8 Status = ST_SUCCESS;
  1348. #ifdef __MMI_SUBLCD__
  1349.     /*----------------------------------------------------------------*/
  1350.     /* Local Variables                                                */
  1351.     /*----------------------------------------------------------------*/
  1352.     S16 count = 0, count1 = 0;
  1353.     S16 endScreenPresent = -1, startScreenPresent = -1;
  1354.     U16 screensDeleted = 0;
  1356.     /*----------------------------------------------------------------*/
  1357.     /* Code Body                                                      */
  1358.     /*----------------------------------------------------------------*/
  1360. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1361.     if (redraw_in_small_screen_proceduer())
  1362.     {
  1363.         return ST_SUCCESS;
  1364.     }
  1365. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1367.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_DEL_BEYOND_TILL_SUBLCD_SCR_HDLR, beyondScrnid, tillScrnid));
  1369.     if (!IsSubLCDScreenPresent(beyondScrnid) || !IsSubLCDScreenPresent(tillScrnid))
  1370.     {
  1371.         return ST_FAILURE;
  1372.     }
  1374.     if (NodeIndex > 0)
  1375.     {
  1376.         count = NodeIndex;
  1377.         count1 = NodeIndex;
  1378.     }
  1380.     while (count)
  1381.     {
  1382.         if (SubLCDHistoryData[count].scrnID == beyondScrnid)
  1383.         {
  1384.             startScreenPresent = count;
  1385.         }
  1386.         if (SubLCDHistoryData[count].scrnID == tillScrnid)
  1387.         {
  1388.             MMI_ASSERT(startScreenPresent != -1);
  1389.             endScreenPresent = count;
  1390.             break;
  1391.         }
  1392.         --count;
  1393.     }
  1394.     MMI_ASSERT((startScreenPresent != -1) && (endScreenPresent != -1));
  1396.     for (count = startScreenPresent - 1; count >= endScreenPresent; count--)
  1397.     {
  1398.         if (ExecHistoryScrnCallBackHandle_ex(count, 0) == MMI_HIST_STOP_DELETING)
  1399.         {
  1400.             /*
  1401.              * The screen won't want to delete. 
  1402.              * We stop continue to delete the screens.
  1403.              */
  1404.             endScreenPresent = count + 1;
  1405.             Status = ST_FAILURE;
  1406.             break;
  1407.         }
  1408.         if (SubLCDHistoryData[count].guiBuffer)
  1409.         {
  1410.             OslMfree(SubLCDHistoryData[count].guiBuffer);
  1411.         }
  1412.         memset(&SubLCDHistoryData[count], 0, sizeof(SubLCDHistoryNode));
  1413.         NodeIndex--;
  1414.         screensDeleted++;
  1415.     }
  1417.     memcpy(
  1418.         SubLCDHistoryData + endScreenPresent,
  1419.         SubLCDHistoryData + startScreenPresent,
  1420.         sizeof(SubLCDHistoryNode) * (count1 - startScreenPresent + 1));
  1421.     memset(SubLCDHistoryData + (NodeIndex + 1), 0, (sizeof(SubLCDHistoryNode) * screensDeleted));
  1422. #endif /* __MMI_SUBLCD__ */ 
  1423.     return Status;
  1424. }
  1427. /*****************************************************************************
  1428.  * FUNCTION
  1429.  *  DeleteBetweenSubLCDScreen
  1430.  * DESCRIPTION
  1431.  *  Deletes Between two Screens including the boundaries
  1432.  * PARAMETERS
  1433.  *  StartScrId      [IN]        
  1434.  *  EndScrId        [IN]        
  1435.  * RETURNS
  1436.  *  U16 - status
  1437.  *****************************************************************************/
  1438. U16 DeleteBetweenSubLCDScreen(U16 StartScrId, U16 EndScrId)
  1439. {
  1440.     U8 Status = ST_SUCCESS;
  1442. #ifdef __MMI_SUBLCD__
  1443.     /*----------------------------------------------------------------*/
  1444.     /* Local Variables                                                */
  1445.     /*----------------------------------------------------------------*/
  1446.     S16 count = 0, count1 = 0;
  1447.     S16 endScreenPresent = -1, startScreenPresent = -1;
  1448.     U16 screensDeleted = 0;
  1450.     /*----------------------------------------------------------------*/
  1451.     /* Code Body                                                      */
  1452.     /*----------------------------------------------------------------*/
  1454. #ifdef __MMI_UI_SMALL_SCREEN_SUPPORT__
  1455.     if (redraw_in_small_screen_proceduer())
  1456.     {
  1457.         return ST_SUCCESS;
  1458.     }
  1459. #endif /* __MMI_UI_SMALL_SCREEN_SUPPORT__ */ 
  1461.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_DEL_BETWEEN_SUBLCD_SCR_HDLR, StartScrId, EndScrId));
  1463.     if (!IsSubLCDScreenPresent(StartScrId) || !IsSubLCDScreenPresent(EndScrId))
  1464.     {
  1465.         return ST_FAILURE;
  1466.     }
  1468.     if (NodeIndex > 0)
  1469.     {
  1470.         count = NodeIndex;
  1471.         count1 = NodeIndex;
  1472.     }
  1474.     while (count >= 0)
  1475.     {
  1476.         if (SubLCDHistoryData[count].scrnID == EndScrId)
  1477.         {
  1478.             startScreenPresent = count;
  1479.         }
  1480.         if (SubLCDHistoryData[count].scrnID == StartScrId)
  1481.         {
  1482.             endScreenPresent = count;
  1483.             break;
  1484.         }
  1485.         --count;
  1486.     }
  1487.     MMI_ASSERT((startScreenPresent != -1) && (endScreenPresent != -1));
  1488.     for (count = startScreenPresent; count >= endScreenPresent; count--)
  1489.     {
  1490.         if (ExecHistoryScrnCallBackHandle_ex(count, 0) == MMI_HIST_STOP_DELETING)
  1491.         {
  1492.             /*
  1493.              * The screen won't want to delete. 
  1494.              * We stop continue to delete the screens.
  1495.              */
  1496.             endScreenPresent = count + 1;
  1497.             Status = ST_FAILURE;
  1498.             break;
  1499.         }
  1500.         if (SubLCDHistoryData[count].guiBuffer)
  1501.         {
  1502.             OslMfree(SubLCDHistoryData[count].guiBuffer);
  1503.         }
  1504.         memset(&SubLCDHistoryData[count], 0, sizeof(SubLCDHistoryNode));
  1505.         NodeIndex--;
  1506.         screensDeleted++;
  1507.     }
  1509.     memcpy(
  1510.         SubLCDHistoryData + endScreenPresent,
  1511.         SubLCDHistoryData + startScreenPresent + 1,
  1512.         sizeof(SubLCDHistoryNode) * (count1 - startScreenPresent + 1));
  1513.     memset(SubLCDHistoryData + (NodeIndex + 1), 0, (sizeof(SubLCDHistoryNode) * screensDeleted));
  1515. #endif /* __MMI_SUBLCD__ */ 
  1516.     return Status;
  1517. }
  1520. /*****************************************************************************
  1521.  * FUNCTION
  1522.  *  SubLCDHistoryReplace
  1523.  * DESCRIPTION
  1524.  *  To replace a specific history
  1525.  *  
  1526.  *  HistoryReplace will be used for a exist history
  1527.  * PARAMETERS
  1528.  *  out_scrn_id     [IN]        
  1529.  *  in_scrn_id      [IN]        
  1530.  *  in_src_func     [IN]        
  1531.  * RETURNS
  1532.  *  pBool
  1533.  *****************************************************************************/
  1534. pBOOL SubLCDHistoryReplace(U16 out_scrn_id, U16 in_scrn_id, FuncPtr in_src_func)
  1535. {
  1536. #ifdef __MMI_SUBLCD__
  1538.     /*----------------------------------------------------------------*/
  1539.     /* Local Variables                                                */
  1540.     /*----------------------------------------------------------------*/
  1541.     S16 count = 0;
  1543.     /*----------------------------------------------------------------*/
  1544.     /* Code Body                                                      */
  1545.     /*----------------------------------------------------------------*/
  1547.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_REPLACE_SUBLCD_SCR_HDLR, out_scrn_id, in_scrn_id, in_src_func));
  1549.     for (count = 0; ((count < MAX_SUBLCD_HISTORY) && ((count <= NodeIndex) && (NodeIndex != -1))); count++)
  1550.     {
  1551.         /* Find the matched source history and then to write into destinate history */
  1552.         if (SubLCDHistoryData[count].scrnID == out_scrn_id)
  1553.         {
  1554.             ClearDelScrnIDCallbackHandler(out_scrn_id, NULL);
  1555.             SubLCDHistoryData[count].scrnID = in_scrn_id;
  1556.             SubLCDHistoryData[count].entryFuncPtr = in_src_func;
  1557.             if (SubLCDHistoryData[count].guiBuffer)
  1558.             {
  1559.                 OslMfree(SubLCDHistoryData[count].guiBuffer);
  1560.             }
  1561.             SubLCDHistoryData[count].guiBuffer = NULL;
  1562.             SubLCDHistoryData[count].guiLen = 0;
  1563.             return MMI_TRUE;
  1564.         }
  1565.     }
  1566. #endif /* __MMI_SUBLCD__ */ 
  1567.     return MMI_FALSE;
  1569. }
  1572. /*****************************************************************************
  1573.  * FUNCTION
  1574.  *  IsSubLCDScreenPresent
  1575.  * DESCRIPTION
  1576.  *  Queries history for presence of a screen Id in sub-LCD history
  1577.  * PARAMETERS
  1578.  *  scrnId          [IN]        
  1579.  *  scrnid(?)       [IN]        
  1580.  * RETURNS
  1581.  *  pBOOL
  1582.  *****************************************************************************/
  1583. pBOOL IsSubLCDScreenPresent(U16 scrnId)
  1584. {
  1585. #ifdef __MMI_SUBLCD__
  1586.     /*----------------------------------------------------------------*/
  1587.     /* Local Variables                                                */
  1588.     /*----------------------------------------------------------------*/
  1589.     S16 count;
  1591.     /*----------------------------------------------------------------*/
  1592.     /* Code Body                                                      */
  1593.     /*----------------------------------------------------------------*/
  1594.     for (count = 0; ((count < MAX_SUBLCD_HISTORY) && ((count <= NodeIndex) && (NodeIndex != -1))); count++)
  1595.     {
  1596.         if (SubLCDHistoryData[count].scrnID == scrnId)
  1597.         {
  1598.             return TRUE;
  1599.         }
  1600.     }
  1601. #endif /* __MMI_SUBLCD__ */ 
  1603.     return FALSE;
  1604. }
  1607. /*****************************************************************************
  1608.  * FUNCTION
  1609.  *  GetCurrSubLCDScreenExitFunc
  1610.  * DESCRIPTION
  1611.  *  Queries present screen exit function
  1612.  * PARAMETERS
  1613.  *  void
  1614.  * RETURNS
  1615.  *  FuncPtr
  1616.  *****************************************************************************/
  1617. FuncPtr GetCurrSubLCDScreenExitFunc(void)
  1618. {
  1619.     /*----------------------------------------------------------------*/
  1620.     /* Local Variables                                                */
  1621.     /*----------------------------------------------------------------*/
  1623.     /*----------------------------------------------------------------*/
  1624.     /* Code Body                                                      */
  1625.     /*----------------------------------------------------------------*/
  1626. #ifdef __MMI_SUBLCD__
  1627.     return gCurrExitSubLCDFn;
  1628. #endif 
  1629.     return 0;
  1630. }
  1633. /*****************************************************************************
  1634.  * FUNCTION
  1635.  *  GetCurrSubLCDScreenEntryFunc
  1636.  * DESCRIPTION
  1637.  *  Queries current screen entry function
  1638.  * PARAMETERS
  1639.  *  void
  1640.  * RETURNS
  1641.  *  FuncPtr
  1642.  *****************************************************************************/
  1643. FuncPtr GetCurrSubLCDScreenEntryFunc(void)
  1644. {
  1645.     /*----------------------------------------------------------------*/
  1646.     /* Local Variables                                                */
  1647.     /*----------------------------------------------------------------*/
  1649.     /*----------------------------------------------------------------*/
  1650.     /* Code Body                                                      */
  1651.     /*----------------------------------------------------------------*/
  1652. #ifdef __MMI_SUBLCD__
  1653.     return gCurrEntrySubLCDFn;
  1654. #endif 
  1655.     return 0;
  1656. }
  1659. /*****************************************************************************
  1660.  * FUNCTION
  1661.  *  GetSubLCDScreenCountInHistory
  1662.  * DESCRIPTION
  1663.  *  Get the screen numbers in subLCD history
  1664.  * PARAMETERS
  1665.  *  void
  1666.  * RETURNS
  1667.  *  S16 - screen count
  1668.  *****************************************************************************/
  1669. S16 GetSubLCDScreenCountInHistory(void)
  1670. {
  1671.     /*----------------------------------------------------------------*/
  1672.     /* Local Variables                                                */
  1673.     /*----------------------------------------------------------------*/
  1675.     /*----------------------------------------------------------------*/
  1676.     /* Code Body                                                      */
  1677.     /*----------------------------------------------------------------*/
  1678. #ifdef __MMI_SUBLCD__
  1679.     return (S16)(NodeIndex + 1);
  1680. #endif 
  1681.     return 0;
  1682. }
  1685. /*****************************************************************************
  1686.  * FUNCTION
  1687.  *  GetSubLCDHistory
  1688.  * DESCRIPTION
  1689.  *  Used to get sub LCD history buffer for a screen id
  1690.  * PARAMETERS
  1691.  *  scrnId          [IN]        
  1692.  *  ptrHistory      [?]         
  1693.  *  scrnID(?)       [IN]        History *ptrHistory
  1694.  * RETURNS
  1695.  *  FuncPtr
  1696.  *****************************************************************************/
  1697. U8 GetSubLCDHistory(U16 scrnId, SubLCDHistoryNodeEx *ptrHistory)
  1698. {
  1699. #ifdef __MMI_SUBLCD__
  1700.     /*----------------------------------------------------------------*/
  1701.     /* Local Variables                                                */
  1702.     /*----------------------------------------------------------------*/
  1703.     S16 count;
  1705.     /*----------------------------------------------------------------*/
  1706.     /* Code Body                                                      */
  1707.     /*----------------------------------------------------------------*/
  1708.     for (count = 0; ((count < MAX_SUBLCD_HISTORY) && ((count <= NodeIndex) && (NodeIndex != -1))); count++)
  1709.     {
  1710.         if (SubLCDHistoryData[count].scrnID == scrnId)
  1711.         {
  1712.             ptrHistory->scrnID = SubLCDHistoryData[count].scrnID;
  1713.             ptrHistory->entryFuncPtr = SubLCDHistoryData[count].entryFuncPtr;
  1714.             if (SubLCDHistoryData[count].guiLen)
  1715.             {
  1716.                 memcpy(ptrHistory->guiBuffer, SubLCDHistoryData[count].guiBuffer, MAX_GUI_BUFFER);
  1717.             }
  1718.             else
  1719.             {
  1720.                 memset(ptrHistory->guiBuffer, 0, MAX_GUI_BUFFER);
  1721.             }
  1723.             return TRUE;
  1724.         }
  1725.     }
  1726. #endif /* __MMI_SUBLCD__ */ 
  1727.     return FALSE;
  1728. }
  1731. /*****************************************************************************
  1732.  * FUNCTION
  1733.  *  GetCurrSubLCDGuiBuffer
  1734.  * DESCRIPTION
  1735.  *  gets current Sub LCD screen gui buffer
  1736.  * PARAMETERS
  1737.  *  scrnId          [IN]        
  1738.  *  scrnid(?)       [IN]        
  1739.  * RETURNS
  1740.  *  FuncPtr
  1741.  *****************************************************************************/
  1742. U8 *GetCurrSubLCDGuiBuffer(U16 scrnId)
  1743. {
  1744. #ifdef __MMI_SUBLCD__
  1745.     /*----------------------------------------------------------------*/
  1746.     /* Local Variables                                                */
  1747.     /*----------------------------------------------------------------*/
  1748.     S16 count;
  1750.     /*----------------------------------------------------------------*/
  1751.     /* Code Body                                                      */
  1752.     /*----------------------------------------------------------------*/
  1753.     for (count = 0; ((count < MAX_SUBLCD_HISTORY) && ((count <= NodeIndex) && (NodeIndex != -1))); count++)
  1754.     {
  1755.         if (SubLCDHistoryData[count].scrnID == scrnId)
  1756.         {
  1757.             return SubLCDHistoryData[count].guiBuffer;
  1758.         }
  1759.     }
  1760. #endif /* __MMI_SUBLCD__ */ 
  1761.     return NULL;
  1762. }
  1765. /*****************************************************************************
  1766.  * FUNCTION
  1767.  *  GetPreviousSubLCDScrnIdOf
  1768.  * DESCRIPTION
  1769.  *  Queries previous scrn id of this Id
  1770.  * PARAMETERS
  1771.  *  scrnId              [IN]        
  1772.  *  previousScrnId      [?]         
  1773.  *  scrnid(?)           [IN]        
  1774.  * RETURNS
  1775.  *  FuncPtr
  1776.  *****************************************************************************/
  1777. pBOOL GetPreviousSubLCDScrnIdOf(U16 scrnId, U16 *previousScrnId)
  1778. {
  1779. #ifdef __MMI_SUBLCD__
  1780.     /*----------------------------------------------------------------*/
  1781.     /* Local Variables                                                */
  1782.     /*----------------------------------------------------------------*/
  1783.     S16 count;
  1785.     /*----------------------------------------------------------------*/
  1786.     /* Code Body                                                      */
  1787.     /*----------------------------------------------------------------*/
  1788.     for (count = 0; ((count < MAX_SUBLCD_HISTORY) && ((count <= NodeIndex) && (NodeIndex != -1))); count++)
  1789.     {
  1790.         if (SubLCDHistoryData[count].scrnID == scrnId)
  1791.         {
  1792.             if ((count - 1) >= 0)
  1793.             {
  1794.                 *previousScrnId = SubLCDHistoryData[count - 1].scrnID;
  1795.                 return MMI_TRUE;
  1796.             }
  1797.             return MMI_FALSE;
  1798.         }
  1799.     }
  1800. #endif /* __MMI_SUBLCD__ */ 
  1801.     return MMI_FALSE;
  1802. }
  1805. /*****************************************************************************
  1806.  * FUNCTION
  1807.  *  GetNextSubLCDScrnIdOf
  1808.  * DESCRIPTION
  1809.  *  Queries next scrn id of this Id
  1810.  * PARAMETERS
  1811.  *  scrnId          [IN]        
  1812.  *  nextScrnId      [?]         
  1813.  *  scrnid(?)       [IN]        
  1814.  * RETURNS
  1815.  *  FuncPtr
  1816.  *****************************************************************************/
  1817. pBOOL GetNextSubLCDScrnIdOf(U16 scrnId, U16 *nextScrnId)
  1818. {
  1819. #ifdef __MMI_SUBLCD__
  1820.     /*----------------------------------------------------------------*/
  1821.     /* Local Variables                                                */
  1822.     /*----------------------------------------------------------------*/
  1823.     S16 count;
  1825.     /*----------------------------------------------------------------*/
  1826.     /* Code Body                                                      */
  1827.     /*----------------------------------------------------------------*/
  1828.     for (count = 0; ((count < MAX_SUBLCD_HISTORY) && ((count <= NodeIndex) && (NodeIndex != -1))); count++)
  1829.     {
  1830.         if (SubLCDHistoryData[count].scrnID == scrnId)
  1831.         {
  1832.             if ((count + 1) <= NodeIndex)
  1833.             {
  1834.                 *nextScrnId = SubLCDHistoryData[count + 1].scrnID;
  1835.                 return MMI_TRUE;
  1836.             }
  1837.             return MMI_FALSE;
  1838.         }
  1839.     }
  1840. #endif /* __MMI_SUBLCD__ */ 
  1841.     return MMI_FALSE;
  1842. }
  1845. /*****************************************************************************
  1846.  * FUNCTION
  1847.  *  GetSubLCActiveScreenId
  1848.  * DESCRIPTION
  1849.  *  Get current screen id of Sub LCD
  1850.  *  
  1851.  *  This is used to clear all the interrupt event handlers
  1852.  * PARAMETERS
  1853.  *  void
  1854.  * RETURNS
  1855.  *  void
  1856.  *****************************************************************************/
  1857. U16 GetSubLCActiveScreenId(void)
  1858. {
  1859. #ifdef __MMI_SUBLCD__
  1860.     /*----------------------------------------------------------------*/
  1861.     /* Local Variables                                                */
  1862.     /*----------------------------------------------------------------*/
  1864.     /*----------------------------------------------------------------*/
  1865.     /* Code Body                                                      */
  1866.     /*----------------------------------------------------------------*/
  1867.     return gCurrTopSubLCDScrnID;
  1868. #endif /* __MMI_SUBLCD__ */ 
  1869.     return 0;
  1870. }
  1873. /*****************************************************************************
  1874.  * FUNCTION
  1875.  *  GetSubLCDExitScrnId
  1876.  * DESCRIPTION
  1877.  *  Gets current exit screen id of Sub LCD
  1878.  * PARAMETERS
  1879.  *  void
  1880.  *  U16(?)      [IN]        Scrnid
  1881.  * RETURNS
  1882.  *  FuncPtr
  1883.  *****************************************************************************/
  1884. U16 GetSubLCDExitScrnId(void)
  1885. {
  1886. #ifdef __MMI_SUBLCD__
  1887.     /*----------------------------------------------------------------*/
  1888.     /* Local Variables                                                */
  1889.     /*----------------------------------------------------------------*/
  1891.     /*----------------------------------------------------------------*/
  1892.     /* Code Body                                                      */
  1893.     /*----------------------------------------------------------------*/
  1894.     return gCurrExitSubLCDScrnID;
  1895. #endif /* __MMI_SUBLCD__ */ 
  1896.     return 0;
  1897. }
  1900. /*****************************************************************************
  1901.  * FUNCTION
  1902.  *  GetSubLCDScrnId
  1903.  * DESCRIPTION
  1904.  *  Gets the id of Sub LCD screen
  1905.  * PARAMETERS
  1906.  *  index       [IN]        
  1907.  * RETURNS
  1908.  *  FuncPtr
  1909.  *****************************************************************************/
  1910. U16 GetSubLCDScrnId(U16 index)
  1911. {
  1912. #ifdef __MMI_SUBLCD__
  1913.     /*----------------------------------------------------------------*/
  1914.     /* Local Variables                                                */
  1915.     /*----------------------------------------------------------------*/
  1917.     /*----------------------------------------------------------------*/
  1918.     /* Code Body                                                      */
  1919.     /*----------------------------------------------------------------*/
  1920.     if (index <= NodeIndex)
  1921.     {
  1922.         return (SubLCDHistoryData[index].scrnID);
  1923.     }
  1924. #endif /* __MMI_SUBLCD__ */ 
  1925.     return 0;
  1926. }
  1929. /*****************************************************************************
  1930.  * FUNCTION
  1931.  *  SubLCDHistoryDump
  1932.  * DESCRIPTION
  1933.  *  Dumps the Sub-LCD history to file or debug window
  1934.  *  
  1935.  *  SubLCDHistoryDump will be used for dbugging purposes
  1936.  * PARAMETERS
  1937.  *  void
  1938.  * RETURNS
  1939.  *  void
  1940.  *****************************************************************************/
  1941. void SubLCDHistoryDump(void)
  1942. {
  1943. #ifdef __MMI_SUBLCD__
  1944.     /*----------------------------------------------------------------*/
  1945.     /* Local Variables                                                */
  1946.     /*----------------------------------------------------------------*/
  1947.     S16 count = 0;
  1949.     /*----------------------------------------------------------------*/
  1950.     /* Code Body                                                      */
  1951.     /*----------------------------------------------------------------*/
  1952.     if (NodeIndex >= 0)
  1953.     {
  1954.         count = NodeIndex;
  1956.         do
  1957.         {
  1958.             MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_DUMP_HDLR,
  1959.                        count, SubLCDHistoryData[count].scrnID, SubLCDHistoryData[count].entryFuncPtr));
  1961.             if (count > 0 && count < MAX_SUBLCD_HISTORY)
  1962.             {
  1963.                 --count;
  1964.             }
  1965.             else
  1966.             {
  1967.                 break;
  1968.             }
  1970.         } while ((count != NodeIndex) && (SubLCDHistoryData[count].entryFuncPtr != NULL));
  1971.     }
  1973.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_SUBHIST_DUMP_ROOTHDLR));
  1975. #endif /* __MMI_SUBLCD__ */ 
  1976. }
  1978. #ifdef __MMI_UI_TAB_PANE__
  1981. /*****************************************************************************
  1982.  * FUNCTION
  1983.  *  disable_subLCD_history_saving
  1984.  * DESCRIPTION
  1985.  *  Disable SubLCD history saving
  1986.  * PARAMETERS
  1987.  *  void
  1988.  * RETURNS
  1989.  *  void
  1990.  *****************************************************************************/
  1991. void disable_subLCD_history_saving(void)
  1992. {
  1993.     /*----------------------------------------------------------------*/
  1994.     /* Local Variables                                                */
  1995.     /*----------------------------------------------------------------*/
  1997.     /*----------------------------------------------------------------*/
  1998.     /* Code Body                                                      */
  1999.     /*----------------------------------------------------------------*/
  2000. #ifdef __MMI_SUBLCD__
  2001.     disable_subLCD_history_save = 1;
  2002. #endif 
  2003. }
  2006. /*****************************************************************************
  2007.  * FUNCTION
  2008.  *  enable_subLCD_history_saving
  2009.  * DESCRIPTION
  2010.  *  Enables SubLCD history saving
  2011.  * PARAMETERS
  2012.  *  void
  2013.  * RETURNS
  2014.  *  void
  2015.  *****************************************************************************/
  2016. void enable_subLCD_history_saving(void)
  2017. {
  2018.     /*----------------------------------------------------------------*/
  2019.     /* Local Variables                                                */
  2020.     /*----------------------------------------------------------------*/
  2022.     /*----------------------------------------------------------------*/
  2023.     /* Code Body                                                      */
  2024.     /*----------------------------------------------------------------*/
  2025. #ifdef __MMI_SUBLCD__
  2026.     disable_subLCD_history_save = 0;
  2027. #endif 
  2028. }
  2031. /*****************************************************************************
  2032.  * FUNCTION
  2033.  *  change_curr_subLCD_gui_buffer
  2034.  * DESCRIPTION
  2035.  *  Changes the current subLCD gui buffer of the current screen
  2036.  *  
  2037.  *  This is used by tab pane as as tab pane history is on top of the screen.
  2038.  * PARAMETERS
  2039.  *  gui_buffer      [?]     
  2040.  * RETURNS
  2041.  *  void
  2042.  *****************************************************************************/
  2043. void change_curr_subLCD_gui_buffer(U8 *gui_buffer)
  2044. {
  2045. #ifdef __MMI_SUBLCD__
  2046.     /*----------------------------------------------------------------*/
  2047.     /* Local Variables                                                */
  2048.     /*----------------------------------------------------------------*/
  2050.     /*----------------------------------------------------------------*/
  2051.     /* Code Body                                                      */
  2052.     /*----------------------------------------------------------------*/
  2053.     if (SubLCDHistoryData[NodeIndex].guiBuffer != NULL)
  2054.     {
  2055.         memcpy(SubLCDHistoryData[NodeIndex].guiBuffer, gui_buffer, MAX_GUI_BUFFER);
  2056.     }
  2057. #endif /* __MMI_SUBLCD__ */ 
  2058. }
  2059. #endif /* __MMI_UI_TAB_PANE__ */