コード例 #1
0
ファイル: lxdm.c プロジェクト: carlodoro88/lxdm
static void on_session_stop(void *data,int pid, int status)
{
	int level;
	LXSession *s=data;

	lxsession_stop(s);

	level=get_run_level();
	if(level=='0' || level=='6')
	{
		if(level=='0')
			g_spawn_command_line_sync("/etc/lxdm/PreShutdown",0,0,0,0);
		else
			g_spawn_command_line_sync("/etc/lxdm/PreReboot",0,0,0,0);
		g_message("run level %c\n",level);
		lxdm_quit_self(0);
	}
	if(s!=lxsession_greeter())
	{
		lxsession_free(s);
	}
	else if(g_key_file_get_integer(config,"server","reset",NULL)==1)
	{
		lxsession_free(s);
		lxsession_greeter();
	}
	gchar *argv[] = { "/etc/lxdm/PostLogout", NULL };
	g_spawn_async(NULL, argv, s->env, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, NULL);
}
コード例 #2
0
ファイル: BIDI.c プロジェクト: 12019/mtktest
/*****************************************************************************
 * FUNCTION
 *  bidi_main
 * DESCRIPTION
 *  fill the string buffer to bidirectional algorithm
 * PARAMETERS
 *  logicalStr              [IN]        Input string for bidi
 *  logicalStrLen           [IN]        String length of input string
 *  logicalCurPos           [IN]        Current cursor position of input string
 *  visualStr               [OUT]       Final output string from bidi algorithm
 *  visualStrLen            [OUT]       String length of final output string
 *  visualCurPos            [OUT]       Cursor position of final output string
 *  fSwap                   [IN]        If true, then reserse the string after apply bidi algorithm
 *  inputMode               [IN]        
 *  logicalHilightStart     [IN]        Word hilight start position of input string
 *  logicalHilightEnd       [IN]        Word hilight end position of input string
 *  visualHilightStart      [OUT]       Word hilight start position of output string
 *  visualHilightEnd        [OUT]       Word hilight end position of output string
 * RETURNS
 *  void
 *****************************************************************************/
void bidi_main(
        U8 *logicalStr,
        U16 logicalStrLen,
        U16 logicalCurPos,
        U8 *visualStr,
        U16 *visualStrLen,
        U16 *visualCurPos,
        pBOOL fSwap,
        U8 inputMode,
        U16 logicalHilightStart,
        U16 logicalHilightEnd,
        U16 *visualHilightStart,
        U16 *visualHilightEnd)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    U8 paragraphEmbeddingLevel = 0;

#if BIDI_CONSIDER_DIFF_INPUT_METHOD_BEHAVIOR
    U8 lastType;
    pBOOL flag = FALSE;
#endif /* BIDI_CONSIDER_DIFF_INPUT_METHOD_BEHAVIOR */ 
    pBOOL bCheckFlag;
    S16 iCount, nParaCount = 0;
    U8 *pInputType = input_types;
    U8 *pInputLevels = input_levels;
    U8 *pDestLevels = dest_levels;
    U8 *pDestTypes = dest_types;
    U8 *pLogicalBuffer = localLogicalBuffer;
    U8 *pVisualBuffer = visualStr;
    U16 mark;

    /* START TARUN PMT 20050202 */
    U8 newLineflag = 0;

    /* END TARUN PMT 20050202 */
    U8 testHilighOneCharFlag = 0;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    memset(input_types, 0,sizeof(input_types));
    memset(input_levels, 0,sizeof(input_levels));
    memset(dest_levels, 0,sizeof(dest_levels));
    memset(dest_types, 0,sizeof(dest_types));
    memset(localLogicalBuffer, 0,sizeof(localLogicalBuffer));

    if (logicalStrLen == 0)
    {
        /* *visualCurPos = 0; */
        *visualCurPos = 0xFFFF;
        *visualStr = 0;
        *(visualStr + 1) = 0;
        *visualStrLen = 0;
        *visualHilightStart = 0;
        *visualHilightEnd = 0;
        return;
    }

    if (logicalCurPos != 0xFFFF)
    {
        if (logicalCurPos < logicalHilightEnd)
        {
            logicalCurPos = logicalHilightEnd;
        }
        if (logicalHilightStart > logicalHilightEnd)
        {
            logicalHilightStart = logicalHilightEnd;
        }
    }


/*PMT IRE START*/
/*removed unwanted code*/
/*PMT IRE END*/
    mmi_ucs2ncpy((S8*) localLogicalBuffer, (const S8*)logicalStr, (U32) logicalStrLen);

#if BIDI_CONSIDER_DIFF_INPUT_METHOD_BEHAVIOR
    if (inputMode == BIDI_R)
    {
        bidi_get_char_type((U8*) & localLogicalBuffer[(logicalStrLen - 1) * BIDI_ENCODING_LENGTH], (U8*) & lastType);
        if (lastType == WS)
        {
            localLogicalBuffer[(logicalStrLen - 1) * BIDI_ENCODING_LENGTH] = 0;
            localLogicalBuffer[(logicalStrLen - 1) * BIDI_ENCODING_LENGTH + 1] = 0;
            if (logicalCurPos == logicalStrLen)
            {
                flag = TRUE;
                logicalCurPos--;
            }
            logicalStrLen--;
        }

        set_bidi_cursor_pos((U8*) localLogicalBuffer, logicalCurPos, (U16) CURSOR_MARK);

        logicalStrLen = (U16) mmi_ucs2strlen((const S8*)localLogicalBuffer);

        set_bidi_cursor_pos((U8*) localLogicalBuffer, logicalStrLen, (U16) LAST_MARK);
    }
    else
#endif /* BIDI_CONSIDER_DIFF_INPUT_METHOD_BEHAVIOR */ 
    {
        if (logicalCurPos != 0xFFFF)
        {
            set_bidi_cursor_pos((U8*) localLogicalBuffer, logicalCurPos, (U16) CURSOR_MARK);
        }
    }

    set_bidi_cursor_pos((U8*) localLogicalBuffer, logicalHilightEnd, (U16) SECOND_HIGHLT);
    set_bidi_cursor_pos((U8*) localLogicalBuffer, (U16) (logicalHilightStart), (U16) FIRST_HIGHLT);

    mmi_ucs2cpy((S8*) visualStr, (const S8*)localLogicalBuffer);
    logicalStrLen = get_direction_codes((U8*) input_types, (U8*) localLogicalBuffer, 0);

    iCount = 0;

    while (iCount < logicalStrLen)
    {
        bCheckFlag = FALSE;
        nParaCount = identify_paragraphs(pInputType, (U16) (logicalStrLen - iCount), &bCheckFlag);
        if (logicalCurPos < nParaCount)
        {
            newLineflag = 1;
        }
        copy_direction_codes(pDestTypes, pInputType, (U16) nParaCount);
        if (bCheckFlag)
        {
            pDestTypes[nParaCount] = 0;
            pInputType[nParaCount] = 0;
            if (pInputType[nParaCount - 1] == BIDI_B)
            {
                pDestTypes[nParaCount - 1] = 0;
                pInputType[nParaCount - 1] = 0;
            }
        }

        /*----------------------------------------------------------------*/
        /* We use bidi_main line by line, so we can't get the paragraph   */
        /* embedding level from the current line.                         */
        /* Now change to set the paragraph embedding                      */
        /* level by the flag: fSwap.                                       */
        /*----------------------------------------------------------------*/
        /* paragraphEmbeddingLevel = get_para_embedding_level(pInputType, nParaCount); */
        paragraphEmbeddingLevel = (fSwap == 1) ? 1 : 0;
        set_dest_levels(0, nParaCount, paragraphEmbeddingLevel, pDestLevels);

        get_run_level(nParaCount, paragraphEmbeddingLevel, pDestLevels, pDestTypes);
        resolve_lines(paragraphEmbeddingLevel, pVisualBuffer, nParaCount, TRUE, pDestTypes, pDestLevels);

        if (bCheckFlag)
        {
            nParaCount++;
        }
        pInputType += nParaCount;
        pInputLevels += nParaCount;
        pDestLevels += nParaCount;
        pDestTypes += nParaCount;
        pLogicalBuffer += nParaCount * 2;
        pVisualBuffer += nParaCount * 2;
        iCount += nParaCount;
    }

    *visualStrLen = (U16) mmi_ucs2strlen((const S8*)visualStr);

    if (fSwap)
    {
        bidi_reverse((U8*) visualStr, *visualStrLen);
    }

    *visualCurPos = 0xFFFF;
    /* START Changed by YOGESH PMT 20050912 */
    while (find_mark(visualStr, *visualStrLen, &mark, (U16*) & iCount))
        /* END YOGESH PMT 20050912 */
    {
        switch (mark)
        {
            case LAST_MARK:
            case CURSOR_MARK:
        #if BIDI_CONSIDER_DIFF_INPUT_METHOD_BEHAVIOR
                if (inputMode == BIDI_R)
                {
                    *visualCurPos = get_bidi_cursor_pos(visualStr, (U16) LAST_MARK);

                    if (lastType == WS)
                    {
                        set_bidi_cursor_pos(visualStr, *visualCurPos, (U16) (0x0020));
                    }

                    *visualCurPos = get_bidi_cursor_pos(visualStr, (U16) CURSOR_MARK);
                }
                else
        #endif /* BIDI_CONSIDER_DIFF_INPUT_METHOD_BEHAVIOR */ 
                {
                    *visualCurPos = get_bidi_cursor_pos(visualStr, (U16) CURSOR_MARK);
                }
                testHilighOneCharFlag = 1;
                break;
            case SECOND_HIGHLT:
                *visualHilightEnd = get_bidi_cursor_pos(visualStr, (U16) SECOND_HIGHLT);
                testHilighOneCharFlag = 0;
                break;
            case FIRST_HIGHLT:
                *visualHilightStart = get_bidi_cursor_pos(visualStr, (U16) FIRST_HIGHLT);
                testHilighOneCharFlag = 0;

                break;
        }
    }

    if (testHilighOneCharFlag == 0 && *visualHilightEnd == *visualHilightStart)
    {
        *visualHilightEnd = *visualHilightStart = *visualCurPos + 1;
    }

    if ((logicalHilightStart == 0) && (logicalHilightEnd == 0))
    {
        *visualHilightEnd = 0;
        *visualHilightStart = 0;
    }

    if ((*visualHilightEnd <
         /*=*/ *visualHilightStart) /* && (!(*visualHilightStart == 0 && *visualHilightEnd == 0)) */ )
    {
        (*visualHilightEnd)++;
        (*visualHilightStart)++;
    }

    *visualStrLen = (U16) mmi_ucs2strlen((const S8*)visualStr);
}