LCOV - code coverage report
Current view: top level - vcl/unx/generic/app - i18n_cb.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 199 0.0 %
Date: 2014-04-14 Functions: 0 17 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <stdio.h>
      21             : #include <string.h>
      22             : 
      23             : #include <sal/alloca.h>
      24             : #include <osl/thread.h>
      25             : 
      26             : #include <prex.h>
      27             : #include <X11/Xlocale.h>
      28             : #include <X11/Xlib.h>
      29             : #include <postx.h>
      30             : 
      31             : #include "vcl/cmdevt.hxx"
      32             : #include "unx/salunx.h"
      33             : #include "unx/XIM.h"
      34             : #include "unx/i18n_cb.hxx"
      35             : #include "unx/i18n_status.hxx"
      36             : #include "unx/i18n_ic.hxx"
      37             : #include "unx/i18n_im.hxx"
      38             : #include "salframe.hxx"
      39             : 
      40             : // i. preedit start callback
      41             : 
      42             : int
      43           0 : PreeditStartCallback ( XIC, XPointer client_data, XPointer )
      44             : {
      45           0 :       preedit_data_t* pPreeditData = (preedit_data_t*)client_data;
      46           0 :     if ( pPreeditData->eState == ePreeditStatusActivationRequired )
      47             :     {
      48           0 :         pPreeditData->eState = ePreeditStatusActive;
      49           0 :         pPreeditData->aText.nCursorPos = 0;
      50           0 :         pPreeditData->aText.nLength    = 0;
      51             :     }
      52             : 
      53           0 :     return -1;
      54             : }
      55             : 
      56             : // ii. preedit done callback
      57             : 
      58             : void
      59           0 : PreeditDoneCallback ( XIC, XPointer client_data, XPointer )
      60             : {
      61           0 :       preedit_data_t* pPreeditData = (preedit_data_t*)client_data;
      62           0 :      if (pPreeditData->eState == ePreeditStatusActive )
      63             :     {
      64           0 :         if( pPreeditData->pFrame )
      65           0 :             pPreeditData->pFrame->CallCallback( SALEVENT_ENDEXTTEXTINPUT, (void*)NULL );
      66             :     }
      67           0 :     pPreeditData->eState = ePreeditStatusStartPending;
      68           0 : }
      69             : 
      70             : // iii. preedit draw callback
      71             : 
      72             : // Handle deletion of text in a preedit_draw_callback
      73             : // from and howmuch are guaranteed to be nonnegative
      74             : 
      75             : void
      76           0 : Preedit_DeleteText(preedit_text_t *ptext, int from, int howmuch)
      77             : {
      78             :     // If we've been asked to delete no text then just set
      79             :     // nLength correctly and return
      80           0 :     if (ptext->nLength == 0)
      81             :     {
      82           0 :         ptext->nLength = from;
      83           0 :         return;
      84             :     }
      85             : 
      86           0 :     int to = from + howmuch;
      87             : 
      88           0 :       if (to == (int)ptext->nLength)
      89             :     {
      90             :         // delete from the end of the text
      91           0 :         ptext->nLength = from;
      92             :       }
      93             :     else
      94           0 :         if (to < (int)ptext->nLength)
      95             :     {
      96             :         // cut out of the middle of the text
      97           0 :         memmove( (void*)(ptext->pUnicodeBuffer + from),
      98             :                 (void*)(ptext->pUnicodeBuffer + to),
      99           0 :                 (ptext->nLength - to) * sizeof(sal_Unicode));
     100           0 :         memmove( (void*)(ptext->pCharStyle + from),
     101             :                 (void*)(ptext->pCharStyle + to),
     102           0 :                 (ptext->nLength - to) * sizeof(XIMFeedback));
     103           0 :         ptext->nLength -= howmuch;
     104             :       }
     105             :     else
     106             :     {
     107             :           // XXX this indicates an error, are we out of sync ?
     108             :           fprintf(stderr, "Preedit_DeleteText( from=%i to=%i length=%i )\n",
     109           0 :                 from, to, ptext->nLength );
     110           0 :           fprintf (stderr, "\t XXX internal error, out of sync XXX\n");
     111             : 
     112           0 :           ptext->nLength = from;
     113             :     }
     114             : 
     115             :       // NULL-terminate the string
     116           0 :       ptext->pUnicodeBuffer[ptext->nLength] = (sal_Unicode)0;
     117             : }
     118             : 
     119             : // reallocate the textbuffer with sufficiently large size 2^x
     120             : // nnewlimit is presupposed to be larger than ptext->size
     121             : void
     122           0 : enlarge_buffer ( preedit_text_t *ptext, int nnewlimit )
     123             : {
     124           0 :       size_t nnewsize = ptext->nSize;
     125             : 
     126           0 :       while ( nnewsize <= (size_t)nnewlimit )
     127           0 :         nnewsize *= 2;
     128             : 
     129           0 :       ptext->nSize = nnewsize;
     130             :       ptext->pUnicodeBuffer = (sal_Unicode*)realloc((void*)ptext->pUnicodeBuffer,
     131           0 :             nnewsize * sizeof(sal_Unicode));
     132             :       ptext->pCharStyle = (XIMFeedback*)realloc((void*)ptext->pCharStyle,
     133           0 :             nnewsize * sizeof(XIMFeedback));
     134           0 : }
     135             : 
     136             : // Handle insertion of text in a preedit_draw_callback
     137             : // string field of XIMText struct is guaranteed to be != NULL
     138             : 
     139             : void
     140           0 : Preedit_InsertText(preedit_text_t *pText, XIMText *pInsertText, int where)
     141             : {
     142             :     sal_Unicode *pInsertTextString;
     143           0 :     int nInsertTextLength = 0;
     144           0 :     XIMFeedback *pInsertTextCharStyle = pInsertText->feedback;
     145             : 
     146           0 :     nInsertTextLength = pInsertText->length;
     147             : 
     148             :     //  can't handle wchar_t strings, so convert to multibyte chars first
     149             :     char *pMBString;
     150             :     size_t nMBLength;
     151           0 :     if (pInsertText->encoding_is_wchar)
     152             :     {
     153           0 :         wchar_t *pWCString = pInsertText->string.wide_char;
     154           0 :           size_t nBytes = wcstombs ( NULL, pWCString, 1024 /* dont care */);
     155           0 :           pMBString = (char*)alloca( nBytes + 1 );
     156           0 :           nMBLength = wcstombs ( pMBString, pWCString, nBytes + 1);
     157             :     }
     158             :     else
     159             :     {
     160           0 :           pMBString = pInsertText->string.multi_byte;
     161           0 :           nMBLength = strlen(pMBString); // xxx
     162             :     }
     163             : 
     164             :     // convert multibyte chars to unicode
     165           0 :     rtl_TextEncoding nEncoding = osl_getThreadTextEncoding();
     166             : 
     167           0 :     if (nEncoding != RTL_TEXTENCODING_UNICODE)
     168             :     {
     169             :           rtl_TextToUnicodeConverter aConverter =
     170           0 :                 rtl_createTextToUnicodeConverter( nEncoding );
     171             :           rtl_TextToUnicodeContext aContext =
     172           0 :                 rtl_createTextToUnicodeContext(aConverter);
     173             : 
     174           0 :           sal_Size nBufferSize = nInsertTextLength * 2;
     175             : 
     176           0 :           pInsertTextString = (sal_Unicode*)alloca(nBufferSize);
     177             : 
     178             :           sal_uInt32  nConversionInfo;
     179             :           sal_Size    nConvertedChars;
     180             : 
     181             :         rtl_convertTextToUnicode( aConverter, aContext,
     182             :                 pMBString, nMBLength,
     183             :                  pInsertTextString, nBufferSize,
     184             :                   RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_IGNORE
     185             :                 | RTL_TEXTTOUNICODE_FLAGS_INVALID_IGNORE,
     186           0 :                 &nConversionInfo, &nConvertedChars );
     187             : 
     188           0 :           rtl_destroyTextToUnicodeContext(aConverter, aContext);
     189           0 :           rtl_destroyTextToUnicodeConverter(aConverter);
     190             : 
     191             :     }
     192             :     else
     193             :     {
     194           0 :           pInsertTextString = (sal_Unicode*)pMBString;
     195             :     }
     196             : 
     197             :     // enlarge target text-buffer if necessary
     198           0 :     if (pText->nSize <= (pText->nLength + nInsertTextLength))
     199           0 :       enlarge_buffer(pText, pText->nLength + nInsertTextLength);
     200             : 
     201             :     // insert text: displace old mem and put new bytes in
     202           0 :     int from    = where;
     203           0 :     int to      = where + nInsertTextLength;
     204           0 :     int howmany = pText->nLength - where;
     205             : 
     206           0 :     memmove((void*)(pText->pUnicodeBuffer + to),
     207             :           (void*)(pText->pUnicodeBuffer + from),
     208           0 :             howmany * sizeof(sal_Unicode));
     209           0 :     memmove((void*)(pText->pCharStyle + to),
     210             :             (void*)(pText->pCharStyle + from),
     211           0 :             howmany * sizeof(XIMFeedback));
     212             : 
     213           0 :     to = from;
     214           0 :     howmany = nInsertTextLength;
     215             : 
     216           0 :     memcpy((void*)(pText->pUnicodeBuffer + to), (void*)pInsertTextString,
     217           0 :            howmany * sizeof(sal_Unicode));
     218           0 :     memcpy((void*)(pText->pCharStyle + to), (void*)pInsertTextCharStyle,
     219           0 :             howmany * sizeof(XIMFeedback));
     220             : 
     221           0 :     pText->nLength += howmany;
     222             : 
     223             :     // NULL-terminate the string
     224           0 :     pText->pUnicodeBuffer[pText->nLength] = (sal_Unicode)0;
     225           0 : }
     226             : 
     227             : // Handle the change of attributes in a preedit_draw_callback
     228             : 
     229             : void
     230           0 : Preedit_UpdateAttributes ( preedit_text_t* ptext, XIMFeedback* feedback,
     231             :         int from, int amount )
     232             : {
     233           0 :     if ( (from + amount) > (int)ptext->nLength )
     234             :     {
     235             :         // XXX this indicates an error, are we out of sync ?
     236             :         fprintf (stderr, "Preedit_UpdateAttributes( %i + %i > %i )\n",
     237           0 :             from, amount, ptext->nLength );
     238           0 :         fprintf (stderr, "\t XXX internal error, out of sync XXX\n");
     239             : 
     240           0 :         return;
     241             :     }
     242             : 
     243           0 :     memcpy ( ptext->pCharStyle + from,
     244           0 :         feedback, amount * sizeof(XIMFeedback) );
     245             : }
     246             : 
     247             : // Convert the XIM feedback values into appropriate VCL
     248             : // EXTTEXTINPUT_ATTR values
     249             : // returns an allocate list of attributes, which must be freed by caller
     250             : sal_uInt16*
     251           0 : Preedit_FeedbackToSAL ( XIMFeedback* pfeedback, int nlength, std::vector<sal_uInt16>& rSalAttr )
     252             : {
     253             :       sal_uInt16 *psalattr;
     254             :       sal_uInt16  nval;
     255           0 :       sal_uInt16  noldval = 0;
     256             :       XIMFeedback nfeedback;
     257             : 
     258             :       // only work with reasonable length
     259           0 :       if (nlength > 0 && nlength > sal::static_int_cast<int>(rSalAttr.size()) )
     260             :     {
     261           0 :         rSalAttr.reserve( nlength );
     262           0 :         psalattr = &rSalAttr[0];
     263             :     }
     264             :       else
     265           0 :         return (sal_uInt16*)NULL;
     266             : 
     267           0 :       for (int npos = 0; npos < nlength; npos++)
     268             :     {
     269           0 :         nval = 0;
     270           0 :         nfeedback = pfeedback[npos];
     271             : 
     272             :         // means to use the feedback of the previous char
     273           0 :         if (nfeedback == 0)
     274             :         {
     275           0 :               nval = noldval;
     276             :            }
     277             :         // convert feedback to attributes
     278             :         else
     279             :         {
     280           0 :               if (nfeedback & XIMReverse)
     281           0 :                 nval |= EXTTEXTINPUT_ATTR_HIGHLIGHT;
     282           0 :               if (nfeedback & XIMUnderline)
     283           0 :                 nval |= EXTTEXTINPUT_ATTR_UNDERLINE;
     284           0 :               if (nfeedback & XIMHighlight)
     285           0 :                 nval |= EXTTEXTINPUT_ATTR_HIGHLIGHT;
     286           0 :               if (nfeedback & XIMPrimary)
     287           0 :                 nval |= EXTTEXTINPUT_ATTR_DOTTEDUNDERLINE;
     288           0 :               if (nfeedback & XIMSecondary)
     289           0 :                 nval |= EXTTEXTINPUT_ATTR_DASHDOTUNDERLINE;
     290           0 :               if (nfeedback & XIMTertiary) // same as 2ery
     291           0 :                 nval |= EXTTEXTINPUT_ATTR_DASHDOTUNDERLINE;
     292             : 
     293             :         }
     294             :         // copy in list
     295           0 :         psalattr[npos] = nval;
     296           0 :         noldval = nval;
     297             :       }
     298             :       // return list of sal attributes
     299           0 :      return psalattr;
     300             : }
     301             : 
     302             : void
     303           0 : PreeditDrawCallback(XIC ic, XPointer client_data,
     304             :             XIMPreeditDrawCallbackStruct *call_data)
     305             : {
     306           0 :     preedit_data_t* pPreeditData = (preedit_data_t*)client_data;
     307             : 
     308             :     // if there's nothing to change then change nothing
     309           0 :     if ( ( (call_data->text == NULL) && (call_data->chg_length == 0) )
     310           0 :          || pPreeditData->pFrame == NULL )
     311           0 :         return;
     312             : 
     313             :     // Solaris 7 deletes the preedit buffer after commit
     314             :     // since the next call to preeditstart will have the same effect just skip this.
     315             :     // if (pPreeditData->eState == ePreeditStatusStartPending && call_data->text == NULL)
     316             :     //    return;
     317             : 
     318           0 :     if ( pPreeditData->eState == ePreeditStatusStartPending )
     319           0 :         pPreeditData->eState = ePreeditStatusActivationRequired;
     320           0 :     PreeditStartCallback( ic, client_data, NULL );
     321             : 
     322             :       // Edit the internal textbuffer as indicated by the call_data,
     323             :       // chg_first and chg_length are guaranteed to be nonnegative
     324             : 
     325             :       // handle text deletion
     326           0 :     if (call_data->text == NULL)
     327             :     {
     328             :         Preedit_DeleteText(&(pPreeditData->aText),
     329           0 :                call_data->chg_first, call_data->chg_length );
     330             :     }
     331             :     else
     332             :     {
     333             :         // handle text insertion
     334           0 :         if (   (call_data->chg_length == 0)
     335           0 :             && (call_data->text->string.wide_char != NULL))
     336             :         {
     337             :               Preedit_InsertText(&(pPreeditData->aText), call_data->text,
     338           0 :                      call_data->chg_first);
     339             :         }
     340           0 :         else if (   (call_data->chg_length != 0)
     341           0 :               && (call_data->text->string.wide_char != NULL))
     342             :         {
     343             :             // handle text replacement by deletion and insertion of text,
     344             :             // not smart, just good enough
     345             : 
     346             :             Preedit_DeleteText(&(pPreeditData->aText),
     347           0 :                        call_data->chg_first, call_data->chg_length);
     348             :             Preedit_InsertText(&(pPreeditData->aText), call_data->text,
     349           0 :                        call_data->chg_first);
     350             :           }
     351           0 :         else if (   (call_data->chg_length != 0)
     352           0 :             && (call_data->text->string.wide_char == NULL))
     353             :         {
     354             :             // not really a text update, only attributes are concerned
     355             :               Preedit_UpdateAttributes(&(pPreeditData->aText),
     356             :                    call_data->text->feedback,
     357           0 :                    call_data->chg_first, call_data->chg_length);
     358             :         }
     359             :     }
     360             : 
     361             :     // build the SalExtTextInputEvent and send it up
     362             : 
     363           0 :     pPreeditData->aInputEv.mnTime = 0;
     364             :     pPreeditData->aInputEv.mpTextAttr = Preedit_FeedbackToSAL(
     365           0 :         pPreeditData->aText.pCharStyle, pPreeditData->aText.nLength, pPreeditData->aInputFlags);
     366           0 :     pPreeditData->aInputEv.mnCursorPos = call_data->caret;
     367           0 :     pPreeditData->aInputEv.maText = OUString(pPreeditData->aText.pUnicodeBuffer,
     368           0 :                                 pPreeditData->aText.nLength);
     369           0 :     pPreeditData->aInputEv.mnCursorFlags    = 0; // default: make cursor visible
     370           0 :     pPreeditData->aInputEv.mbOnlyCursor = False;
     371             : 
     372           0 :     if ( pPreeditData->eState == ePreeditStatusActive && pPreeditData->pFrame )
     373           0 :         pPreeditData->pFrame->CallCallback(SALEVENT_EXTTEXTINPUT, (void*)&pPreeditData->aInputEv);
     374           0 :     if (pPreeditData->aText.nLength == 0 && pPreeditData->pFrame )
     375           0 :         pPreeditData->pFrame->CallCallback( SALEVENT_ENDEXTTEXTINPUT, (void*)NULL );
     376             : 
     377           0 :     if (pPreeditData->aText.nLength == 0)
     378           0 :         pPreeditData->eState = ePreeditStatusStartPending;
     379             : 
     380           0 :     GetPreeditSpotLocation(ic, (XPointer)pPreeditData);
     381             : }
     382             : 
     383             : void
     384           0 : GetPreeditSpotLocation(XIC ic, XPointer client_data)
     385             : {
     386             : 
     387             :     // Send SalEventExtTextInputPos event to get spotlocation
     388             : 
     389           0 :     SalExtTextInputPosEvent mPosEvent;
     390           0 :     preedit_data_t* pPreeditData = (preedit_data_t*)client_data;
     391             : 
     392           0 :     if( pPreeditData->pFrame )
     393           0 :         pPreeditData->pFrame->CallCallback(SALEVENT_EXTTEXTINPUTPOS, (void*)&mPosEvent);
     394             : 
     395             :     XPoint point;
     396           0 :     point.x = mPosEvent.mnX + mPosEvent.mnWidth;
     397           0 :     point.y = mPosEvent.mnY + mPosEvent.mnHeight;
     398             : 
     399             :     XVaNestedList preedit_attr;
     400           0 :     preedit_attr = XVaCreateNestedList(0, XNSpotLocation, &point, NULL);
     401           0 :     XSetICValues(ic, XNPreeditAttributes, preedit_attr, NULL);
     402           0 :     XFree(preedit_attr);
     403             : 
     404           0 :     return;
     405             : }
     406             : 
     407             : // iv. preedit caret callback
     408             : 
     409             : #if OSL_DEBUG_LEVEL > 1
     410             : void
     411             : PreeditCaretCallback ( XIC ic, XPointer client_data,
     412             :     XIMPreeditCaretCallbackStruct *call_data )
     413             : #else
     414             : void
     415           0 : PreeditCaretCallback ( XIC, XPointer,XIMPreeditCaretCallbackStruct* )
     416             : #endif
     417             : {
     418             :     #if OSL_DEBUG_LEVEL > 1
     419             :     // XXX PreeditCaretCallback is pure debug code for now
     420             :     const char *direction = "?";
     421             :     const char *style = "?";
     422             : 
     423             :     switch ( call_data->style )
     424             :     {
     425             :         case XIMIsInvisible: style = "Invisible"; break;
     426             :         case XIMIsPrimary:   style = "Primary";   break;
     427             :         case XIMIsSecondary: style = "Secondary"; break;
     428             :     }
     429             :     switch ( call_data->direction )
     430             :     {
     431             :         case XIMForwardChar:  direction = "Forward char";  break;
     432             :         case XIMBackwardChar: direction = "Backward char"; break;
     433             :         case XIMForwardWord:  direction = "Forward word";  break;
     434             :         case XIMBackwardWord: direction = "Backward word"; break;
     435             :         case XIMCaretUp:      direction = "Caret up";      break;
     436             :         case XIMCaretDown:    direction = "Caret down";    break;
     437             :         case XIMNextLine:     direction = "Next line";     break;
     438             :         case XIMPreviousLine: direction = "Previous line"; break;
     439             :         case XIMLineStart:    direction = "Line start";    break;
     440             :         case XIMLineEnd:      direction = "Line end";      break;
     441             :         case XIMAbsolutePosition: direction = "Absolute";  break;
     442             :         case XIMDontChange:   direction = "Dont change";   break;
     443             :     }
     444             : 
     445             :     fprintf (stderr, "PreeditCaretCallback( ic=%p, client=%p,\n",
     446             :         ic, client_data );
     447             :     fprintf (stderr, "\t position=%i, direction=\"%s\", style=\"%s\" )\n",
     448             :         call_data->position, direction, style );
     449             :     #endif
     450           0 : }
     451             : 
     452             : // v. commit string callback: convert an extended text input (iiimp ... )
     453             : //     into an ordinary key-event
     454             : 
     455             : Bool
     456           0 : IsControlCode(sal_Unicode nChar)
     457             : {
     458           0 :     if ( nChar <= 0x1F /* C0 controls */ )
     459           0 :         return True;
     460             :     else
     461           0 :         return False;
     462             : }
     463             : 
     464             : // vi. status callbacks: for now these are empty, they are just needed for turbo linux
     465             : 
     466             : void
     467           0 : StatusStartCallback (XIC, XPointer, XPointer)
     468             : {
     469           0 :     return;
     470             : }
     471             : 
     472             : void
     473           0 : StatusDoneCallback (XIC, XPointer, XPointer)
     474             : {
     475           0 :     return;
     476             : }
     477             : 
     478             : void
     479           0 : StatusDrawCallback (XIC, XPointer, XIMStatusDrawCallbackStruct *call_data)
     480             : {
     481           0 :     if( call_data->type == XIMTextType )
     482             :     {
     483           0 :         OUString aText;
     484           0 :         if( call_data->data.text )
     485             :         {
     486             :             // XIM with text
     487           0 :             sal_Char* pMBString = NULL;
     488           0 :             size_t nLength = 0;
     489           0 :             if( call_data->data.text->encoding_is_wchar )
     490             :             {
     491           0 :                 if( call_data->data.text->string.wide_char )
     492             :                 {
     493           0 :                     wchar_t* pWString = call_data->data.text->string.wide_char;
     494           0 :                     size_t nBytes = wcstombs( NULL, pWString, 1024 );
     495           0 :                     pMBString = (sal_Char*)alloca( nBytes+1 );
     496           0 :                     nLength = wcstombs( pMBString, pWString, nBytes+1 );
     497             :                 }
     498             :             }
     499             :             else
     500             :             {
     501           0 :                 if( call_data->data.text->string.multi_byte )
     502             :                 {
     503           0 :                     pMBString = call_data->data.text->string.multi_byte;
     504           0 :                     nLength = strlen( pMBString );
     505             :                 }
     506             :             }
     507           0 :             if( nLength )
     508           0 :                 aText = OUString( pMBString, nLength, osl_getThreadTextEncoding() );
     509             :         }
     510           0 :         ::vcl::I18NStatus::get().setStatusText( aText );
     511             :     }
     512             : #if OSL_DEBUG_LEVEL > 1
     513             :     else
     514             :     {
     515             :         fprintf( stderr, "XIMStatusDataType %s not supported\n",
     516             :             call_data->type == XIMBitmapType ? "XIMBitmapType" : OString::number(call_data->type).getStr() );
     517             :     }
     518             : #endif
     519           0 :     return;
     520             : }
     521             : 
     522             : void
     523           0 : SwitchIMCallback (XIC, XPointer, XPointer call_data)
     524             : {
     525           0 :     XIMSwitchIMNotifyCallbackStruct* pCallData = (XIMSwitchIMNotifyCallbackStruct*)call_data;
     526           0 :     ::vcl::I18NStatus::get().changeIM( OStringToOUString(pCallData->to->name, RTL_TEXTENCODING_UTF8) );
     527           0 : }
     528             : 
     529             : // vii. destroy callbacks: internally disable all IC/IM calls
     530             : 
     531             : void
     532           0 : IC_IMDestroyCallback (XIM, XPointer client_data, XPointer)
     533             : {
     534           0 :     SalI18N_InputContext *pContext = (SalI18N_InputContext*)client_data;
     535           0 :     if (pContext != NULL)
     536           0 :         pContext->HandleDestroyIM();
     537           0 : }
     538             : 
     539             : void
     540           0 : IM_IMDestroyCallback (XIM, XPointer client_data, XPointer)
     541             : {
     542           0 :     SalI18N_InputMethod *pMethod = (SalI18N_InputMethod*)client_data;
     543           0 :     if (pMethod != NULL)
     544           0 :         pMethod->HandleDestroyIM();
     545           0 : }
     546             : 
     547             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10