vcl/unx/source/app/i18n_ic.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: i18n_ic.cxx,v $
  10  * $Revision: 1.39 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_vcl.hxx"
  33
  34 #include <stdio.h>
  35 #include <sal/alloca.h>
  36
  37 #include <tools/prex.h>
  38 #include <X11/Xlocale.h>
  39 #include <X11/Xlib.h>
  40 #include <tools/postx.h>
  41
  42 #include <salunx.h>
  43
  44 #include <XIM.h>
  45 #include <i18n_ic.hxx>
  46 #include <i18n_im.hxx>
  47 #include <i18n_status.hxx>
  48
  49 #ifndef _SV_SALFRAME_HXX
  50 #include <salframe.h>
  51 #endif
  52 #include <saldata.hxx>
  53 #include <saldisp.hxx>
  54
  55 #ifndef _OSL_THREAD_H
  56 #include <osl/thread.h>
  57 #endif
  58
  59 using namespace vcl;
  60
  61 static void sendEmptyCommit( SalFrame* pFrame )
  62 {
  63     vcl::DeletionListener aDel( pFrame );
  64
  65     SalExtTextInputEvent aEmptyEv;
  66     aEmptyEv.mnTime                     = 0;
  67     aEmptyEv.mpTextAttr                 = 0;
  68     aEmptyEv.maText                 = String();
  69     aEmptyEv.mnCursorPos                = 0;
  70     aEmptyEv.mnCursorFlags          = 0;
  71     aEmptyEv.mnDeltaStart           = 0;
  72     aEmptyEv.mbOnlyCursor           = False;
  73     pFrame->CallCallback( SALEVENT_EXTTEXTINPUT, (void*)&aEmptyEv );
  74     if( ! aDel.isDeleted() )
  75         pFrame->CallCallback( SALEVENT_ENDEXTTEXTINPUT, NULL );
  76 }
  77
  78 // ---------------------------------------------------------------------------
  79 //
  80 // Constructor / Destructor, the InputContext is bound to the SalFrame, as it
  81 // needs the shell window as a focus window
  82 //
  83 // ----------------------------------------------------------------------------
  84
  85 SalI18N_InputContext::~SalI18N_InputContext()
  86 {
  87     if ( maContext != NULL )
  88         XDestroyIC( maContext );
  89     if ( mpAttributes != NULL )
  90         XFree( mpAttributes );
  91     if ( mpStatusAttributes != NULL )
  92         XFree( mpStatusAttributes );
  93     if ( mpPreeditAttributes != NULL )
  94         XFree( mpPreeditAttributes );
  95
  96     if (maClientData.aText.pUnicodeBuffer != NULL)
  97         free(maClientData.aText.pUnicodeBuffer);
  98     if (maClientData.aText.pCharStyle != NULL)
  99         free(maClientData.aText.pCharStyle);
 100 }
 101
 102 // ----------------------------------------------------------------------------
 103 // convenience routine to add items to a XVaNestedList
 104 // ----------------------------------------------------------------------------
 105
 106 static XVaNestedList
 107 XVaAddToNestedList( XVaNestedList a_srclist, char* name, XPointer value )
 108 {
 109     XVaNestedList a_dstlist;
 110
 111     // if ( value == NULL )
 112     //  return a_srclist;
 113
 114     if ( a_srclist == NULL )
 115     {
 116         a_dstlist = XVaCreateNestedList(
 117                                         0,
 118                                         name,           value,
 119                                         NULL );
 120     }
 121     else
 122     {
 123         a_dstlist = XVaCreateNestedList(
 124                                         0,
 125                                         XNVaNestedList, a_srclist,
 126                                         name,           value,
 127                                         NULL );
 128     }
 129
 130     return a_dstlist != NULL ? a_dstlist : a_srclist ;
 131 }
 132
 133 // ----------------------------------------------------------------------------
 134 // convenience routine to create a fontset
 135 // ----------------------------------------------------------------------------
 136
 137 static XFontSet
 138 get_font_set( Display *p_display )
 139 {
 140     static XFontSet p_font_set = NULL;
 141
 142     if (p_font_set == NULL)
 143     {
 144         char **pp_missing_list;
 145         int    n_missing_count;
 146         char  *p_default_string;
 147
 148         p_font_set = XCreateFontSet(p_display, "-*",
 149                                     &pp_missing_list, &n_missing_count, &p_default_string);
 150     }
 151
 152     return p_font_set;
 153 }
 154
 155 // ---------------------------------------------------------------------------
 156 //
 157 // Constructor for a InputContext (IC)
 158 //
 159 // ----------------------------------------------------------------------------
 160
 161 SalI18N_InputContext::SalI18N_InputContext ( SalFrame *pFrame ) :
 162         mbUseable( True ),
 163         maContext( (XIC)NULL ),
 164         mnSupportedStatusStyle(
 165                                XIMStatusCallbacks   |
 166                                XIMStatusNothing     |
 167                                XIMStatusNone
 168                                ),
 169         mnSupportedPreeditStyle(
 170                                 XIMPreeditCallbacks |
 171                                 XIMPreeditNothing   |
 172                                 XIMPreeditNone
 173                                 ),
 174         mnStatusStyle( 0 ),
 175         mnPreeditStyle( 0 ),
 176         mpAttributes( NULL ),
 177         mpStatusAttributes( NULL ),
 178         mpPreeditAttributes( NULL )
 179 {
 180 #ifdef SOLARIS
 181     static const char* pIIIMPEnable = getenv( "SAL_DISABLE_OWN_IM_STATUS" );
 182     if( pIIIMPEnable && *pIIIMPEnable )
 183         mnSupportedStatusStyle &= ~XIMStatusCallbacks;
 184 #endif
 185
 186     maClientData.aText.pUnicodeBuffer       = NULL;
 187     maClientData.aText.pCharStyle           = NULL;
 188     maClientData.aInputEv.mnTime            = 0;
 189     maClientData.aInputEv.mpTextAttr        = NULL;
 190     maClientData.aInputEv.mnCursorPos       = 0;
 191     maClientData.aInputEv.mnDeltaStart      = 0;
 192     maClientData.aInputEv.mnCursorFlags     = 0;
 193     maClientData.aInputEv.mbOnlyCursor      = FALSE;
 194
 195     SalI18N_InputMethod *pInputMethod;
 196     pInputMethod = GetX11SalData()->GetDisplay()->GetInputMethod();
 197     mbMultiLingual = pInputMethod->IsMultiLingual();
 198
 199     mnSupportedPreeditStyle =   XIMPreeditCallbacks | XIMPreeditPosition
 200         | XIMPreeditNothing   | XIMPreeditNone;
 201     if (pInputMethod->UseMethod()
 202         && SupportInputMethodStyle( pInputMethod->GetSupportedStyles() ) )
 203     {
 204         const SystemEnvData* pEnv = pFrame->GetSystemData();
 205         XLIB_Window  aClientWindow = pEnv->aShellWindow;
 206         XLIB_Window  aFocusWindow  = pEnv->aWindow;
 207
 208         // for status callbacks and commit string callbacks
 209 #define PREEDIT_BUFSZ 16
 210         maClientData.bIsMultilingual        = mbMultiLingual;
 211         maClientData.eState                 = ePreeditStatusStartPending;
 212         maClientData.pFrame                 = pFrame;
 213         maClientData.aText.pUnicodeBuffer   =
 214             (sal_Unicode*)malloc(PREEDIT_BUFSZ * sizeof(sal_Unicode));
 215         maClientData.aText.pCharStyle       =
 216             (XIMFeedback*)malloc(PREEDIT_BUFSZ * sizeof(XIMFeedback));;
 217         maClientData.aText.nSize            = PREEDIT_BUFSZ;
 218         maClientData.aText.nCursorPos       = 0;
 219         maClientData.aText.nLength          = 0;
 220
 221         //
 222         // Status attributes
 223         //
 224
 225         switch ( mnStatusStyle )
 226         {
 227             case XIMStatusCallbacks:
 228             {
 229                 static XIMCallback aStatusStartCallback;
 230                 static XIMCallback aStatusDoneCallback;
 231                 static XIMCallback aStatusDrawCallback;
 232
 233                 aStatusStartCallback.callback    = (XIMProc)StatusStartCallback;
 234                 aStatusStartCallback.client_data = (XPointer)&maClientData;
 235                 aStatusDoneCallback.callback     = (XIMProc)StatusDoneCallback;
 236                 aStatusDoneCallback.client_data  = (XPointer)&maClientData;
 237                 aStatusDrawCallback.callback     = (XIMProc)StatusDrawCallback;
 238                 aStatusDrawCallback.client_data  = (XPointer)&maClientData;
 239
 240                 mpStatusAttributes = XVaCreateNestedList (
 241                                                           0,
 242                                                           XNStatusStartCallback, &aStatusStartCallback,
 243                                                           XNStatusDoneCallback,  &aStatusDoneCallback,
 244                                                           XNStatusDrawCallback,  &aStatusDrawCallback,
 245                                                           NULL );
 246
 247                 break;
 248             }
 249
 250             case XIMStatusArea:
 251                 /* not supported */
 252                 break;
 253
 254             case XIMStatusNone:
 255             case XIMStatusNothing:
 256             default:
 257                 /* no arguments needed */
 258                 break;
 259         }
 260
 261         //
 262         // set preedit attributes
 263         //
 264
 265         switch ( mnPreeditStyle )
 266         {
 267             case XIMPreeditCallbacks:
 268
 269                 maPreeditCaretCallback.callback = (XIMProc)PreeditCaretCallback;
 270                 maPreeditStartCallback.callback = (XIMProc)PreeditStartCallback;
 271                 maPreeditDoneCallback.callback  = (XIMProc)PreeditDoneCallback;
 272                 maPreeditDrawCallback.callback  = (XIMProc)PreeditDrawCallback;
 273                 maPreeditCaretCallback.client_data = (XPointer)&maClientData;
 274                 maPreeditStartCallback.client_data = (XPointer)&maClientData;
 275                 maPreeditDoneCallback.client_data  = (XPointer)&maClientData;
 276                 maPreeditDrawCallback.client_data  = (XPointer)&maClientData;
 277
 278                 mpPreeditAttributes = XVaCreateNestedList (
 279                                                            0,
 280                                                            XNPreeditStartCallback, &maPreeditStartCallback,
 281                                                            XNPreeditDoneCallback,  &maPreeditDoneCallback,
 282                                                            XNPreeditDrawCallback,   &maPreeditDrawCallback,
 283                                                            XNPreeditCaretCallback, &maPreeditCaretCallback,
 284                                                            NULL );
 285
 286                 break;
 287
 288             case XIMPreeditArea:
 289                 /* not supported */
 290                 break;
 291
 292             case XIMPreeditPosition:
 293             {
 294                 // spot location
 295                 SalExtTextInputPosEvent aPosEvent;
 296                 pFrame->CallCallback(SALEVENT_EXTTEXTINPUTPOS, (void*)&aPosEvent);
 297
 298                 static XPoint aSpot;
 299                 aSpot.x = aPosEvent.mnX + aPosEvent.mnWidth;
 300                 aSpot.y = aPosEvent.mnY + aPosEvent.mnHeight;
 301
 302                 // create attributes for preedit position style
 303                 mpPreeditAttributes = XVaCreateNestedList (
 304                                                            0,
 305                                                            XNSpotLocation, &aSpot,
 306                                                            NULL );
 307
 308                 // XCreateIC() fails on Redflag Linux 2.0 if there is no
 309                 // fontset though the data itself is not evaluated nor is
 310                 // it required according to the X specs.
 311                 Display* pDisplay = GetX11SalData()->GetDisplay()->GetDisplay();
 312                 XFontSet pFontSet = get_font_set(pDisplay);
 313
 314                 if (pFontSet != NULL)
 315                 {
 316                     mpPreeditAttributes = XVaAddToNestedList( mpPreeditAttributes,
 317                                                               const_cast<char*>(XNFontSet), (XPointer)pFontSet);
 318                 }
 319
 320                 break;
 321             }
 322
 323             case XIMPreeditNone:
 324             case XIMPreeditNothing:
 325             default:
 326                 /* no arguments needed */
 327                 break;
 328         }
 329
 330         // Create the InputContext by giving it exactly the information it
 331         // deserves, because inappropriate attributes
 332         // let XCreateIC fail on Solaris (eg. for C locale)
 333
 334         mpAttributes = XVaCreateNestedList(
 335                                            0,
 336                                            XNFocusWindow,       aFocusWindow,
 337                                            XNClientWindow,      aClientWindow,
 338                                            XNInputStyle,        mnPreeditStyle | mnStatusStyle,
 339                                            NULL );
 340
 341         if ( mnPreeditStyle != XIMPreeditNone )
 342         {
 343 #if defined LINUX || defined FREEBSD || defined NETBSD || defined IRIX
 344             if ( mpPreeditAttributes != NULL )
 345 #endif
 346                 mpAttributes = XVaAddToNestedList( mpAttributes,
 347                                                    const_cast<char*>(XNPreeditAttributes), (XPointer)mpPreeditAttributes );
 348         }
 349         if ( mnStatusStyle != XIMStatusNone )
 350         {
 351 #if defined LINUX || defined FREEBSD || defined NETBSD || defined IRIX
 352             if ( mpStatusAttributes != NULL )
 353 #endif
 354                 mpAttributes = XVaAddToNestedList( mpAttributes,
 355                                                    const_cast<char*>(XNStatusAttributes), (XPointer)mpStatusAttributes );
 356         }
 357         maContext = XCreateIC( pInputMethod->GetMethod(),
 358                                XNVaNestedList, mpAttributes,
 359                                NULL );
 360     }
 361
 362     if ( maContext == NULL )
 363     {
 364 #if OSL_DEBUG_LEVEL > 1
 365         fprintf(stderr, "input context creation failed\n");
 366 #endif
 367
 368         mbUseable = False;
 369         mbMultiLingual = False;
 370
 371         if ( mpAttributes != NULL )
 372             XFree( mpAttributes );
 373         if ( mpStatusAttributes != NULL )
 374             XFree( mpStatusAttributes );
 375         if ( mpPreeditAttributes != NULL )
 376             XFree( mpPreeditAttributes );
 377         if ( maClientData.aText.pUnicodeBuffer != NULL )
 378             free ( maClientData.aText.pUnicodeBuffer );
 379         if ( maClientData.aText.pCharStyle != NULL )
 380             free ( maClientData.aText.pCharStyle );
 381
 382         mpAttributes                      = NULL;
 383         mpStatusAttributes                = NULL;
 384         mpPreeditAttributes               = NULL;
 385         maClientData.aText.pUnicodeBuffer = NULL;
 386         maClientData.aText.pCharStyle     = NULL;
 387     }
 388
 389     if ( maContext != NULL && mbMultiLingual )
 390     {
 391         maCommitStringCallback.callback    = (XIMProc)::CommitStringCallback;
 392         maCommitStringCallback.client_data = (XPointer)&maClientData;
 393         maSwitchIMCallback.callback        = (XIMProc)::SwitchIMCallback;
 394         maSwitchIMCallback.client_data     = (XPointer)&maClientData;
 395         XSetICValues( maContext,
 396                       XNCommitStringCallback, &maCommitStringCallback,
 397                       XNSwitchIMNotifyCallback, &maSwitchIMCallback,
 398                       NULL );
 399     }
 400     if ( maContext != NULL)
 401     {
 402         maDestroyCallback.callback    = (XIMProc)IC_IMDestroyCallback;
 403         maDestroyCallback.client_data = (XPointer)this;
 404         XSetICValues( maContext,
 405                       XNDestroyCallback,      &maDestroyCallback,
 406                       NULL );
 407     }
 408
 409     if( mbMultiLingual )
 410     {
 411         // set initial IM status
 412         XIMUnicodeCharacterSubset* pSubset = NULL;
 413         if( ! XGetICValues( maContext,
 414                             XNUnicodeCharacterSubset, & pSubset,
 415                             NULL )
 416             && pSubset )
 417         {
 418             String aCurrent( ByteString( pSubset->name ), RTL_TEXTENCODING_UTF8 );
 419             ::vcl::I18NStatus::get().changeIM( aCurrent );
 420             ::vcl::I18NStatus::get().setStatusText( aCurrent );
 421         }
 422     }
 423 }
 424
 425 // ---------------------------------------------------------------------------
 426 //
 427 // In Solaris 8 the status window does not unmap if the frame unmapps, so
 428 // unmap it the hard way
 429 //
 430 // ---------------------------------------------------------------------------
 431
 432 void
 433 SalI18N_InputContext::Unmap( SalFrame* pFrame )
 434 {
 435     if ( maContext != NULL )
 436     {
 437         I18NStatus& rStatus( I18NStatus::get() );
 438         if( rStatus.getParent() == pFrame )
 439             rStatus.show( false, I18NStatus::contextmap );
 440
 441     }
 442     UnsetICFocus( pFrame );
 443     maClientData.pFrame = NULL;
 444 }
 445
 446 void
 447 SalI18N_InputContext::Map( SalFrame *pFrame )
 448 {
 449     if( mbUseable )
 450     {
 451         I18NStatus& rStatus(I18NStatus::get() );
 452         rStatus.setParent( pFrame );
 453         if( pFrame )
 454         {
 455             rStatus.show( true, I18NStatus::contextmap );
 456             if ( maContext == NULL )
 457             {
 458                 SalI18N_InputMethod *pInputMethod;
 459                 pInputMethod = GetX11SalData()->GetDisplay()->GetInputMethod();
 460
 461                 maContext = XCreateIC( pInputMethod->GetMethod(),
 462                                        XNVaNestedList, mpAttributes,
 463                                        NULL );
 464                 if ( maContext != NULL && mbMultiLingual )
 465                     XSetICValues( maContext,
 466                                   XNCommitStringCallback, &maCommitStringCallback,
 467                                   XNSwitchIMNotifyCallback, &maSwitchIMCallback,
 468                                   NULL );
 469             }
 470             if( maClientData.pFrame != pFrame )
 471                 SetICFocus( pFrame );
 472         }
 473     }
 474 }
 475
 476 // --------------------------------------------------------------------------
 477 //
 478 // Handle DestroyCallbacks
 479 // in fact this is a callback called from the XNDestroyCallback
 480 //
 481 // --------------------------------------------------------------------------
 482
 483 void
 484 SalI18N_InputContext::HandleDestroyIM()
 485 {
 486     maContext = 0;      // noli me tangere
 487     mbUseable = False;
 488 }
 489
 490 // ---------------------------------------------------------------------------
 491 //
 492 //  make sure, the input method gets all the X-Events it needs, this is only
 493 //  called once on each frame, it relys on a valid maContext
 494 //
 495 // ---------------------------------------------------------------------------
 496
 497 void
 498 SalI18N_InputContext::ExtendEventMask( XLIB_Window aFocusWindow )
 499 {
 500     unsigned long nIMEventMask;
 501     XWindowAttributes aWindowAttributes;
 502
 503     if ( mbUseable )
 504     {
 505         Display *pDisplay = XDisplayOfIM( XIMOfIC(maContext) );
 506
 507         XGetWindowAttributes( pDisplay, aFocusWindow,
 508                               &aWindowAttributes );
 509         XGetICValues ( maContext,
 510                        XNFilterEvents, &nIMEventMask,
 511                        NULL);
 512         nIMEventMask |= aWindowAttributes.your_event_mask;
 513         XSelectInput ( pDisplay, aFocusWindow, nIMEventMask );
 514     }
 515 }
 516
 517 // ---------------------------------------------------------------------------
 518 //
 519 // tune the styles provided by the input method with the supported one
 520 //
 521 // ---------------------------------------------------------------------------
 522
 523 unsigned int
 524 SalI18N_InputContext::GetWeightingOfIMStyle( XIMStyle nStyle ) const
 525 {
 526     struct StyleWeightingT {
 527         const XIMStyle      nStyle;
 528         const unsigned int  nWeight;
 529     };
 530
 531     StyleWeightingT const *pWeightPtr;
 532     const StyleWeightingT pWeight[] = {
 533         { XIMPreeditCallbacks, 0x10000000 },
 534         { XIMPreeditPosition,  0x02000000 },
 535         { XIMPreeditArea,      0x01000000 },
 536         { XIMPreeditNothing,   0x00100000 },
 537         { XIMPreeditNone,      0x00010000 },
 538         { XIMStatusCallbacks,      0x1000 },
 539         { XIMStatusArea,           0x0100 },
 540         { XIMStatusNothing,        0x0010 },
 541         { XIMStatusNone,           0x0001 },
 542         { 0, 0x0 }
 543     };
 544
 545     int nWeight = 0;
 546     for ( pWeightPtr = pWeight; pWeightPtr->nStyle != 0; pWeightPtr++ )
 547     {
 548         if ( (pWeightPtr->nStyle & nStyle) != 0 )
 549             nWeight += pWeightPtr->nWeight;
 550     }
 551     return nWeight;
 552 }
 553
 554 Bool
 555 SalI18N_InputContext::IsSupportedIMStyle( XIMStyle nStyle ) const
 556 {
 557     if (   (nStyle & mnSupportedPreeditStyle)
 558            && (nStyle & mnSupportedStatusStyle) )
 559     {
 560         return True;
 561     }
 562     return False;
 563 }
 564
 565 Bool
 566 SalI18N_InputContext::SupportInputMethodStyle( XIMStyles *pIMStyles )
 567 {
 568     int nBestScore   = 0;
 569     int nActualScore = 0;
 570
 571     mnPreeditStyle = 0;
 572     mnStatusStyle  = 0;
 573
 574     if ( pIMStyles != NULL )
 575     {
 576         // check whether the XIM supports one of the desired styles
 577         // only a single preedit and a single status style must occure
 578         // in a inpuut method style. Hideki said so, so i trust him
 579         for ( int nStyle = 0; nStyle < pIMStyles->count_styles; nStyle++ )
 580         {
 581             XIMStyle nProvidedStyle = pIMStyles->supported_styles[ nStyle ];
 582             if ( IsSupportedIMStyle(nProvidedStyle) )
 583             {
 584                 nActualScore = GetWeightingOfIMStyle( nProvidedStyle );
 585                 if ( nActualScore >= nBestScore )
 586                 {
 587                     nBestScore = nActualScore;
 588                     mnPreeditStyle = nProvidedStyle & mnSupportedPreeditStyle;
 589                     mnStatusStyle  = nProvidedStyle & mnSupportedStatusStyle;
 590                 }
 591             }
 592         }
 593     }
 594
 595 #if OSL_DEBUG_LEVEL > 1
 596     char pBuf[ 128 ];
 597     fprintf( stderr, "selected inputmethod style = %s\n",
 598              GetMethodName(mnPreeditStyle | mnStatusStyle, pBuf, sizeof(pBuf)) );
 599 #endif
 600
 601     return (mnPreeditStyle != 0) && (mnStatusStyle != 0) ;
 602 }
 603
 604 // ---------------------------------------------------------------------------
 605 //
 606 // handle extended and normal key input
 607 //
 608 // ---------------------------------------------------------------------------
 609
 610 int
 611 SalI18N_InputContext::CommitStringCallback (sal_Unicode* pText, sal_Size nLength)
 612 {
 613     XIMUnicodeText call_data;
 614
 615     call_data.string.utf16_char = pText;
 616     call_data.length            = nLength;
 617     call_data.annotations       = NULL;
 618     call_data.count_annotations = 0;
 619     call_data.feedback          = NULL;
 620
 621     return ::CommitStringCallback( maContext,
 622                                    (XPointer)&maClientData, (XPointer)&call_data );
 623 }
 624
 625 int
 626 SalI18N_InputContext::CommitKeyEvent(sal_Unicode* pText, sal_Size nLength)
 627 {
 628     if (nLength == 1 && IsControlCode(pText[0]))
 629         return 0;
 630
 631     if( maClientData.pFrame )
 632     {
 633         SalExtTextInputEvent aTextEvent;
 634
 635         aTextEvent.mnTime        = 0;
 636         aTextEvent.mpTextAttr    = 0;
 637         aTextEvent.mnCursorPos   = nLength;
 638         aTextEvent.maText        = UniString(pText, nLength);
 639         aTextEvent.mnCursorFlags = 0;
 640         aTextEvent.mnDeltaStart  = 0;
 641         aTextEvent.mbOnlyCursor  = False;
 642
 643         maClientData.pFrame->CallCallback(SALEVENT_EXTTEXTINPUT,    (void*)&aTextEvent);
 644         maClientData.pFrame->CallCallback(SALEVENT_ENDEXTTEXTINPUT, (void*)NULL);
 645     }
 646 #if OSL_DEBUG_LEVEL > 1
 647     else
 648         fprintf(stderr, "CommitKeyEvent without frame\n" );
 649 #endif
 650
 651     return 0;
 652 }
 653
 654 int
 655 SalI18N_InputContext::UpdateSpotLocation()
 656 {
 657     if (maContext == 0 || maClientData.pFrame == NULL)
 658         return -1;
 659
 660     SalExtTextInputPosEvent aPosEvent;
 661     maClientData.pFrame->CallCallback(SALEVENT_EXTTEXTINPUTPOS, (void*)&aPosEvent);
 662
 663     XPoint aSpot;
 664     aSpot.x = aPosEvent.mnX + aPosEvent.mnWidth;
 665     aSpot.y = aPosEvent.mnY + aPosEvent.mnHeight;
 666
 667     XVaNestedList preedit_attr = XVaCreateNestedList(0, XNSpotLocation, &aSpot, NULL);
 668     XSetICValues(maContext, XNPreeditAttributes, preedit_attr, NULL);
 669     XFree(preedit_attr);
 670
 671     I18NStatus::get().show( true, I18NStatus::contextmap );
 672
 673     return 0;
 674 }
 675
 676 // ---------------------------------------------------------------------------
 677 //
 678 // set and unset the focus for the Input Context
 679 // the context may be NULL despite it is useable if the framewindow is
 680 // in unmapped state
 681 //
 682 // ---------------------------------------------------------------------------
 683
 684 void
 685 SalI18N_InputContext::SetICFocus( SalFrame* pFocusFrame )
 686 {
 687     I18NStatus::get().setParent( pFocusFrame );
 688     if ( mbUseable && (maContext != NULL)  )
 689     {
 690         maClientData.pFrame = pFocusFrame;
 691
 692         const SystemEnvData* pEnv       = pFocusFrame->GetSystemData();
 693         XLIB_Window  aClientWindow      = pEnv->aShellWindow;
 694         XLIB_Window  aFocusWindow       = pEnv->aWindow;
 695
 696         XSetICValues( maContext,
 697                       XNFocusWindow,       aFocusWindow,
 698                       XNClientWindow,      aClientWindow,
 699                       NULL );
 700
 701         if( maClientData.aInputEv.mpTextAttr )
 702         {
 703             sendEmptyCommit(pFocusFrame);
 704             // begin preedit again
 705             GetX11SalData()->GetDisplay()->SendInternalEvent( pFocusFrame, &maClientData.aInputEv, SALEVENT_EXTTEXTINPUT );
 706         }
 707
 708         XSetICFocus( maContext );
 709     }
 710 }
 711
 712 void
 713 SalI18N_InputContext::UnsetICFocus( SalFrame* pFrame )
 714 {
 715     I18NStatus& rStatus( I18NStatus::get() );
 716     if( rStatus.getParent() == pFrame )
 717         rStatus.setParent( NULL );
 718
 719     if ( mbUseable && (maContext != NULL) )
 720     {
 721         // cancel an eventual event posted to begin preedit again
 722         GetX11SalData()->GetDisplay()->CancelInternalEvent( maClientData.pFrame, &maClientData.aInputEv, SALEVENT_EXTTEXTINPUT );
 723         maClientData.pFrame = NULL;
 724         XUnsetICFocus( maContext );
 725     }
 726 }
 727
 728 // ---------------------------------------------------------------------------
 729 //
 730 // multi byte input method only
 731 //
 732 // ---------------------------------------------------------------------------
 733
 734 void
 735 SalI18N_InputContext::SetPreeditState(Bool aPreeditState)
 736 {
 737     XIMPreeditState preedit_state = XIMPreeditUnKnown;
 738     XVaNestedList preedit_attr;
 739
 740     preedit_attr = XVaCreateNestedList(
 741                                        0,
 742                                        XNPreeditState, &preedit_state,
 743                                        NULL);
 744     if (!XGetICValues(maContext, XNPreeditAttributes, preedit_attr, NULL))
 745     {
 746         XFree(preedit_attr);
 747
 748         preedit_state = aPreeditState? XIMPreeditEnable : XIMPreeditDisable;
 749         preedit_attr = XVaCreateNestedList(
 750                                            0,
 751                                            XNPreeditState, preedit_state,
 752                                            NULL);
 753         XSetICValues(maContext, XNPreeditAttributes, preedit_attr, NULL);
 754     }
 755
 756     XFree(preedit_attr);
 757
 758     return;
 759 }
 760
 761 void
 762 SalI18N_InputContext::SetLanguage(LanguageType)
 763 {
 764     // not yet implemented
 765     return;
 766 }
 767
 768 void
 769 SalI18N_InputContext::EndExtTextInput( USHORT /*nFlags*/ )
 770 {
 771     if ( mbUseable && (maContext != NULL) && maClientData.pFrame )
 772     {
 773         vcl::DeletionListener aDel( maClientData.pFrame );
 774         // delete preedit in sal (commit an empty string)
 775         sendEmptyCommit( maClientData.pFrame );
 776         if( ! aDel.isDeleted() )
 777         {
 778             // mark previous preedit state again (will e.g. be sent at focus gain)
 779             maClientData.aInputEv.mpTextAttr = &maClientData.aInputFlags[0];
 780             if( static_cast<X11SalFrame*>(maClientData.pFrame)->hasFocus() )
 781             {
 782                 // begin preedit again
 783                 GetX11SalData()->GetDisplay()->SendInternalEvent( maClientData.pFrame, &maClientData.aInputEv, SALEVENT_EXTTEXTINPUT );
 784             }
 785         }
 786     }
 787 }
 788
 789