contentLister/inc/control.h File Reference

control - handle input and keep state More...

#include "lister.h"
#include "gtkErrorScreen.h"
#include "metadataStoreManager.h"

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_contentLister
Defines
#define	CATEGORIES_LIST   (-1)
#define	CF_ID   "CF"
#define	SD_ID   "SD"
#define	USB_ID   "USB"
#define	MAIN_MEMORY_ID   "MAIN"
#define	RECENT_DOCS_ID   "RECENT"
#define	ITEM_SELECT_TIMEOUT   6
#define	ITEM_SELECT_TIMER_INTERVAL   500
#define	ITEM_SELECT_TIMEOUT_TICKS   ((ITEM_SELECT_TIMEOUT * 1000) / ITEM_SELECT_TIMER_INTERVAL)
#define	BG_CONNECT_RETRY_INTERVAL   5
#define	PINCODE_MAX_IDLE_TIME   (5*60*1000)
#define	ILLEGAL_FILENAME_CHARS   "*?/\\\"<>:|";
#define	CONTENTLISTER_GROUP   "CONTENTLISTER"
#define	DO_SHARE_KEY   "doc_sharing"
#define	DO_SIGN_KEY   "doc_signing"
#define	MODE_MENU_REFERENCE_MATERIALS_DIRNAME   "_reference/"
#define	ERROR_STRING_BUFLEN   256
Typedefs
typedef struct _contentLister	ContentLister
Enumerations
enum	ctrlScanType_e { ctrlScanCurrent = 0, ctrlScanPrevious = 1, ctrlScanNext = 2 }
enum	listerState_t {   STATE_NORMAL = 0, STATE_USB_CONNECTED, STATE_DOWNLOADMGR, STATE_MISC,   STATE_PINCODE, STATE_LANG_SEL, STATE_LAST }
enum	e_ctrl_connect_reason_t {   connect_manual, connect_background, connect_from_pincode, connect_after_reboot,   connect_timed_ids_with_sw, connect_timed_ids_content_only, connect_timed_ids_background }
Functions
ContentLister *	ctrlInit (GtkWidget *topLevelWindow)
void	ctrlSetScreenTexts (void)
void	ctrlDestroy (ContentLister *contentLister)
void	ctrl_listItem_clicked (int index, gpointer data)
st_ContentType_e	ctrl_get_storageType (gchar *szExtID)
void	ctrl_storage_changed (st_ContentType_e storageType, gboolean storagePresent)
void	ctrl_contentType_button_clicked (st_ContentType_e type)
void	ctrl_goto_page (int pagenumber)
void	ctrl_connect_button_clicked (void)
void	ctrl_disconnect (connectScr_e screen)
void	ctrl_disconnect_wait (void)
void	ctrl_background_connect_timeout_start (gboolean read_settings)
void	ctrl_set_connect_icon (void)
void	ctrl_new_content_received (void)
void	ctrl_mode_button_long_clicked (void)
void	ctrl_usbmode_keypress (void)
void	ctrl_rescan_current (void)
unsigned int	ctrl_get_item_index (ContentLister *theContentLister)
int	ctrl_before_file_clicked (clDisplayItem_t *theItem)
void	ctrl_mode_button_clicked (void)
void	ctrl_display_download_history (void)
void	ctrl_cleanup_download_history (void)
void	ctrl_battery_low_screen (gint percentage, gint time_left, gboolean shutdown)
void	ctrl_on_icon_clicked (int iconID, int iconState)
void	ctrl_on_lock_screen_clicked (int iconState)
void	ctrl_on_toolbar_synchronised ()
void	ctrl_show_lister_area (void)
void	ctrl_hide_lister_area (void)
void	ctrl_hide_misc_screen (void)
listerState_t	getListerState ()
void	setListerState (listerState_t newstate)
gboolean	listerIsErrorScreenVisible (void)
void	listerHideErrorScreen (void)
void	listerShowErrorScreen (ctrlErrorType_e errorType)
void	listerShowUSBScreen (void)
void	listerHideUSBScreen (void)
void	ctrl_update_pagebar (void)
void	ctrl_shutdown (void)
void	ctrl_display_search_result (void)
void	ctrl_hide_search_wnd (void)
const char *	ctrl_get_abscurr_location (char *sPath, int iSize)
gboolean	ctrl_location_is_outbox (const char *location)
void	ctrl_pincode_setting_init (void)
void	ctrl_show_pincode_screen (showPincodeReason_t reason, on_passed_callback_t *on_passed_callback, on_cancel_callback_t *on_cancel_callback)
void	ctrl_hide_pincode_screen (void)
gboolean	ctrl_pincode_is_for_locking (void)
void	ctrl_pincode_overview_button_clicked (void)
void	ctrl_pincode_connect_button_clicked (void)
void	ctrl_pincode_button_clicked (void)
gboolean	ctrl_is_connect_from_pincode (void)
void	ctrl_connect_back_to_pincode_screen (void)
void	ctrl_startup (void)
void	ctrl_export_config (void)
void	ctrl_handle_import_config (void)
gboolean	on_idle_connect_start_background (gpointer p)
void	ctrl_connect (connectScr_e screen, e_ctrl_connect_reason_t reason)

---

Detailed Description

control - handle input and keep state

<File description>="">

Definition in file control.h.

---

Define Documentation

#define BG_CONNECT_RETRY_INTERVAL   5

Definition at line 57 of file control.h.

#define CATEGORIES_LIST   (-1)

Definition at line 42 of file control.h.

#define CF_ID   "CF"

Definition at line 45 of file control.h.

#define CONTENTLISTER_GROUP   "CONTENTLISTER"

Definition at line 66 of file control.h.

#define DO_SHARE_KEY   "doc_sharing"

Definition at line 67 of file control.h.

#define DO_SIGN_KEY   "doc_signing"

Definition at line 68 of file control.h.

#define ERROR_STRING_BUFLEN   256

Definition at line 72 of file control.h.

#define ILLEGAL_FILENAME_CHARS   "*?/\\\"<>:|";

Definition at line 63 of file control.h.

#define ITEM_SELECT_TIMEOUT   6

Definition at line 52 of file control.h.

#define ITEM_SELECT_TIMEOUT_TICKS   ((ITEM_SELECT_TIMEOUT * 1000) / ITEM_SELECT_TIMER_INTERVAL)

Definition at line 54 of file control.h.

#define ITEM_SELECT_TIMER_INTERVAL   500

Definition at line 53 of file control.h.

#define MAIN_MEMORY_ID   "MAIN"

Definition at line 48 of file control.h.

#define MODE_MENU_REFERENCE_MATERIALS_DIRNAME   "_reference/"

Definition at line 70 of file control.h.

#define PINCODE_MAX_IDLE_TIME   (5*60*1000)

Definition at line 59 of file control.h.

#define RECENT_DOCS_ID   "RECENT"

Definition at line 49 of file control.h.

#define SD_ID   "SD"

Definition at line 46 of file control.h.

#define USB_ID   "USB"

Definition at line 47 of file control.h.

---

Typedef Documentation

typedef struct _contentLister ContentLister

---

Enumeration Type Documentation

enum ctrlScanType_e

Enumerator:

ctrlScanCurrent
ctrlScanPrevious
ctrlScanNext

Definition at line 74 of file control.h.

{
    ctrlScanCurrent = 0,
    ctrlScanPrevious = 1,
    ctrlScanNext = 2,
} ctrlScanType_e;

enum e_ctrl_connect_reason_t

Enumerator:

connect_manual
connect_background
connect_from_pincode
connect_after_reboot
connect_timed_ids_with_sw
connect_timed_ids_content_only
connect_timed_ids_background

Definition at line 118 of file control.h.

{
    connect_manual,
    connect_background,
    connect_from_pincode,
    connect_after_reboot,
    connect_timed_ids_with_sw,
    connect_timed_ids_content_only,
    connect_timed_ids_background
} e_ctrl_connect_reason_t;

enum listerState_t

Enumerator:

STATE_NORMAL
STATE_USB_CONNECTED
STATE_DOWNLOADMGR
STATE_MISC
STATE_PINCODE
STATE_LANG_SEL
STATE_LAST

Definition at line 107 of file control.h.

             {
    STATE_NORMAL = 0,
    STATE_USB_CONNECTED,
    STATE_DOWNLOADMGR,
    STATE_MISC,// combine rename, search, sort states into one state STATE_MISC
    STATE_PINCODE,
    STATE_LANG_SEL,
    STATE_LAST
} listerState_t;

---

Function Documentation

void ctrl_background_connect_timeout_start

(

gboolean

read_settings

)

Definition at line 428 of file control.c.

{
    CL_LOGPRINTF("entry: read_settings [%d]", read_settings);

    ctrl_background_connect_timeout_start_withinterval(read_settings, FALSE, 0);
}

Here is the call graph for this function:

void ctrl_battery_low_screen	(	gint	percentage,
		gint	time_left,
		gboolean	shutdown
	)

Definition at line 2134 of file control.c.

{
    static int ignore_count = 0;

    CL_CONTROLPRINTF("entry: percentage [%d] time_left [%d]", percentage, time_left);

    // We don't do anything with the battery status at the moment...

    if (shutdown && g_errorTypeDisplayed == ctrlBatteryLowError)
    {
        ctrl_shutdown();
    }
    else if (   ctrl_is_connect_from_pincode()
             && ignore_count < 2               ) 
    {
        ignore_count++;
    }
    else
    {
        ignore_count = 0;
        listerShowErrorScreen(ctrlBatteryLowError);
    }
}

Here is the call graph for this function:

int ctrl_before_file_clicked

(

clDisplayItem_t *

theItem

)

Definition at line 3136 of file control.c.

{
    CL_LOGPRINTF("entry: szFilename [%s] szFileExt [%s]", theItem->szFilename, theItem->szFileExt);

    int ret = -1;               // -1 = error, 0 = ok

    if (strlen(theItem->szFilename) >= ERMDS_MAX_FILENAME_SIZE)
    {
        CL_ERRORPRINTF("Filename too long: [%s]", theItem->szFilename);
        return ret;
    }

    // maximum tries for file rename, arbitary value
    static const int MAX_COUNT = 5;
    char * viewer_id;

    int  i;
    char dirname [    ERMDS_MAX_FILENAME_SIZE            ];
    char filename[    ERMDS_MAX_FILENAME_SIZE            ];
    char tmp_file[    ERMDS_MAX_FILENAME_SIZE + MAX_COUNT];
    char new_dir [    ERMDS_MAX_FILENAME_SIZE            ];
    char new_file[2 * ERMDS_MAX_FILENAME_SIZE            ];
    char new_fil2[    ERMDS_MAX_FILENAME_SIZE            ];

    // 1. get extname, filename and dirname    
    char *name      = strrchr(theItem->szFilename, '/');
    char *extension = theItem->szFileExt;    
    if (name == NULL  || extension == NULL  || strlen(name) <= strlen(extension))
    {
        // it must be a fatal error, ignore this file
        CL_ERRORPRINTF("No extension or file name error!");
        return ret;
    }
    name++;

    i = strlen(theItem->szFilename) - strlen(name);
    strncpy(dirname, theItem->szFilename, i);
    dirname[i] = '\0';

    // verify if the path is trusted, otherwise we will *not* create the
    // manifest
    if (ctrl_is_trusted_path(dirname) == NULL)
    {
        CL_ERRORPRINTF("The fully qualified path [%s] is not trusted, not creating manifest", dirname);
        return ret;
    }

    // check if for this path we cannot create manifest folders
    if (ctrl_not_create_manifest(dirname))
    {
        CL_ERRORPRINTF("Configured to not create manifest folder for [%s]", dirname);
        return ret;
    }

    strcpy(filename, name);     // including extension

    // 2. check. we only handle the file we can handle
    if (!ctrl_check_extension(extension))
    {
        CL_ERRORPRINTF("Invalid extension: [%s]", extension);
        return ret;
    }
    
    // 3. create directory and move file if needed
    // Determine new directory and filename
    sprintf(new_dir,  "%s%s",    dirname, filename);
    sprintf(new_file, "%s%s/%s", dirname, filename, filename);
    if (strlen(new_file) >= ERMDS_MAX_FILENAME_SIZE)
    {
        CL_ERRORPRINTF("Filename too long to make it a container: [%s]", theItem->szFilename);
        return ret;
    }
    // before we create the dir, we need to change the file name
    // otherwise the dir will not be created successfully
    strcpy(tmp_file, theItem->szFilename);
    for(i = 0; i < MAX_COUNT; ++i)
    {
        strcat(tmp_file, "_");
        if (!ctrl_file_exist(tmp_file))
        {
            rename(theItem->szFilename, tmp_file);
            break;
        }
    }
    if (MAX_COUNT == i)
    {
        // could not change filename
        CL_ERRORPRINTF("Could not change name to %s", tmp_file);
        return ret;
    }
    //
    // create dir now                
    if (0 != mkdir(new_dir, 0755))
    {
        CL_ERRORPRINTF("Can not create directory for this content!");             
        rename(tmp_file, theItem->szFilename);
        return ret;
    }
    if (0 != rename(tmp_file, new_file))
    {
        // restore the file name and remove dir
        rmdir(new_dir);
        rename(tmp_file, theItem->szFilename);
        CL_ERRORPRINTF("Can not move file!");             
        return ret;
    }

    // if this is Mobipocket, check if there is a *.mbp file with the same name
    viewer_id = pm_getUaID(extension);
    if (viewer_id  &&  strcmp(viewer_id, "MOBIPOCKET") == 0)
    {
        struct stat file_stat;

        // strip extension
        char * tmp;
        char * fname = strdup(filename);
        tmp = strrchr(fname, '.');
        if (tmp) *tmp = '\0';

        snprintf(tmp_file, sizeof(tmp_file), "%s%s.%s", dirname, fname, "mbp");
        snprintf(new_fil2, sizeof(new_fil2), "%s%s/%s.%s", dirname, filename, fname, "mbp");
        free(fname);
        if (stat(tmp_file, &file_stat) == 0 && S_ISREG(file_stat.st_mode))
        {
            CL_CONTROLPRINTF("Going to rename %s to %s", tmp_file, new_fil2);
            if (rename(tmp_file, new_fil2) != 0)
            {
                unlink(tmp_file);
                CL_ERRORPRINTF("Could not move %s, deleted it instead!", tmp_file);
            }
        }
    }
        
    // update the file name, so that it can be open successfully
    strncpy(theItem->szFilename, new_file, ERMDS_MAX_FILENAME_SIZE);
    
    // 4. create the manifest file 
    ctrl_create_manifest(theItem, new_dir, filename);
    
    // 5. change item to mdsFitContainer
    theItem->fit = mdsFitContainer;

    ret = 0;
    return ret;
}

Here is the call graph for this function:

void ctrl_cleanup_download_history

(

void

)

Definition at line 1979 of file control.c.

{
    char   dirname[ERMDS_MAX_FILENAME_SIZE];

    if ( mdsGetRootLocation(st_DownloadHistory, dirname, sizeof(dirname)) > 0 )
    {
        // remove dangling symlinks
        hsCleanupSymlinks(dirname);

        // restrict the number of symlinks
        hsLimitSymlinks(dirname, MAX_DOWNLOAD_ITEMS);
    }
}

Here is the call graph for this function:

void ctrl_connect	(	connectScr_e	screen,
		e_ctrl_connect_reason_t	reason
	)

Definition at line 1755 of file control.c.

{
    CL_LOGPRINTF("entry: reason [%d]", reason);

    gboolean use_last_connected  = FALSE;
    gboolean background          = FALSE;
    gboolean content_only        = FALSE;
    gchar*   content_uuid        = NULL;
    gboolean from_pincode_screen = FALSE;
    gboolean force_ids           = FALSE;
    gboolean after_reboot        = FALSE;

    switch (reason)
    {
        case connect_manual:
            break;
        case connect_background:
            use_last_connected  = TRUE;
            background          = TRUE;
            content_only        = TRUE;
            break;
        case connect_from_pincode:
            use_last_connected  = TRUE;
            content_only        = TRUE;
            content_uuid        = "reset-pin-code";
            from_pincode_screen = TRUE;
            force_ids           = TRUE;
            break;
        case connect_after_reboot:
            use_last_connected  = TRUE;
            force_ids           = TRUE;
            after_reboot        = TRUE;
            break;
        case connect_timed_ids_with_sw:
            force_ids           = TRUE;
            break;
        case connect_timed_ids_content_only:
            content_only        = TRUE;
            force_ids           = TRUE;
            break;
        case connect_timed_ids_background:
            use_last_connected  = TRUE;
            background          = TRUE;
            content_only        = TRUE;
            force_ids           = TRUE;
            break;
        default:
            CL_ERRORPRINTF("Illegal reason [%d]", reason);
            return;
    }

    if (    gContentLister->currentError == ctrlNoError
         && connectStruct.state          == connectStateIdle )
    {
        // Show toolbar icon "connected"
        toolbar_setIconState(iconID_connect, iconState_selected);

        // Put contentlister on top
        if ( background )
        {
            toolbar_synchronise();
        }
        else
        {
            const char* UaOnTop = pm_getUaOnTop();
            CL_CONTROLPRINTF("UaOnTop = %s", UaOnTop);
            if ((strncmp(UaOnTop, CONTENTLISTER_UAID, UAID_MAX_SIZE) != 0))
            {
                // contentLister not "On Top" => show contentlister
                CL_CONTROLPRINTF("CL NOT on top - current type was = %d", gContentLister->currentContentType);
                pm_RaiseContentLister();
            }
            setListerState(STATE_DOWNLOADMGR);
            pm_setUaOnTop(PROFILES_APP);  // set connection mgr as application-on-top, so key events will be sent here
            toolbar_restore();
        }

        // Block USB connect while connectionMgr running
        erStopMSDiskApp();

        // Start the connectionMgr, 
        // who connects to the IDS server
        // end then starts the downloadMgr
        snprintf( connectStruct.szCommand,
                  sizeof(connectStruct.szCommand),
                  "%s%s%s%s%s%s%s%s",
                  CONNECTIONMGR_EXECUTABLE,
                  use_last_connected ? " --use-last-connected"   : "",
                  background         ? " --background"           : "",
                  content_only       ? " --content-only"         : "",
                  content_uuid       ? " --content-uuid "        : "",
                  content_uuid       ?   content_uuid            : "",
                  force_ids          ? " --connect-ids"          : "",
                  after_reboot       ? " --connect-after-reboot" : ""  );

        connectStruct.screen               = screen;
        connectStruct.background           = background;
        connectStruct.connect_from_pincode = from_pincode_screen;
        connectStruct.connect_after_reboot = after_reboot;
        connectStruct.command              = connectCmdStart;
        pthread_mutex_unlock( &(connectStruct.mutex) );
    }
    else
    {
        CL_SCREENPRINTF("cannot connect now");
        display_update_request_screen_refresh(MAIN_WINDOW_EXPOSE_LEVEL);
    }
}

Here is the call graph for this function:

void ctrl_connect_back_to_pincode_screen

(

void

)

Definition at line 3799 of file control.c.

{
    ContentLister *theContentLister = gContentLister;
    char *UaOnTop = NULL;
    showPincodeReason_t reason;

    g_return_if_fail(NULL != theContentLister);
    g_return_if_fail(NULL != theContentLister->pincodeScreen);

    // set contentliser to STATE_PINCODE
    setListerState(STATE_PINCODE);

    // when finishing downloading reset pincode,  we should continue accumulate_idle_time

    // re-read pincode from sysset
    // from pincode screen user can connect to iDS and download a pincode reset package
    ctrl_pincode_setting_init();

    reason = gtk_pincode_screen_get_reason(theContentLister->pincodeScreen);
    if (reason != startup_t)
    {
        UaOnTop = pm_getUaOnTop();
        CL_CONTROLPRINTF("UaOnTop = %s", UaOnTop);
        if ((strncmp(UaOnTop, CONTENTLISTER_UAID, UAID_MAX_SIZE) != 0))
        {
            // contentLister not "On Top" => show contentlister 
            CL_CONTROLPRINTF("CL NOT on top");
            pm_RaiseContentLister();
        }
    }

    display_update_request_screen_refresh(MAIN_WINDOW_EXPOSE_LEVEL);
}

Here is the call graph for this function:

void ctrl_connect_button_clicked

(

void

)

Definition at line 1744 of file control.c.

{
    CL_LOGPRINTF("entry");

    // stop background connect, to avoid conflicts
    ctrl_disconnect_wait();

    // connect to iDS
    ctrl_connect(connectScrDownloadHistory, connect_manual);
}

Here is the call graph for this function:

void ctrl_contentType_button_clicked

(

st_ContentType_e

type

)

category button selected

Parameters:

data

- reference contentLister data

Returns:

-

Definition at line 1650 of file control.c.

{
    ContentLister *theContentLister = gContentLister;
    clDisplayItem_t theItem;
    const gboolean cl_OnTop = (strcmp(pm_getUaOnTop(), CONTENTLISTER_UAID) == 0) ? TRUE : FALSE;
    const gboolean dm_OnTop = (strcmp(pm_getUaOnTop(), PROFILES_APP      ) == 0) ? TRUE : FALSE;
    char *location;

    // check whether contentlister is visible
    CL_CONTROLPRINTF("entry: theContentLister [%p] type [%d] UaOnTop [%s]", theContentLister, theContentType, pm_getUaOnTop());
    if ( !cl_OnTop )
    {
        // contentLister not "On Top" => scan current content and show contentlister 
        CL_CONTROLPRINTF("CL NOT on top - current type was = %d", theContentLister->currentContentType);

        theContentLister->previousContentType = theContentLister->currentContentType;
        theContentLister->currentContentType = theContentType;
        // change acording to design, do not record history
        stackClear(theContentType);

        pm_RaiseContentLister();

        if (dm_OnTop)
        {
            // This scan_content only needed after download manager,
            // because the sigchld handler already rescans (see programMgr.c)
            ctrl_scan_content(theContentLister, ctrlScanCurrent, NULL);
        }
    }
    else
    {
        // contentLister is "On Top"
        if (theContentType != theContentLister->currentContentType)
        {
            // contentLister "On Top" but different contentType => scan
            // new contentType 
            CL_CONTROLPRINTF
                ("CL on top - current type (%d) != theContentType (%d)",
                 theContentLister->currentContentType, theContentType);

            if (getListerState() == STATE_MISC)
            {
                ctrl_hide_misc_screen();
            }
            ctrl_select_stop(TRUE);

            theContentLister->previousContentType = theContentLister->currentContentType;
            theContentLister->currentContentType  = theContentType;
            // change acording to design, do not record history
            stackClear(theContentType);

            ctrl_scan_content(theContentLister, ctrlScanCurrent, NULL);
        }
        else if (theContentLister->currentError != ctrlNoError)
        {
            CL_CONTROLPRINTF("currentError %d", theContentLister->currentError);
            ctrl_scan_content(theContentLister, ctrlScanCurrent, NULL);
        }
        else if (g_select.active)
        {
            ctrl_select_stop(TRUE);
            toolbar_synchronise();
        }
        else if (getListerState() == STATE_MISC)
        {
            ctrl_hide_misc_screen();
        }
        else
        {
            CL_CONTROLPRINTF("CL on top - current type (%d) == theContentType", theContentLister->currentContentType);

            CL_HISTORYPRINTF("Goto last read content of the contentType %d", theContentType);

            hsGetItem(theContentType, &theItem);
            location = hsGetLocation(theContentType);

            CL_HISTORYPRINTF("hsGetLocation (for %d) returned %s",
                             theContentType, (location == NULL) ? "NULL" : location);

            if (ctrl_start_viewer(theContentLister->currentContentType, &theItem, location) == FALSE)
            {
                CL_CONTROLPRINTF("ctrl_start_viewer returned FALSE");
                ctrl_scan_content(theContentLister, ctrlScanCurrent, NULL);
            }

            if (location)
            {
                g_free(location);
                location = NULL;
            }
        }
    }
}

Here is the call graph for this function:

void ctrl_disconnect

(

connectScr_e

screen

)

Definition at line 1864 of file control.c.

{
    CL_LOGPRINTF("entry: screen [%d]", screen);
    
    if (connectStruct.state == connectStateConnected)
    {
        connectStruct.screen  = screen;
        connectStruct.command = connectCmdStop;
    }
}

void ctrl_disconnect_wait

(

void

)

Definition at line 1875 of file control.c.

{
    CL_LOGPRINTF("entry");
    
    ctrl_disconnect(connectStruct.screen);

    while (connectStruct.state != connectStateIdle)
    {
        CL_WARNPRINTF("Waiting for connectStateIdle [%d], current state [%d]", connectStateIdle, connectStruct.state);
        sleep(1);
    }
}

Here is the call graph for this function:

void ctrl_display_download_history

(

void

)

Definition at line 1946 of file control.c.

{
    ContentLister *theContentLister = gContentLister;
    char *UaOnTop;

    CL_CONTROLPRINTF("entry 0x%x", (unsigned int)theContentLister);

    // back to the download history menu 
    CL_CONTROLPRINTF("Back to the download history menu");
    theContentLister->previousContentType = theContentLister->currentContentType;
    theContentLister->currentContentType = st_DownloadHistory;
    if (g_new_content_received)
    {
        g_new_content_acknowledged = TRUE;
    }

    ctrl_cleanup_download_history();

    // reset the st_DownloadHistory stack
    stackClear(theContentLister->currentContentType);
    // always display the first page
    mdsSetIndex(theContentLister->currentContentType, 0);
    ctrl_scan_content(theContentLister, ctrlScanCurrent, NULL);
    UaOnTop = pm_getUaOnTop();
    CL_CONTROLPRINTF("UaOnTop = %s", UaOnTop);
    if ((strncmp(UaOnTop, CONTENTLISTER_UAID, UAID_MAX_SIZE) != 0))
    {
        // contentLister not "On Top" => show contentlister 
        CL_CONTROLPRINTF("CL NOT on top");
        pm_RaiseContentLister();
    }
}

Here is the call graph for this function:

void ctrl_display_search_result

(

void

)

Definition at line 3092 of file control.c.

{
    CL_SEARCHPRINTF("entry");

    gContentLister->previousContentType = gContentLister->currentContentType;
    gContentLister->currentContentType = st_SearchResult;

    // reset the st_SearchResult stack, always display the first page
    stackClear(gContentLister->currentContentType);
    mdsSetIndex(gContentLister->currentContentType, 0);
    ctrl_scan_content(gContentLister, ctrlScanCurrent, NULL);

    char *UaOnTop = pm_getUaOnTop();
    CL_SEARCHPRINTF("UaOnTop = %s", UaOnTop);
    if ((strncmp(UaOnTop, CONTENTLISTER_UAID, UAID_MAX_SIZE) != 0))
    {
        // contentLister not "On Top" => show contentlister 
        CL_SEARCHPRINTF("CL NOT on top");
        pm_RaiseContentLister();
    }
}

Here is the call graph for this function:

void ctrl_export_config

(

void

)

const char* ctrl_get_abscurr_location	(	char *	sPath,
		int	iSize
	)

Definition at line 3451 of file control.c.

{
    memset(sPath, 0, iSize);
    if (0 >= mdsGetRootLocation(gContentLister->currentContentType, sPath, iSize))
    {
        return sPath;
    }

    stItem_t *pItem = stackPeek(gContentLister->currentContentType);
    if (NULL != pItem)
    {
        mdsDirectory_t *directory = &g_array_index(pItem->dirArray, mdsDirectory_t, 0);
        if (directory)
        {
            return directory->szFilename;
        }
    }
    return sPath;
}

Here is the call graph for this function:

unsigned int ctrl_get_item_index

(

ContentLister *

theContentLister

)

Definition at line 1050 of file control.c.

{
    unsigned int itemIndex;
    int pageIndex;

    pageIndex = (theContentLister->currentPage - 1);
    if (pageIndex < 0)
    {
        pageIndex = 0;
    }

    itemIndex = (pageIndex * MAX_ITEMS_ON_ONE_PAGE);
    if (itemIndex >= 0)
    {
        itemIndex += theContentLister->currentFocus;
    }

    CL_CURSORPRINTF ("item index %d (current page %d, pageindex %d, currentFocus %d)",
                                 itemIndex,       theContentLister->currentPage,
                                                                pageIndex,       theContentLister->currentFocus);

    return itemIndex;
}

st_ContentType_e ctrl_get_storageType

(

gchar *

szExtID

)

Definition at line 1022 of file control.c.

{
    st_ContentType_e theType = st_ContentTypeUndefined;

    if (strncmp(szExtID, CF_ID, ERMDS_MAX_EXTENSION_ID_SIZE) == 0)
    {
        theType = st_StorageTypeCF;
    }
    else if (strncmp(szExtID, SD_ID, ERMDS_MAX_EXTENSION_ID_SIZE) == 0)
    {
        theType = st_StorageTypeSD;
    }
    else if (strncmp(szExtID, USB_ID, ERMDS_MAX_EXTENSION_ID_SIZE) == 0)
    {
        theType = st_StorageTypeUSB;
    }
    else if (strncmp(szExtID, MAIN_MEMORY_ID, ERMDS_MAX_EXTENSION_ID_SIZE) == 0)
    {
        theType = st_StorageTypeMain;
    }
    else if (strncmp(szExtID, RECENT_DOCS_ID, ERMDS_MAX_EXTENSION_ID_SIZE) == 0)
    {
        theType = st_RecentDocuments;
    }

    return theType;
}

void ctrl_goto_page

(

int

pagenumber

)

Jump to the specified page number, in case the page number is invalid keep the current status and update the status information

Parameters:

pagenumber

the requested page number

Returns:

--

Definition at line 1534 of file control.c.

{
    CL_SCREENPRINTF("entry: pagenum [%d]", pagenumber);

    int startindex;
    int req_cnt = MAX_ITEMS_ON_ONE_PAGE;
    ContentLister *theContentLister = gContentLister;

    if (   getListerState() == STATE_MISC
        && GTK_WIDGET_VISIBLE(theContentLister->distListWnd))
    {
        dist_list_wnd_goto_page(pagenumber);
    }
    else if ((pagenumber > 0) && (pagenumber != theContentLister->currentPage)
             && (pagenumber <= theContentLister->pagecount))
    {
        theContentLister->currentPage = pagenumber;
        startindex = MAX_ITEMS_ON_ONE_PAGE * (pagenumber - 1);

        ctrl_select_stop(TRUE);

        // retrieve new page content
        mdsSetPageContent(theContentLister->items, startindex, &req_cnt);

        // update the stored index value
        mdsSetIndex(theContentLister->currentContentType, startindex);

        theContentLister->itemCount = req_cnt;
        theContentLister->currentFocus = 0;
        ctrl_display_item_view(theContentLister);
    }
    else
    {
        erbusy_off();
    }
}

Here is the call graph for this function:

void ctrl_handle_import_config

(

void

)

void ctrl_hide_lister_area

(

void

)

Definition at line 2766 of file control.c.

{
    if (gContentLister->listerArea)
    {
        gtk_widget_hide(gContentLister->listerArea);
    }
}

void ctrl_hide_misc_screen

(

void

)

Definition at line 2117 of file control.c.

{
    CL_CONTROLPRINTF("entry");

    if (getListerState() == STATE_MISC)
    {
        ctrl_metadata_editor_close(FALSE);
        ctrl_hide_search_wnd();
        ctrl_hide_sort_wnd(FALSE);
        ctrl_hide_sel_list_wnd(gContentLister, FALSE);
    }
    else
    {
        ctrl_select_stop(TRUE);
    }
}

Here is the call graph for this function:

void ctrl_hide_pincode_screen

(

void

)

Definition at line 3655 of file control.c.

{
    showPincodeReason_t reason;
    CL_LOGPRINTF("PINCODE screen hide");

    ContentLister *theContentLister = gContentLister;
    if (g_listerState != STATE_PINCODE)
    {
        return;
    }

    if (theContentLister && theContentLister->pincodeScreen && GTK_WIDGET_VISIBLE(theContentLister->pincodeScreen))
    {
        // => only request a refresh on the main window expose event
        CL_SCREENPRINTF("");
        display_update_increase_level(MAIN_WINDOW_EXPOSE_LEVEL);

        gtk_window_unfullscreen(GTK_WINDOW(theContentLister->topLevelWindow));
        gtk_widget_show(GTK_WIDGET(theContentLister->listerScreen ));
        gtk_widget_hide(GTK_WIDGET(theContentLister->errorScreen  ));
        gtk_widget_hide(GTK_WIDGET(theContentLister->pincodeScreen));
        gtk_widget_grab_focus(GTK_WIDGET(theContentLister->listerArea));

        reason = gtk_pincode_screen_get_reason(theContentLister->pincodeScreen);
        if (reason != startup_t)
        {
            if ((strncmp (restoreUaOnTop, CONTENTLISTER_UAID, UAID_MAX_SIZE) != 0)) 
            { 
                pm_RaiseUserApp (restoreUaOnTop);
                strncpy (restoreUaOnTop, CONTENTLISTER_UAID, sizeof(restoreUaOnTop)); 
            } 
        }
        if (   reason != startup_t
            && reason != enterSettings_t)
        {
            erStartMSDiskApp();
        }
    }

    // when hide pincode screen, 
    // and set contentlister to be normal state
    // and enable usb connect with pc
    // and end to accumulate idle time
    setListerState(STATE_NORMAL);
    accumulate_idle_time_end();
}

Here is the call graph for this function:

void ctrl_hide_search_wnd

(

void

)

Definition at line 3032 of file control.c.

{
    CL_SEARCHPRINTF("entry");

    if ( (getListerState() == STATE_MISC) 
         && (gContentLister->searchWnd)
         && GTK_WIDGET_VISIBLE(gContentLister->searchWnd) )
    {
        // update toolbar, hide keyboard
        toolbar_disableUpdate();
        toolbar_setIconState(iconID_search,   iconState_normal);
        toolbar_setIconState(iconID_sort,     iconState_normal);
        toolbar_setIconState(iconID_share,    iconState_normal);
        toolbar_setIconState(iconID_tagging,  iconState_normal);
        toolbar_setIconState(iconID_trashcan, iconState_normal);
        ctrl_hide_keyboard(iconState_grey);
        toolbar_enableUpdate();

        // show contentlister page
        gtk_widget_hide(GTK_WIDGET(gContentLister->searchWnd));
        gtk_widget_grab_focus(GTK_WIDGET(gContentLister->listerArea));
        setListerState(STATE_NORMAL);
        ctrl_rescan_current();
    }
}

Here is the call graph for this function:

gboolean ctrl_is_connect_from_pincode

(

void

)

Definition at line 3786 of file control.c.

{
    gboolean bRet = FALSE;
   
    if (   getListerState() == STATE_DOWNLOADMGR
        && connectStruct.connect_from_pincode   )
    {
        bRet = TRUE;
    }
    CL_LOGPRINTF("return %d", bRet);
    return bRet;
}

Here is the call graph for this function:

void ctrl_listItem_clicked	(	int	index,
		gpointer	data
	)

Gtk list item clicked callback routine

Parameters:

	data	index of the item in the pageitem list
	reference	passed during lsInit

Returns:

-

Definition at line 634 of file control.c.

{
    ContentLister    *theContentLister = (ContentLister *) data;
    clDisplayItem_t  *theItem;
    int              itemIndex = 0;
    st_ContentType_e storageType;
    gboolean         ret;

    CL_CONTROLPRINTF("Entry: index [%d]", index);

    // action required only when content lister in normal state and visible
    if (   g_listerState != STATE_NORMAL
        || strcmp(pm_getUaOnTop(), CONTENTLISTER_UAID) != 0)
    {
        CL_WARNPRINTF("Ignore because contentLister in special state or not visible");
        return;
    }

    if (g_select.active)
    {
        // select mode: blink or hide cursor for this item
        if (g_select.item_selected[index])
        {
            g_select.item_selected[index] = FALSE;
            cursor_set_state(index, e_cursor_hide);
            cursor_redraw();
        }
        else
        {
            g_select.item_selected[index] = TRUE;
            cursor_set_state(index, e_cursor_blink);
            cursor_redraw();

            if ( !g_select.confirm_with_icon )
            {
                g_select.icon_clicked = TRUE;
            }
        }

        // restart the select timeout
        g_select.ticks = ITEM_SELECT_TIMEOUT_TICKS;
    }
    else if ( !ctrl_current_location_is_outbox() )
    {
        // Not in select mode: open the item
        erbusy_blink();

        theItem = &theContentLister->items[index];

        // position cursor on the selected item
        ctrl_listItem_focus(index, theContentLister);

        // update the stored index value
        itemIndex = ctrl_get_item_index(theContentLister);
        mdsSetIndex(theContentLister->currentContentType, itemIndex);

        // now act on the selected item
        switch (theItem->fit)
        {
            case mdsFitFolder:
                ctrl_scan_content(theContentLister, ctrlScanNext, theItem->szFilename);
                break;

            case mdsFitApplication:
                CL_CONTROLPRINTF("mdsFitApplication");
                // before enter setup, ask user input pincode
                if (0 == strcmp(theItem->szExtID, SETUP_APP))
                {
                    gboolean enable = FALSE;
                    gchar pincode[PINCODE_MAX_LENGTH + 1];

                    gtk_pincode_screen_get_pincode_settings(theContentLister->pincodeScreen, &enable, pincode);
                    if (FALSE == enable || 0 == strlen(pincode))
                    {
                        ctrl_start_application(theItem->szExtID, NULL);
                    }
                    else
                    {
                        ctrl_show_pincode_screen(enterSettings_t, ctrl_start_setup, NULL);
                    }
                }
                else
                {
                    ctrl_start_application(theItem->szExtID, NULL);
                }
                break;

            case mdsFitManifestDirectory:
                CL_CONTROLPRINTF("mdsFitManifestDirectory -> %s", theItem->szFilename);
                ctrl_scan_content(theContentLister, ctrlScanNext, theItem->szFilename);
                break;

            case mdsFitStorage:
                storageType = ctrl_get_storageType(theItem->szExtID);

                if (stackIsStorage(storageType) == TRUE)
                {
                    CL_CONTROLPRINTF("scan storage type %d", storageType);

                    // update the contentType
                    theContentLister->previousContentType = theContentLister->currentContentType;
                    theContentLister->currentContentType = storageType;
                    ctrl_scan_content(theContentLister, ctrlScanCurrent, 0);
                }
                else
                {
                    CL_ERRORPRINTF("invalid storage type");
                }
                break;
                
            case mdsFitContainer:
                ret = ctrl_start_viewer(theContentLister->currentContentType, theItem, NULL);
                if (ret == FALSE)
                {
                    // Not busy!
                    erbusy_off();
                }
                break;
                
            case mdsFitFile:
                ctrl_before_file_clicked(theItem);
                ret = ctrl_start_viewer(theContentLister->currentContentType, theItem, NULL);
                if (ret == FALSE)
                {
                    // Not busy!
                    erbusy_off();
                }
                break;

            case mdsFitSymlink:
            default:
                CL_ERRORPRINTF("theItem->fit %d - UNKNOWN", theItem->fit);
        }
    }
}

Here is the call graph for this function:

gboolean ctrl_location_is_outbox

(

const char *

location

)

Definition at line 3471 of file control.c.

{
    if ( location != NULL && strncmp(location, "/" OUTBOX_NAME, 1 + strlen(OUTBOX_NAME)) == 0 )
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

void ctrl_mode_button_clicked

(

void

)

Definition at line 1894 of file control.c.

{
    ContentLister *theContentLister = gContentLister;
    char *UaOnTop;

    CL_CONTROLPRINTF("entry 0x%x", (unsigned int)theContentLister);

    UaOnTop = pm_getUaOnTop();

    CL_CONTROLPRINTF("UaOnTop = %s", UaOnTop);

    if ((strncmp(UaOnTop, CONTENTLISTER_UAID, UAID_MAX_SIZE) != 0))
    {
        // contentLister not "On Top" => scan mode directory content and
        // show contentlister 
        CL_CONTROLPRINTF("CL NOT on top");
        theContentLister->previousContentType = theContentLister->currentContentType;
        theContentLister->currentContentType = st_MenuTypeMode;
        // reset the st_MenuTypeMode stack
        stackClear(theContentLister->currentContentType);

        pm_RaiseContentLister();

        // Disabled this scan_content, because the signal handler already
        // rescans (see programMgr.c)
        // ctrl_scan_content(theContentLister, ctrlScanCurrent, NULL);
        CL_CONTROLPRINTF("Not scanning content, this will be done in the sigchld handler");
    }
    else
    {
        // contentLister "On Top" => scan new contentType 
        CL_CONTROLPRINTF("CL on top - current type (%d)", theContentLister->currentContentType);

        if ((theContentLister->currentError != ctrlNoError) && (stackIsStorage(theContentLister->currentContentType)))
        {
            CL_CONTROLPRINTF("Error screen for storage (%d)", theContentLister->currentContentType);
            ctrl_scan_content(theContentLister, ctrlScanCurrent, NULL);
        }
        else
        {
            // back to the mode menu 
            CL_CONTROLPRINTF("Back to mode menu");
            ctrl_hide_misc_screen();
            theContentLister->previousContentType = theContentLister->currentContentType;
            theContentLister->currentContentType = st_MenuTypeMode;
            // reset the st_MenuType1 stack
            stackClear(theContentLister->currentContentType);
            ctrl_scan_content(theContentLister, ctrlScanCurrent, NULL);
        }
    }
}

Here is the call graph for this function:

void ctrl_mode_button_long_clicked

(

void

)

Definition at line 1889 of file control.c.

{
    ctrl_display_recent_documents();
}

Here is the call graph for this function:

void ctrl_new_content_received

(

void

)

Definition at line 464 of file control.c.

{
    CL_LOGPRINTF("entry");

    g_new_content_received     = TRUE;
    g_new_content_acknowledged = FALSE;
}

void ctrl_on_icon_clicked	(	int	iconID,
		int	iconState
	)

Definition at line 2599 of file control.c.

{
    CL_TBPRINTF("entry: iconID [%d] iconState [%d]", iconID, iconState);

    if (   g_select.active
        && iconID    == g_select.iconID
        && iconState == iconState_selected)
    {
        // icon clicked again -> listitem select procedure ends
        // Note: ipc messages like toolbar icon clicked are received on a separate thread, therefore the current
        //       function is NOT called on the GTK thread, so the order of events cannot be guaranteed.
        //       More precisely: pen-click listitem, pen-click toolbar icon sometimes is received in the inverse order.
        //       To avoid these issues we set a flag, which is checked by the timer function who then ends the select.
        g_select.icon_clicked = TRUE;
    }
    else
    {
        // icon actions regardless the icon state
        switch (iconID)
        {
            case iconID_search:
                ctrl_on_search_clicked(iconState);
                break;

            case iconID_sort:
                ctrl_on_sort_clicked(iconState);
                break;

            case iconID_locked:
                switch (iconState)
                {
                    case iconState_normal:
                        toolbar_setIconState(iconID_locked, iconState_selected);
                        toolbar_synchronise();
                        break;
                    case iconState_selected:
                        toolbar_setIconState(iconID_locked, iconState_normal);
                        toolbar_synchronise();
                        break;
                    case iconState_grey:
                        // ignore
                        break;
                    default:
                        CL_ERRORPRINTF("iconID_locked: state [%d] unknown", iconState);
                }
                break;

            case iconID_lock_screen:
                ctrl_on_lock_screen_clicked(iconState);
                break;

            case iconID_connect:
                switch (iconState)
                {
                    case iconState_normal:
                    case iconState_IDconnect_time:
                        ctrl_background_connect_timeout_start_withinterval(FALSE, TRUE, 0);
                        break;
                    case iconState_selected:
                        ctrl_disconnect(connectScrUnchanged);
                        break;
                    case iconState_IDconnect_newcontent:
                        ctrl_display_download_history();
                        break;
                    case iconState_IDconnect_newcontent_selected:
                        g_new_content_received = FALSE;
                        ctrl_set_connect_icon();
                        toolbar_synchronise();
                        break;
                    default:
                        CL_ERRORPRINTF("iconID_connect state [%d] unknown", iconState);
                }
                break;

            default:
                break; //ignore
        }

        // icon actions for icon state normal
        if (iconState == iconState_normal)
        {
            switch (iconID)
            {
                case iconID_share:
                    ctrl_select_listitem(iconID_share, FALSE, ctrl_listItem_share);
                    break;

                case iconID_tagging:
                    ctrl_select_listitem(iconID_tagging, FALSE, ctrl_listItem_edit);
                    break;
                
                case iconID_trashcan:
                    ctrl_select_listitem(iconID_trashcan, TRUE, ctrl_listItem_delete);
                    break;

                default:
                    break;  // ignore
            }
        }

        // icon actions for icon state selected
        if (iconState == iconState_selected)
        {
            switch (iconID)
            {
                case iconID_share:
                    ctrl_doc_share_now(gContentLister);
                    break;

                case iconID_tagging:
                    ctrl_metadata_editor_close(TRUE);
                    break;

                default:
                    break;  // ignore
            }
        }
    }
}

Here is the call graph for this function:

void ctrl_on_lock_screen_clicked

(

int

iconState

)

Definition at line 3833 of file control.c.

{
    CL_IPCPRINTF("entry: iconState [%d]", iconState);

    switch (iconState)
    {
    case iconState_normal:
    // change icon to "selected",
//        toolbar_setIconState(iconID_lock_screen, iconState_selected);
//        toolbar_synchronise();
    ctrl_lock_screen();
    break;

//    case iconState_selected:
    // change icon to "normal",
//        toolbar_setIconState(iconID_lock_screen, iconState_normal);
//        toolbar_synchronise();
    break;

    default:
        /*
        * ignore 
        */ ;
    }
}

Here is the call graph for this function:

void ctrl_on_toolbar_synchronised

(

)

Definition at line 2739 of file control.c.

{
    int i;

    CL_IPCPRINTF("entry");

    display_update_request_screen_refresh(TOOLBAR_UPDATE_LEVEL);

    // call functions for registered on_toolbar_sync_actions
    for (i = 0; i < sizeof(on_toolbar_sync_actions) / sizeof(on_toolbar_sync_actions[0]); i++)
    {
        if (on_toolbar_sync_actions[i] != NULL)
        {
            on_toolbar_sync_actions[i] ();
            on_toolbar_sync_actions[i] = NULL;
        }
    }
}

Here is the call graph for this function:

void ctrl_pincode_button_clicked

(

void

)

Definition at line 3780 of file control.c.

{
    accumulate_idle_time_reset();
    erbusy_off();
}

Here is the call graph for this function:

void ctrl_pincode_connect_button_clicked

(

void

)

Definition at line 3759 of file control.c.

{
    gboolean bIsForLocking;

    accumulate_idle_time_reset();

    bIsForLocking = ctrl_pincode_is_for_locking();
    if (!bIsForLocking)
    {
        erbusy_off();
        return;
    }
    
    CL_LOGPRINTF("Connect from PINCODE...");
    // when downloading, we should remove accumulate_idle_time
    // to prevent shutdown device due to idle
    accumulate_idle_time_end();

    ctrl_connect(connectScrUnchanged, connect_from_pincode);
}

Here is the call graph for this function:

gboolean ctrl_pincode_is_for_locking

(

void

)

Definition at line 3702 of file control.c.

{
    gboolean bIsForLocking=TRUE;
    ContentLister *theContentLister;
    showPincodeReason_t reason;
    
    theContentLister = gContentLister;
    if (NULL == theContentLister)
        return bIsForLocking;
    if (NULL == theContentLister->pincodeScreen)
        return bIsForLocking;
    reason = (showPincodeReason_t)gtk_pincode_screen_get_reason(theContentLister->pincodeScreen);
    switch (reason)
    {
        case startup_t:
        case lockScreen_t:
            bIsForLocking = TRUE;
        break;
        
        case signDocument_t:
        case enterSettings_t:
        case importSettings_t:
            bIsForLocking = FALSE;
        break;
        
        default:
            bIsForLocking = TRUE;
    }
    return bIsForLocking;
}

Here is the call graph for this function:

void ctrl_pincode_overview_button_clicked

(

void

)

Definition at line 3738 of file control.c.

{
   showPincodeReason_t reason;
   gboolean bIsForLocking;

    accumulate_idle_time_reset();

    bIsForLocking = ctrl_pincode_is_for_locking();
    if (bIsForLocking)
    {
        erbusy_off();
        return;
    }

    ContentLister *theContentLister = gContentLister;
    reason = gtk_pincode_screen_get_reason(theContentLister->pincodeScreen);
    ctrl_hide_pincode_screen();
    gtk_pincode_screen_on_cancel_callback(theContentLister->pincodeScreen);
}

Here is the call graph for this function:

void ctrl_pincode_setting_init

(

void

)

Definition at line 3564 of file control.c.

{
    gboolean enable = FALSE;
    gchar pincode[PINCODE_MAX_LENGTH + 1];
    ContentLister *theContentLister = gContentLister;

    g_return_if_fail(NULL != theContentLister);
    g_return_if_fail(NULL != theContentLister->pincodeScreen);
    sysset_read_pincode_onoff(&enable);
    sysset_read_pincode_string(pincode);
    
    gtk_pincode_screen_set_pincode_settings(theContentLister->pincodeScreen, enable, pincode);
    ctrl_pincode_set_toolbar_icon();
}

Here is the call graph for this function:

void ctrl_rescan_current

(

void

)

Definition at line 1638 of file control.c.

{
    CL_CONTROLPRINTF("entry: currentError [%d]", gContentLister->currentError);

    if (gContentLister->currentError == ctrlNoError)
    {
        CL_CONTROLPRINTF("rescan folder only, current content type = %d", gContentLister->currentContentType);
        ctrl_scan_content(gContentLister, ctrlScanCurrent, NULL);
    }
}

Here is the call graph for this function:

void ctrl_set_connect_icon

(

void

)

Definition at line 435 of file control.c.

{

    CL_LOGPRINTF("entry");
    
    // update connect-state on toolbar
    if (g_new_content_received)
    {
        if (gContentLister->currentContentType == st_DownloadHistory)
        {
            toolbar_setIconState(iconID_connect, 
                g_new_content_acknowledged ? iconState_IDconnect_newcontent_selected : iconState_IDconnect_newcontent);
        }
        else if (g_new_content_acknowledged)
        {
            toolbar_setIconState(iconID_connect, g_background_connect_enable ? iconState_IDconnect_time : iconState_normal);
            g_new_content_received = FALSE;
        }
        else
        {
            toolbar_setIconState(iconID_connect, iconState_IDconnect_newcontent);
        }
    }
    else
    {
        toolbar_setIconState(iconID_connect, g_background_connect_enable ? iconState_IDconnect_time : iconState_normal);
    }
}

Here is the call graph for this function:

void ctrl_show_lister_area

(

void

)

Definition at line 2758 of file control.c.

{
    if (gContentLister->listerArea)
    {
        gtk_widget_show(gContentLister->listerArea);
    }
}

void ctrl_show_pincode_screen	(	showPincodeReason_t	reason,
		on_passed_callback_t *	on_passed_callback,
		on_cancel_callback_t *	on_cancel_callback
	)

Definition at line 3579 of file control.c.

{
    CL_LOGPRINTF("PINCODE screen show");

    ContentLister *theContentLister = gContentLister;
    char *UaOnTop = NULL;

    g_return_if_fail(theContentLister != NULL);
    g_return_if_fail(theContentLister->pincodeScreen != NULL);
    g_return_if_fail(g_listerState != STATE_PINCODE);

    if (reason != startup_t)
    {
        // abort miscellaneous contentLister windows
        ctrl_hide_misc_screen();

        // bring contentlister on top
        UaOnTop = pm_getUaOnTop ();
        CL_CONTROLPRINTF ("%s on top", UaOnTop);
        strncpy (restoreUaOnTop, UaOnTop, sizeof (restoreUaOnTop)); 
        if ((strncmp (UaOnTop, CONTENTLISTER_UAID, UAID_MAX_SIZE) != 0)) 
        { 
            // contentLister not "On Top" => show contentlister 
            CL_CONTROLPRINTF ("CL NOT on top");
            display_update_increase_level(NO_DISPLAY_UPDATE_LEVEL);
            pm_RaiseContentLister (); 
        }
    }

    if (GTK_WIDGET_VISIBLE(theContentLister->pincodeScreen) == FALSE)
    {
        // => only request a refresh on the main window expose event
        CL_SCREENPRINTF("Display pincode screen");
        if (display_update_get_level() == NO_DISPLAY_UPDATE_LEVEL)
        {
            display_update_decrease_level(MAIN_WINDOW_EXPOSE_LEVEL);
        }
        else
        {
            display_update_increase_level(MAIN_WINDOW_EXPOSE_LEVEL);
        }
        gtk_window_fullscreen(GTK_WINDOW(theContentLister->topLevelWindow));
        gtk_widget_hide(GTK_WIDGET(theContentLister->listerScreen ));
        gtk_widget_hide(GTK_WIDGET(theContentLister->errorScreen  ));
        gtk_widget_show(GTK_WIDGET(theContentLister->pincodeScreen));
        gtk_widget_grab_focus(GTK_WIDGET(theContentLister->pincodeScreen));
    }
    // it's possible user change or reset pincode after we create gtkPincdeScreen
    ctrl_pincode_setting_init();

    // when show pincode screen
    // and disable usb connect with pc
    // and begin to accumulate idle time 
    // and reset the pincode passed

    // attention: when launched downloadMgr, will change contentlister status to STATE_DOWNLOADMGR
    setListerState(STATE_PINCODE);
    erStopMSDiskApp();
   
    accumulate_idle_time_set_callback(ctrl_pincode_idle_time_callback);
    accumulate_idle_time_set_threshold(PINCODE_MAX_IDLE_TIME);
    gtk_pincode_screen_layout_reset(theContentLister->pincodeScreen);
    gtk_pincode_screen_data_reset(theContentLister->pincodeScreen);
    gtk_pincode_screen_set_reason(theContentLister->pincodeScreen, reason);
    gtk_pincode_screen_set_on_passed_callback(theContentLister->pincodeScreen, on_passed_callback);

    if (ctrl_pincode_is_for_locking())
    {
        gtk_pincode_screen_set_on_cancel_callback(theContentLister->pincodeScreen, NULL);
    }
    else
    {
        gtk_pincode_screen_set_on_cancel_callback(theContentLister->pincodeScreen, on_cancel_callback);
    }
}

Here is the call graph for this function:

void ctrl_shutdown

(

void

)

Definition at line 3384 of file control.c.

{
    CL_WARNPRINTF("entry");

    g_shutdownPending = TRUE;

    // keep busy led on
    erbusy_shutdown();

    // block all keys
    button_block_all_keys(TRUE);
    
    // hide pincode screen
    ctrl_hide_pincode_screen();

    // show a "System will shutdown now message"
    listerShowErrorScreen(ctrlSystemShutdownError);

    // store last view content logging data before killing the
    // contentLister process
    ctrlDestroy(gContentLister);

    // re-create RTC alarm if needed
    timed_ids_final();

    // stop usb export of filesystem
    erStopMSDiskApp();

    // and stop the system
    system("halt");

    CL_WARNPRINTF("end");
}

Here is the call graph for this function:

void ctrl_startup

(

void

)

Definition at line 4159 of file control.c.

{
    CL_CONTROLPRINTF("entry");
    
    gboolean      enable = FALSE;
    gchar         pincode[PINCODE_MAX_LENGTH + 1];   
    ContentLister *theContentLister = gContentLister;

    static gboolean firsttime = TRUE;

    g_return_if_fail(theContentLister != NULL);
    g_return_if_fail(g_shutdownPending == FALSE);

    // If user hasn't set language yet or the current language hasn't been installed,
    // run 'setup --select-language-only' to let user set language.
    // Do this only once, user may exit setup without selecting a language.
    if (firsttime  &&  !languageSelected())
    {
        setListerState(STATE_LANG_SEL);
        display_update_increase_level(NO_DISPLAY_UPDATE_LEVEL);
        gtk_idle_add(ctrl_on_idle_select_language, (gpointer)FALSE);
    }
    else
    {
        // read the pincode settings
        sysset_read_pincode_onoff(&enable);
        sysset_read_pincode_string(pincode);

        gtk_pincode_screen_set_pincode_settings(theContentLister->pincodeScreen, enable, pincode);
        if (enable  &&  strlen(pincode) > 0)
        {
            CL_LOGPRINTF("PINCODE on-show pincode screen");
            ctrl_show_pincode_screen(startup_t, ctrl_start_up_behaviour, NULL);
        }
        else
        {
            CL_LOGPRINTF("PINCODE off or empty - user customized start-up behaviour");
            ctrl_pincode_set_toolbar_icon();
            ctrl_start_up_behaviour();
        }
    }

    firsttime = FALSE;
    CL_CONTROLPRINTF("leave");
}

Here is the call graph for this function:

void ctrl_storage_changed	(	st_ContentType_e	storageType,
		gboolean	storagePresent
	)

A storage module has been inserted or removed

Parameters:

	storage	module identification
	1/0	= module present yes/no

Returns:

-

Definition at line 770 of file control.c.

{
    ContentLister *theContentLister = gContentLister;
    
    CL_CONTROLPRINTF("Entry: storageType [%d] Present [%d]", storageType, storagePresent);

    if (storagePresent)
    {
        // if the archive locations are redirected to the storage device,
        // check the archive folders exits or not, if not create them
        mdsRecreateArchives(storageType);
    }

    if (theContentLister != NULL 
        && (theContentLister->currentContentType == storageType 
            || mdsArcLocIsChanged(theContentLister->currentContentType, storageType)) )
    {
        if (!storagePresent)
        {
            ctrl_hide_misc_screen();
        }
        ctrl_select_stop(TRUE);

        if (stackIsStorage(storageType) == TRUE)
        {
            CL_CONTROLPRINTF("scan storage type %d", storageType);
            stackClear(theContentLister->currentContentType);
            ctrl_scan_content(theContentLister, ctrlScanCurrent, NULL);
        }
        else
        {
            CL_ERRORPRINTF("invalid storage type");
        }
    }

    erMSDisk_storage_changed(storageType, storagePresent);
}

Here is the call graph for this function:

void ctrl_update_pagebar

(

void

)

void ctrl_usbmode_keypress

(

void

)

Definition at line 2171 of file control.c.

{
    CL_CONTROLPRINTF("entry");

    ctrl_errorScreen_buttonpress(NULL, NULL, gContentLister);
}

Here is the call graph for this function:

void ctrlDestroy

(

ContentLister *

contentLister

)

destroy contentlister modules - clean up allocated memory and store the loggin information in Flash

Parameters:

contentLister

reference contentLister data

Returns:

-

Definition at line 472 of file control.c.

{
    g_return_if_fail(contentLister != NULL);

    // TODO : store the last read content 

    // destroy the history information
    hsDestroy();

    pm_DestroyProgramManager();

    // store the loggin information 
    // g_free(contentLister);

    // free page content
    // mdsDestroy();

    // free pixmaps
    // icons_destroy();
}

Here is the call graph for this function:

ContentLister* ctrlInit

(

GtkWidget *

topLevelWindow

)

Init contentlister modules/data : - init meta data store (logging information)

• init screen layout
• init button handling
• init history data
• init IPC communication
• allocate ContentLister, for maintaining state

Parameters:

window

reference to the top level window

Returns:

reference to contentLister structure, NULL in case of failure

Definition at line 195 of file control.c.

{
    ContentLister *theContentLister = NULL;
    guint         signal_id;

    // create one theContentLister struct and fill it with zeros
    theContentLister = g_new0(ContentLister, 1);
    theContentLister->topLevelWindow = topLevelWindow;
    gContentLister = theContentLister;

    // init the connect fsm thread
    erConnectInit(&connectStruct);

    // init the msdisk application
    erMSDiskInit();

    // load the frequently used icons
    icons_init();

    // init the meta data store (including the contenttype history/stack)
    mdsInit();

    // init the history information
    hsInit();

    viewerInstallIpcServer();

    // whether or not the viewers are actually there is not important
    // during the init phase
    viewerInit(BROWSER_APP);

    erbusy_init();
    pagebar_init();
    toolbar_init();

    // power Manager init
    // MvdW: power manager disabled for now, needs more testing...
    // power_init();

    // init content key handling
    button_init(theContentLister);

    // init the program manager
    if (pm_InitProgramManager() != TRUE)
    {
        CL_ERRORPRINTF("Error initializing programManager, this will most likely cause a crash...");
    }

    // init the screen layout
    ctrl_init_screen_layout(topLevelWindow, theContentLister);
    theContentLister->lister = lsInit(theContentLister->listerArea, theContentLister);
    create_content_metadata_wnd(theContentLister->contentEditWnd);
    create_search_wnd(theContentLister->searchWnd);
    create_sort_wnd(theContentLister->sortWnd);
    create_dist_list_wnd(theContentLister->distListWnd);
    ctrlSetScreenTexts();

    // install class-specific screen update handlers
    //   erGtkEntry
    signal_id = g_signal_lookup("screen-refresh", ERGTK_ENTRY_TYPE);
    g_assert(signal_id > 0);
    g_signal_add_emission_hook(signal_id, 0, hook_screen_refresh_typing, (gpointer)TEXTENTRY_CHANGED_LEVEL, NULL);
    //   erGtkToggleButton
    signal_id = g_signal_lookup("toggled", ERGTK_TOGGLE_BUTTON_TYPE);
    g_assert(signal_id > 0);
    g_signal_add_emission_hook(signal_id, 0, hook_screen_refresh_typing, (gpointer)TEXTENTRY_CHANGED_LEVEL, NULL);

    cursor_init(theContentLister);

    theContentLister->itemCount = 0;
    theContentLister->currentContentType = st_ContentTypeUndefined;
    theContentLister->previousContentType = st_ContentTypeUndefined;
    theContentLister->currentFocus = 0;
    theContentLister->pagecount = 0;
    theContentLister->currentPage = 0;
    theContentLister->currentError = ctrlNoError;

    // Re-connect to server when requested
    gboolean do_connect = FALSE;
    int err = scGet_Reconnect(&do_connect);
    if (err == 0 && do_connect)
    {
        display_update_increase_level(NO_DISPLAY_UPDATE_LEVEL);
        g_idle_add(on_idle_connect_start, NULL);
    }
    else if (get_timedids_connect_reason() == connect_after_wakeup)
    {
        // iLiad is waken up by RTC alarm, need to connect to iDS
        display_update_increase_level(NO_DISPLAY_UPDATE_LEVEL);
        g_idle_add(on_timedids_connect_after_wakeup, NULL);
    }
    else
    {
        // Normal startup actions: select language, open QuickRef, etc.
        ctrl_startup();
    }

    return theContentLister;
}

Here is the call graph for this function:

void ctrlSetScreenTexts

(

void

)

Set fixed screen texts

Definition at line 307 of file control.c.

{
    content_metadata_set_text();
    search_wnd_set_text();
    sort_wnd_set_text();
}

Here is the call graph for this function:

listerState_t getListerState

(

)

Definition at line 2062 of file control.c.

{
    CL_CONTROLPRINTF("return [%d]", g_listerState);
    return g_listerState;
}

void listerHideErrorScreen

(

void

)

Definition at line 2367 of file control.c.

{
    CL_CONTROLPRINTF("entry");

    if (gContentLister && listerIsErrorScreenVisible())
    {
        // hide error screen
        // => only request a refresh on the main window expose event
        CL_SCREENPRINTF("");
        display_update_increase_level(MAIN_WINDOW_EXPOSE_LEVEL);
        
        if (ctrl_is_connect_from_pincode())
        {
            setListerState(STATE_PINCODE);
        }

        if (STATE_PINCODE == getListerState())
        {
            CL_WARNPRINTF("hide error, show pincode");
            gtk_window_fullscreen(GTK_WINDOW(gContentLister->topLevelWindow));
            gtk_widget_hide(GTK_WIDGET(gContentLister->listerScreen ));
            gtk_widget_hide(GTK_WIDGET(gContentLister->errorScreen  ));
            gtk_widget_show(GTK_WIDGET(gContentLister->pincodeScreen));
            gtk_widget_grab_focus(GTK_WIDGET(gContentLister->pincodeScreen));
        }
        else
        {
            CL_WARNPRINTF("hide error, show listArea");
            gtk_window_unfullscreen(GTK_WINDOW(gContentLister->topLevelWindow));
            gtk_widget_show(GTK_WIDGET(gContentLister->listerScreen ));
            gtk_widget_hide(GTK_WIDGET(gContentLister->errorScreen  ));
            gtk_widget_hide(GTK_WIDGET(gContentLister->pincodeScreen));
            gtk_widget_grab_focus(GTK_WIDGET(gContentLister->listerArea));
        }
        g_errorTypeDisplayed = ctrlNoError;
        
        if ((strncmp(restoreUaOnTop, CONTENTLISTER_UAID, UAID_MAX_SIZE) != 0))
        {
            pm_RaiseUserApp(restoreUaOnTop);
            strncpy(restoreUaOnTop, CONTENTLISTER_UAID, sizeof(restoreUaOnTop));
        }

        if (g_idle_check_battery_id > 0)
        {
            g_source_remove(g_idle_check_battery_id);
            g_idle_check_battery_id = 0;
        }
    }
}

Here is the call graph for this function:

void listerHideUSBScreen

(

void

)

Definition at line 2100 of file control.c.

{
    CL_CONTROLPRINTF("entry");

    if (gContentLister)
    {
        if (gContentLister->currentError == ctrlNoError)
        {
            listerHideErrorScreen();
        }
        else
        {
            listerShowErrorScreen(gContentLister->currentError);
        }
    }
}

Here is the call graph for this function:

gboolean listerIsErrorScreenVisible

(

void

)

Definition at line 2158 of file control.c.

{
    gboolean ret = FALSE;

    if (gContentLister->errorScreen)
    {
        ret = GTK_WIDGET_VISIBLE(gContentLister->errorScreen);
    }

    CL_CONTROLPRINTF("return [%d]", ret);
    return ret;
}

void listerShowErrorScreen

(

ctrlErrorType_e

errorType

)

Definition at line 2240 of file control.c.

{
    char *UaOnTop;

    CL_SCREENPRINTF("entry: errorType [%d]", errorType);

    if (gContentLister)
    {
        toolbar_disableUpdate();

        // abort miscellaneous contentLister windows
        ctrl_hide_misc_screen();
        toolbar_setIconState(iconID_search,   iconState_grey);
        toolbar_setIconState(iconID_sort,     iconState_grey);
        toolbar_setIconState(iconID_share,    iconState_grey);
        toolbar_setIconState(iconID_tagging,  iconState_grey);
        toolbar_setIconState(iconID_trashcan, iconState_grey);

        // hide keyboard
        ctrl_hide_keyboard(iconState_grey);
        toolbar_enableUpdate();

        // bring contentlister on top
        UaOnTop = pm_getUaOnTop();
        strncpy(restoreUaOnTop, UaOnTop, sizeof(restoreUaOnTop));
        if ((strncmp(UaOnTop, CONTENTLISTER_UAID, UAID_MAX_SIZE) != 0))
        {
            display_update_increase_level(NO_DISPLAY_UPDATE_LEVEL);
            CL_SCREENPRINTF("restoreUaOnTop=%s", restoreUaOnTop);
            pm_RaiseContentLister();
        }

        const char* card_name = NULL;
        char buf[ERROR_STRING_BUFLEN];
        switch (errorType)
        {
            case ctrlConnectedUSBError:
                gtk_error_screen_set_text(GTK_ERROR_SCREEN(gContentLister->errorScreen), _("Connected to PC..."));
                gtk_error_screen_set_image(GTK_ERROR_SCREEN(gContentLister->errorScreen), ctrlDontDisconnectNWIcon);
                break;

            case ctrlExportingDevUnavailError:
                switch (get_exported_memory_type())
                {
                    case expMMC:
                        card_name = _("MMC card");
                        break;
                    case expUSB:
                        card_name = _("USB stick");
                        break;
                    case expCF:
                        card_name = _("CF card");
                        break;
                    default:
                        break;
                }
                snprintf(buf, ERROR_STRING_BUFLEN, _("Connected to PC.\nThe %s storage is not available, Internal Memory is exported instead."), card_name);

                gtk_error_screen_set_text(GTK_ERROR_SCREEN(gContentLister->errorScreen), buf);
                gtk_error_screen_set_image(GTK_ERROR_SCREEN(gContentLister->errorScreen), ctrlWarningIcon);
                break;

            case ctrlBatteryLowError:
                gtk_error_screen_set_text(GTK_ERROR_SCREEN(gContentLister->errorScreen),
                        _("Your battery is almost empty, please connect the power adapter to keep working."));
                gtk_error_screen_set_image(GTK_ERROR_SCREEN(gContentLister->errorScreen), ctrlBatteryLowIcon);
                g_idle_check_battery_id = g_idle_add(idle_CheckBattery_HideErrorScreen, NULL);
                break;

            case ctrlSystemShutdownError:
                gtk_error_screen_set_text(GTK_ERROR_SCREEN(gContentLister->errorScreen),
                        _("The iLiad is preparing for power down."));
                gtk_error_screen_set_image(GTK_ERROR_SCREEN(gContentLister->errorScreen), ctrlSystemShutdownIcon);
                break;

            case ctrlScanTooManyItemsError:
                gtk_error_screen_set_text(GTK_ERROR_SCREEN(gContentLister->errorScreen),
                        _("There are too many items to display. Only the first 1000 items will be listed."));
                gtk_error_screen_set_image(GTK_ERROR_SCREEN(gContentLister->errorScreen), ctrlWarningIcon);
                break;

            case ctrlScanFailedError:
                gtk_error_screen_set_text(GTK_ERROR_SCREEN(gContentLister->errorScreen),
                        _("Reading of content has failed due to an unknown reason."));
                gtk_error_screen_set_image(GTK_ERROR_SCREEN(gContentLister->errorScreen), ctrlErrorIcon);
                break;

            case ctrlContentNotAvailableError:
                gtk_error_screen_set_text(GTK_ERROR_SCREEN(gContentLister->errorScreen),
                        _("Content isn't accessible any more."));
                gtk_error_screen_set_image(GTK_ERROR_SCREEN(gContentLister->errorScreen), ctrlInfoIcon);
                break;

            case ctrlNoNetworkConfiguredError:
                gtk_error_screen_set_text(GTK_ERROR_SCREEN(gContentLister->errorScreen),
                        _("No network configured."));
                gtk_error_screen_set_image(GTK_ERROR_SCREEN(gContentLister->errorScreen), ctrlErrorIcon);
                break;

            default:
                gtk_error_screen_set_text(GTK_ERROR_SCREEN(gContentLister->errorScreen),
                        _("An unknown event occurred."));
                gtk_error_screen_set_image(GTK_ERROR_SCREEN(gContentLister->errorScreen), ctrlInfoIcon);
        }
        g_errorTypeDisplayed = errorType;

        if (listerIsErrorScreenVisible() == FALSE)
        {
            // => only request a refresh on the main window expose event
            CL_SCREENPRINTF("Display error screen");
            if (display_update_get_level() == NO_DISPLAY_UPDATE_LEVEL)
            {
                display_update_decrease_level(MAIN_WINDOW_EXPOSE_LEVEL);
            }
            else
            {
                display_update_increase_level(MAIN_WINDOW_EXPOSE_LEVEL);
            }
            gtk_window_fullscreen(GTK_WINDOW(gContentLister->topLevelWindow));
            gtk_widget_hide(GTK_WIDGET(gContentLister->listerScreen ));
            gtk_widget_show(GTK_WIDGET(gContentLister->errorScreen  ));
            gtk_widget_hide(GTK_WIDGET(gContentLister->pincodeScreen));
            gtk_widget_grab_focus(GTK_WIDGET(gContentLister->errorScreen));
        }
    }
}

Here is the call graph for this function:

void listerShowUSBScreen

(

void

)

Definition at line 2086 of file control.c.

{
    CL_CONTROLPRINTF("entry");

    if (get_exported_memory_type() == get_memory_type_used())
    {
        listerShowErrorScreen(ctrlConnectedUSBError);
    }
    else
    {
        listerShowErrorScreen(ctrlExportingDevUnavailError);
    }
}

Here is the call graph for this function:

gboolean on_idle_connect_start_background

(

gpointer

p

)

Alexis 30nov07 DOWNLOADMGR_APP no longer used for manual connect, now PROFILES_APP ** else if ( strcmp(uaOnTop, DOWNLOADMGR_APP) == 0 ) { manual connect busy --> ignore CL_WARNPRINTF("Download manager active, no background connect"); }

Definition at line 323 of file control.c.

{
    CL_LOGPRINTF("entry");

    g_assert(p);

    e_ctrl_connect_reason_t connReason = (e_ctrl_connect_reason_t)p;

    const gchar* uaOnTop = pm_getUaOnTop();

    if (   strcmp(uaOnTop, PROFILES_APP) == 0
        || strcmp(uaOnTop, SETUP_APP   ) == 0
        || listerIsErrorScreenVisible()
        || g_select.active                   )
    {
        // profile editor or manual connect is running
        // or settings applicationf is running
        // or error screen is visible
        //     --> try again after retry interval
        CL_WARNPRINTF("Retry after [%d] minutes", BG_CONNECT_RETRY_INTERVAL);
        if (connReason == connect_timed_ids_background)
        {
            timed_ids_handle_recreate_timer(BG_CONNECT_RETRY_INTERVAL);
        }
        else
        {
            ctrl_background_connect_timeout_start_withinterval(FALSE, FALSE, BG_CONNECT_RETRY_INTERVAL);
        }
    }
    else
    {
        // no problems -> do background connect to iDS
        CL_WARNPRINTF("Do background connect");

        if (connReason == connect_timed_ids_background)
        {
            set_timedids_connect_reason(connect_when_running);
        }
        
        ctrl_connect(connectScrUnchanged, connReason);
    }

    return FALSE;  // don't call again
}

Here is the call graph for this function:

void setListerState

(

listerState_t

newstate

)

Definition at line 2068 of file control.c.

{
    CL_CONTROLPRINTF("entry: state old [%d] new [%d]", g_listerState, newstate);

    // need to rescan if state changes from STATE_USB_CONNECTED to normal
    if (STATE_USB_CONNECTED == g_listerState && STATE_NORMAL == newstate)
    {
        // set new state and rescan
        g_listerState = newstate; // set new state before rescan (ref. BT 802)
        CL_CONTROLPRINTF("rescan after disconnected from PC");
        ctrl_scan_content(gContentLister, ctrlScanCurrent, 0);
    }
    else
    {
        g_listerState = newstate;
    }
}

Here is the call graph for this function: