LCOV - code coverage report
Current view: top level - libreoffice/cui/source/dialogs - hangulhanjadlg.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 963 0.0 %
Date: 2012-12-27 Functions: 0 144 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 "hangulhanjadlg.hxx"
      21             : #include "hangulhanjadlg.hrc"
      22             : #include "commonlingui.hxx"
      23             : #include <dialmgr.hxx>
      24             : 
      25             : #include <cuires.hrc>
      26             : #include "helpid.hrc"
      27             : 
      28             : #include <algorithm>
      29             : #include <vcl/controllayout.hxx>
      30             : #include <vcl/msgbox.hxx>
      31             : #include <unotools/lingucfg.hxx>
      32             : #include <unotools/linguprops.hxx>
      33             : #include <com/sun/star/linguistic2/ConversionDictionaryType.hpp>
      34             : #include <com/sun/star/linguistic2/ConversionDirection.hpp>
      35             : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
      36             : #include <com/sun/star/i18n/TextConversionOption.hpp>
      37             : #include <com/sun/star/util/XFlushable.hpp>
      38             : 
      39             : #include <comphelper/processfactory.hxx>
      40             : #include <comphelper/string.hxx>
      41             : #include "svtools/treelistentry.hxx"
      42             : 
      43             : #define HHC editeng::HangulHanjaConversion
      44             : #define LINE_CNT        static_cast< sal_uInt16 >(2)
      45             : 
      46             : //.............................................................................
      47             : namespace svx
      48             : {
      49             : //.............................................................................
      50             :     using namespace ::com::sun::star;
      51             :     using namespace ::com::sun::star::uno;
      52             :     using namespace ::com::sun::star::linguistic2;
      53             :     using namespace ::com::sun::star::lang;
      54             :     using namespace ::com::sun::star::container;
      55             :     using ::rtl::OUString;
      56             : 
      57             :     //-------------------------------------------------------------------------
      58             :     namespace
      59             :     {
      60             :         class FontSwitch
      61             :         {
      62             :         private:
      63             :             OutputDevice& m_rDev;
      64             : 
      65             :         public:
      66           0 :             inline FontSwitch( OutputDevice& _rDev, const Font& _rTemporaryFont )
      67           0 :                 :m_rDev( _rDev )
      68             :             {
      69           0 :                 m_rDev.Push( PUSH_FONT );
      70           0 :                 m_rDev.SetFont( _rTemporaryFont );
      71           0 :             }
      72           0 :             inline ~FontSwitch( )
      73             :             {
      74           0 :                 m_rDev.Pop( );
      75           0 :             }
      76             :         };
      77             :     }
      78             : 
      79             :     //=========================================================================
      80             :     //= PseudoRubyText
      81             :     //=========================================================================
      82             :     /** a class which allows to draw two texts in a pseudo-ruby way (which basically
      83             :         means one text above or below the other, and a little bit smaller)
      84             :     */
      85           0 :     class PseudoRubyText
      86             :     {
      87             :     public:
      88             :         enum RubyPosition
      89             :         {
      90             :             eAbove, eBelow
      91             :         };
      92             : 
      93             :     protected:
      94             :         const String        m_sPrimaryText;
      95             :         const String        m_sSecondaryText;
      96             :         const RubyPosition  m_ePosition;
      97             : 
      98             :     public:
      99             :         PseudoRubyText( const String& _rPrimary, const String& _rSecondary, const RubyPosition _ePosition );
     100             : 
     101             :     public:
     102             :         void Paint( OutputDevice& _rDevice, const Rectangle& _rRect, sal_uInt16 _nTextStyle,
     103             :             Rectangle* _pPrimaryLocation = NULL, Rectangle* _pSecondaryLocation = NULL,
     104             :             ::vcl::ControlLayoutData* _pLayoutData = NULL );
     105             :     };
     106             : 
     107             :     //-------------------------------------------------------------------------
     108           0 :     PseudoRubyText::PseudoRubyText( const String& _rPrimary, const String& _rSecondary, const RubyPosition _ePosition )
     109             :         :m_sPrimaryText( _rPrimary )
     110             :         ,m_sSecondaryText( _rSecondary )
     111           0 :         ,m_ePosition( _ePosition )
     112             :     {
     113           0 :     }
     114             : 
     115             :     //-------------------------------------------------------------------------
     116           0 :     void PseudoRubyText::Paint( OutputDevice& _rDevice, const Rectangle& _rRect, sal_uInt16 _nTextStyle,
     117             :         Rectangle* _pPrimaryLocation, Rectangle* _pSecondaryLocation, ::vcl::ControlLayoutData* _pLayoutData )
     118             :     {
     119           0 :         bool            bLayoutOnly  = NULL != _pLayoutData;
     120           0 :         MetricVector*   pTextMetrics = bLayoutOnly ? &_pLayoutData->m_aUnicodeBoundRects : NULL;
     121           0 :         String*         pDisplayText = bLayoutOnly ? &_pLayoutData->m_aDisplayText       : NULL;
     122             : 
     123           0 :         Size aPlaygroundSize( _rRect.GetSize() );
     124             : 
     125             :         // the font for the secondary text:
     126           0 :         Font aSmallerFont( _rDevice.GetFont() );
     127             :         // heuristic: 80% of the original size
     128           0 :         aSmallerFont.SetHeight( (long)( 0.8 * aSmallerFont.GetHeight() ) );
     129             : 
     130             :         // let's calculate the size of our two texts
     131           0 :         Rectangle aPrimaryRect = _rDevice.GetTextRect( _rRect, m_sPrimaryText, _nTextStyle );
     132           0 :         Rectangle aSecondaryRect;
     133             :         {
     134           0 :             FontSwitch aFontRestore( _rDevice, aSmallerFont );
     135           0 :             aSecondaryRect = _rDevice.GetTextRect( _rRect, m_sSecondaryText, _nTextStyle );
     136             :         }
     137             : 
     138             :         // position these rectangles properly
     139             :         // x-axis:
     140           0 :         sal_Int32 nCombinedWidth = ::std::max( aSecondaryRect.GetWidth(), aPrimaryRect.GetWidth() );
     141             :             // the rectangle where both texts will reside is as high as possible, and as wide as the
     142             :             // widest of both text rects
     143           0 :         aPrimaryRect.Left() = aSecondaryRect.Left() = _rRect.Left();
     144           0 :         aPrimaryRect.Right() = aSecondaryRect.Right() = _rRect.Left() + nCombinedWidth;
     145           0 :         if ( TEXT_DRAW_RIGHT & _nTextStyle )
     146             :         {
     147             :             // move the rectangles to the right
     148           0 :             aPrimaryRect.Move( aPlaygroundSize.Width() - nCombinedWidth, 0 );
     149           0 :             aSecondaryRect.Move( aPlaygroundSize.Width() - nCombinedWidth, 0 );
     150             :         }
     151           0 :         else if ( TEXT_DRAW_CENTER & _nTextStyle )
     152             :         {
     153             :             // center the rectangles
     154           0 :             aPrimaryRect.Move( ( aPlaygroundSize.Width() - nCombinedWidth ) / 2, 0 );
     155           0 :             aSecondaryRect.Move( ( aPlaygroundSize.Width() - nCombinedWidth ) / 2, 0 );
     156             :         }
     157             : 
     158             :         // y-axis:
     159           0 :         sal_Int32 nCombinedHeight = aPrimaryRect.GetHeight() + aSecondaryRect.GetHeight();
     160             :         // align to the top, for the moment
     161           0 :         aPrimaryRect.Move( 0, _rRect.Top() - aPrimaryRect.Top() );
     162           0 :         aSecondaryRect.Move( 0, aPrimaryRect.Top() + aPrimaryRect.GetHeight() - aSecondaryRect.Top() );
     163           0 :         if ( TEXT_DRAW_BOTTOM & _nTextStyle )
     164             :         {
     165             :             // move the rects to the bottom
     166           0 :             aPrimaryRect.Move( 0, aPlaygroundSize.Height() - nCombinedHeight );
     167           0 :             aSecondaryRect.Move( 0, aPlaygroundSize.Height() - nCombinedHeight );
     168             :         }
     169           0 :         else if ( TEXT_DRAW_VCENTER & _nTextStyle )
     170             :         {
     171             :             // move the rects to the bottom
     172           0 :             aPrimaryRect.Move( 0, ( aPlaygroundSize.Height() - nCombinedHeight ) / 2 );
     173           0 :             aSecondaryRect.Move( 0, ( aPlaygroundSize.Height() - nCombinedHeight ) / 2 );
     174             :         }
     175             : 
     176             :         // 'til here, everything we did assumes that the secondary text is painted _below_ the primary
     177             :         // text. If this isn't the case, we need to correct the rectangles
     178           0 :         if ( eAbove == m_ePosition )
     179             :         {
     180           0 :             sal_Int32 nVertDistance = aSecondaryRect.Top() - aPrimaryRect.Top();
     181           0 :             aSecondaryRect.Move( 0, -nVertDistance );
     182           0 :             aPrimaryRect.Move( 0, nCombinedHeight - nVertDistance );
     183             :         }
     184             : 
     185             :         // now draw the texts
     186             :         // as we already calculated the precise rectangles for the texts, we don't want to
     187             :         // use the alignment flags given - within it's rect, every text is centered
     188           0 :         sal_uInt16 nDrawTextStyle( _nTextStyle );
     189           0 :         nDrawTextStyle &= ~( TEXT_DRAW_RIGHT | TEXT_DRAW_LEFT | TEXT_DRAW_BOTTOM | TEXT_DRAW_TOP );
     190           0 :         nDrawTextStyle |= TEXT_DRAW_CENTER | TEXT_DRAW_VCENTER;
     191             : 
     192           0 :         _rDevice.DrawText( aPrimaryRect, m_sPrimaryText, nDrawTextStyle, pTextMetrics, pDisplayText );
     193             :         {
     194           0 :             FontSwitch aFontRestore( _rDevice, aSmallerFont );
     195           0 :             _rDevice.DrawText( aSecondaryRect, m_sSecondaryText, nDrawTextStyle, pTextMetrics, pDisplayText );
     196             :         }
     197             : 
     198             :         // outta here
     199           0 :         if ( _pPrimaryLocation )
     200           0 :             *_pPrimaryLocation = aPrimaryRect;
     201           0 :         if ( _pSecondaryLocation )
     202           0 :             *_pSecondaryLocation = aSecondaryRect;
     203           0 :     }
     204             : 
     205             :     //=========================================================================
     206             :     //= RubyRadioButton
     207             :     //=========================================================================
     208           0 :     class RubyRadioButton   :public RadioButton
     209             :                             ,protected PseudoRubyText
     210             :     {
     211             :         using svx::PseudoRubyText::Paint;
     212             : 
     213             :     public:
     214             :         RubyRadioButton(
     215             :             Window* _pParent,
     216             :             const ResId& _rId,          // the text in the resource will be taken as primary text
     217             :             const String& _rSecondary,  // this will be the secondary text which will be printed somewhat smaller
     218             :             const PseudoRubyText::RubyPosition _ePosition );
     219             : 
     220             :     protected:
     221             :         virtual void    Paint( const Rectangle& _rRect );
     222             :     };
     223             : 
     224             :     //-------------------------------------------------------------------------
     225           0 :     RubyRadioButton::RubyRadioButton( Window* _pParent, const ResId& _rId,
     226             :         const String& _rSecondary, const PseudoRubyText::RubyPosition _ePosition )
     227             :         :RadioButton( _pParent, _rId )
     228           0 :         ,PseudoRubyText( RadioButton::GetText(), _rSecondary, _ePosition )
     229             :     {
     230           0 :     }
     231             : 
     232             :     //-------------------------------------------------------------------------
     233           0 :     void RubyRadioButton::Paint( const Rectangle& )
     234             :     {
     235           0 :         HideFocus();
     236             : 
     237             :         // calculate the size of the radio image - we're to paint our text _after_ this image
     238             :         DBG_ASSERT( !GetModeRadioImage(), "RubyRadioButton::Paint: images not supported!" );
     239           0 :         Size aImageSize = GetRadioImage( GetSettings(), 0 ).GetSizePixel();
     240           0 :         aImageSize.Width()  = CalcZoom( aImageSize.Width() );
     241           0 :         aImageSize.Height()  = CalcZoom( aImageSize.Height() );
     242             : 
     243           0 :         Rectangle aOverallRect( Point( 0, 0 ), GetOutputSizePixel() );
     244           0 :         aOverallRect.Left() += aImageSize.Width() + 4;  // 4 is the separator between the image and the text
     245             :         // inflate the rect a little bit (because the VCL radio button does the same)
     246           0 :         Rectangle aTextRect( aOverallRect );
     247           0 :         ++aTextRect.Left(); --aTextRect.Right();
     248           0 :         ++aTextRect.Top(); --aTextRect.Bottom();
     249             : 
     250             :         // calculate the text flags for the painting
     251           0 :         sal_uInt16 nTextStyle = TEXT_DRAW_MNEMONIC;
     252           0 :         WinBits nStyle = GetStyle( );
     253             : 
     254             :         // the horizontal alignment
     255           0 :         if ( nStyle & WB_RIGHT )
     256           0 :             nTextStyle |= TEXT_DRAW_RIGHT;
     257           0 :         else if ( nStyle & WB_CENTER )
     258           0 :             nTextStyle |= TEXT_DRAW_CENTER;
     259             :         else
     260           0 :             nTextStyle |= TEXT_DRAW_LEFT;
     261             :         // the vertical alignment
     262           0 :         if ( nStyle & WB_BOTTOM )
     263           0 :             nTextStyle |= TEXT_DRAW_BOTTOM;
     264           0 :         else if ( nStyle & WB_VCENTER )
     265           0 :             nTextStyle |= TEXT_DRAW_VCENTER;
     266             :         else
     267           0 :             nTextStyle |= TEXT_DRAW_TOP;
     268             :         // mnemonics
     269           0 :         if ( 0 == ( nStyle & WB_NOLABEL ) )
     270           0 :             nTextStyle |= TEXT_DRAW_MNEMONIC;
     271             : 
     272             :         // paint the ruby text
     273           0 :         Rectangle aPrimaryTextLocation, aSecondaryTextLocation;
     274           0 :         PseudoRubyText::Paint( *this, aTextRect, nTextStyle, &aPrimaryTextLocation, &aSecondaryTextLocation );
     275             : 
     276             :         // the focus rectangle is to be painted around both texts
     277           0 :         Rectangle aCombinedRect( aPrimaryTextLocation );
     278           0 :         aCombinedRect.Union( aSecondaryTextLocation );
     279           0 :         SetFocusRect( aCombinedRect );
     280             : 
     281             :         // let the base class paint the radio button
     282             :         // for this, give it the proper location to paint the image (vertically centered, relative to our text)
     283           0 :         Rectangle aImageLocation( Point( 0, 0 ), aImageSize );
     284           0 :         sal_Int32 nTextHeight = aSecondaryTextLocation.Bottom() - aPrimaryTextLocation.Top();
     285           0 :         aImageLocation.Top() = aPrimaryTextLocation.Top() + ( nTextHeight - aImageSize.Height() ) / 2;
     286           0 :         aImageLocation.Bottom() = aImageLocation.Top() + aImageSize.Height();
     287           0 :         SetStateRect( aImageLocation );
     288           0 :         DrawRadioButtonState( );
     289             : 
     290             :         // mouse clicks should be recognized in a rect which is one pixel larger in each direction, plus
     291             :         // includes the image
     292           0 :         aCombinedRect.Left() = aImageLocation.Left(); ++aCombinedRect.Right();
     293           0 :         --aCombinedRect.Top(); ++aCombinedRect.Bottom();
     294           0 :         SetMouseRect( aCombinedRect );
     295             : 
     296             :         // paint the focus rect, if necessary
     297           0 :         if ( HasFocus() )
     298           0 :             ShowFocus( aTextRect );
     299           0 :     }
     300             : 
     301             :     //=========================================================================
     302             :     //= SuggestionSet
     303             :     //=========================================================================
     304             :     //-------------------------------------------------------------------------
     305             : 
     306           0 :     SuggestionSet::SuggestionSet( Window* pParent )
     307           0 :                     : ValueSet( pParent, pParent->GetStyle() | WB_BORDER )
     308             : 
     309             :     {
     310           0 :     }
     311             : 
     312           0 :     SuggestionSet::~SuggestionSet()
     313             :     {
     314           0 :         ClearSet();
     315           0 :     }
     316             : 
     317           0 :     void SuggestionSet::UserDraw( const UserDrawEvent& rUDEvt )
     318             :     {
     319           0 :         OutputDevice*  pDev = rUDEvt.GetDevice();
     320           0 :         Rectangle aRect = rUDEvt.GetRect();
     321           0 :         sal_uInt16  nItemId = rUDEvt.GetItemId();
     322             : 
     323           0 :         String sText = *static_cast< String* >( GetItemData( nItemId ) );
     324           0 :         pDev->DrawText( aRect, sText, TEXT_DRAW_CENTER | TEXT_DRAW_VCENTER );
     325           0 :     }
     326             : 
     327           0 :     void SuggestionSet::ClearSet()
     328             :     {
     329           0 :         sal_uInt16 i, nCount = GetItemCount();
     330           0 :         for ( i = 0; i < nCount; ++i )
     331           0 :             delete static_cast< String* >( GetItemData(i) );
     332           0 :         Clear();
     333           0 :     }
     334             : 
     335             :     //=========================================================================
     336             :     //= SuggestionDisplay
     337             :     //=========================================================================
     338             :     //-------------------------------------------------------------------------
     339             : 
     340           0 :     SuggestionDisplay::SuggestionDisplay( Window* pParent, const ResId& rResId )
     341             :         : Control( pParent, rResId )
     342             :         , m_bDisplayListBox(true)
     343             :         , m_aValueSet(this)
     344           0 :         , m_aListBox(this,GetStyle() | WB_BORDER )
     345           0 :         , m_bInSelectionUpdate(false)
     346             :     {
     347           0 :         m_aValueSet.SetSelectHdl( LINK( this, SuggestionDisplay, SelectSuggestionHdl ) );
     348           0 :         m_aListBox.SetSelectHdl( LINK( this, SuggestionDisplay, SelectSuggestionHdl ) );
     349             : 
     350           0 :         m_aValueSet.SetLineCount( LINE_CNT );
     351           0 :         m_aValueSet.SetStyle( m_aValueSet.GetStyle() | WB_ITEMBORDER | WB_FLATVALUESET | WB_VSCROLL );
     352           0 :         m_aValueSet.SetBorderStyle( WINDOW_BORDER_MONO );
     353           0 :         String aOneCharacter(RTL_CONSTASCII_USTRINGPARAM("AU"));
     354           0 :         long nItemWidth = 2*GetTextWidth( aOneCharacter );
     355           0 :         m_aValueSet.SetItemWidth( nItemWidth );
     356             : 
     357           0 :         Point aPos(0,0);
     358           0 :         Size aSize(GetSizePixel());
     359           0 :         m_aValueSet.SetSizePixel(aSize);
     360           0 :         m_aListBox.SetSizePixel(aSize);
     361             : 
     362           0 :         implUpdateDisplay();
     363           0 :     }
     364             : 
     365           0 :     SuggestionDisplay::~SuggestionDisplay()
     366             :     {
     367           0 :     }
     368             : 
     369           0 :     void SuggestionDisplay::implUpdateDisplay()
     370             :     {
     371           0 :         bool bShowBox = IsVisible() && m_bDisplayListBox;
     372           0 :         bool bShowSet = IsVisible() && !m_bDisplayListBox;
     373             : 
     374           0 :         m_aListBox.Show(bShowBox);
     375           0 :         m_aValueSet.Show(bShowSet);
     376           0 :     }
     377             : 
     378           0 :     void SuggestionDisplay::StateChanged( StateChangedType nStateChange )
     379             :     {
     380           0 :         if( STATE_CHANGE_VISIBLE == nStateChange )
     381           0 :             implUpdateDisplay();
     382           0 :     }
     383             : 
     384           0 :     Control& SuggestionDisplay::implGetCurrentControl()
     385             :     {
     386           0 :         if( m_bDisplayListBox )
     387           0 :             return m_aListBox;
     388           0 :         return m_aValueSet;
     389             :     }
     390             : 
     391           0 :     void SuggestionDisplay::KeyInput( const KeyEvent& rKEvt )
     392             :     {
     393           0 :         implGetCurrentControl().KeyInput( rKEvt );
     394           0 :     }
     395           0 :     void SuggestionDisplay::KeyUp( const KeyEvent& rKEvt )
     396             :     {
     397           0 :         implGetCurrentControl().KeyUp( rKEvt );
     398           0 :     }
     399           0 :     void SuggestionDisplay::Activate()
     400             :     {
     401           0 :         implGetCurrentControl().Activate();
     402           0 :     }
     403           0 :     void SuggestionDisplay::Deactivate()
     404             :     {
     405           0 :         implGetCurrentControl().Deactivate();
     406           0 :     }
     407           0 :     void SuggestionDisplay::GetFocus()
     408             :     {
     409           0 :         implGetCurrentControl().GetFocus();
     410           0 :     }
     411           0 :     void SuggestionDisplay::LoseFocus()
     412             :     {
     413           0 :         implGetCurrentControl().LoseFocus();
     414           0 :     }
     415           0 :     void SuggestionDisplay::Command( const CommandEvent& rCEvt )
     416             :     {
     417           0 :         implGetCurrentControl().Command( rCEvt );
     418           0 :     }
     419             : 
     420           0 :     void SuggestionDisplay::DisplayListBox( bool bDisplayListBox )
     421             :     {
     422           0 :         if( m_bDisplayListBox != bDisplayListBox )
     423             :         {
     424           0 :             Control& rOldControl = implGetCurrentControl();
     425           0 :             sal_Bool bHasFocus = rOldControl.HasFocus();
     426             : 
     427           0 :             m_bDisplayListBox = bDisplayListBox;
     428             : 
     429           0 :             if( bHasFocus )
     430             :             {
     431           0 :                 Control& rNewControl = implGetCurrentControl();
     432           0 :                 rNewControl.GrabFocus();
     433             :             }
     434             : 
     435           0 :             implUpdateDisplay();
     436             :         }
     437           0 :     }
     438             : 
     439           0 :     IMPL_LINK( SuggestionDisplay, SelectSuggestionHdl, Control*, pControl )
     440             :     {
     441           0 :         if( m_bInSelectionUpdate )
     442           0 :             return 0L;
     443             : 
     444           0 :         m_bInSelectionUpdate = true;
     445           0 :         if(pControl==&m_aListBox)
     446             :         {
     447           0 :             sal_uInt16 nPos = m_aListBox.GetSelectEntryPos();
     448           0 :             m_aValueSet.SelectItem( nPos+1 ); //itemid == pos+1 (id 0 has special meaning)
     449             :         }
     450             :         else
     451             :         {
     452           0 :             sal_uInt16 nPos = m_aValueSet.GetSelectItemId()-1; //itemid == pos+1 (id 0 has special meaning)
     453           0 :             m_aListBox.SelectEntryPos( nPos );
     454             :         }
     455           0 :         m_bInSelectionUpdate = false;
     456           0 :         m_aSelectLink.Call(this);
     457           0 :         return 0L;
     458             :     }
     459             : 
     460           0 :     void SuggestionDisplay::SetSelectHdl( const Link& rLink )
     461             :     {
     462           0 :         m_aSelectLink = rLink;
     463           0 :     }
     464           0 :     void SuggestionDisplay::Clear()
     465             :     {
     466           0 :         m_aListBox.Clear();
     467           0 :         m_aValueSet.Clear();
     468           0 :     }
     469           0 :     void SuggestionDisplay::InsertEntry( const XubString& rStr )
     470             :     {
     471           0 :         sal_uInt16 nItemId = m_aListBox.InsertEntry( rStr ) + 1; //itemid == pos+1 (id 0 has special meaning)
     472           0 :         m_aValueSet.InsertItem( nItemId );
     473           0 :         String* pItemData = new String(rStr);
     474           0 :         m_aValueSet.SetItemData( nItemId, pItemData );
     475           0 :     }
     476           0 :     void SuggestionDisplay::SelectEntryPos( sal_uInt16 nPos )
     477             :     {
     478           0 :         m_aListBox.SelectEntryPos( nPos );
     479           0 :         m_aValueSet.SelectItem( nPos+1 ); //itemid == pos+1 (id 0 has special meaning)
     480           0 :     }
     481           0 :     sal_uInt16 SuggestionDisplay::GetEntryCount() const
     482             :     {
     483           0 :         return m_aListBox.GetEntryCount();
     484             :     }
     485           0 :     XubString SuggestionDisplay::GetEntry( sal_uInt16 nPos ) const
     486             :     {
     487           0 :         return m_aListBox.GetEntry( nPos );
     488             :     }
     489           0 :     XubString SuggestionDisplay::GetSelectEntry() const
     490             :     {
     491           0 :         return m_aListBox.GetSelectEntry();
     492             :     }
     493           0 :     void SuggestionDisplay::SetHelpIds()
     494             :     {
     495           0 :         this->SetHelpId( HID_HANGULDLG_SUGGESTIONS );
     496           0 :         m_aValueSet.SetHelpId( HID_HANGULDLG_SUGGESTIONS_GRID );
     497           0 :         m_aListBox.SetHelpId( HID_HANGULDLG_SUGGESTIONS_LIST );
     498           0 :     }
     499             : 
     500             :     //=========================================================================
     501             :     //= HangulHanjaConversionDialog
     502             :     //=========================================================================
     503             :     //-------------------------------------------------------------------------
     504           0 :     HangulHanjaConversionDialog::HangulHanjaConversionDialog( Window* _pParent, HHC::ConversionDirection _ePrimaryDirection )
     505           0 :         :ModalDialog( _pParent, CUI_RES( RID_SVX_MDLG_HANGULHANJA ) )
     506           0 :         ,m_pPlayground( new SvxCommonLinguisticControl( this ) )
     507           0 :         ,m_aFind            ( m_pPlayground.get(), CUI_RES( PB_FIND ) )
     508           0 :         ,m_aSuggestions     ( m_pPlayground.get(), CUI_RES( CTL_SUGGESTIONS ) )
     509           0 :         ,m_aFormat          ( m_pPlayground.get(), CUI_RES( FT_FORMAT ) )
     510           0 :         ,m_aSimpleConversion( m_pPlayground.get(), CUI_RES( RB_SIMPLE_CONVERSION ) )
     511           0 :         ,m_aHangulBracketed ( m_pPlayground.get(), CUI_RES( RB_HANJA_HANGUL_BRACKETED ) )
     512           0 :         ,m_aHanjaBracketed  ( m_pPlayground.get(), CUI_RES( RB_HANGUL_HANJA_BRACKETED ) )
     513           0 :         ,m_aConversion      ( m_pPlayground.get(), CUI_RES( FT_CONVERSION ) )
     514           0 :         ,m_aHangulOnly      ( m_pPlayground.get(), CUI_RES( CB_HANGUL_ONLY ) )
     515           0 :         ,m_aHanjaOnly       ( m_pPlayground.get(), CUI_RES( CB_HANJA_ONLY ) )
     516           0 :         ,m_aReplaceByChar   ( m_pPlayground.get(), CUI_RES( CB_REPLACE_BY_CHARACTER ) )
     517             :         ,m_pIgnoreNonPrimary( NULL )
     518           0 :         ,m_bDocumentMode( true )
     519             :     {
     520             :         // special creation of the 4 pseudo-ruby radio buttons
     521           0 :         String sSecondaryHangul( CUI_RES( STR_HANGUL ) );
     522           0 :         String sSecondaryHanja( CUI_RES( STR_HANJA ) );
     523           0 :         m_pHanjaAbove.reset( new RubyRadioButton( m_pPlayground.get(), CUI_RES( RB_HANGUL_HANJA_ABOVE ), sSecondaryHanja, PseudoRubyText::eAbove ) );
     524           0 :         m_pHanjaBelow.reset( new RubyRadioButton( m_pPlayground.get(), CUI_RES( RB_HANGUL_HANJA_BELOW ), sSecondaryHanja, PseudoRubyText::eBelow ) );
     525           0 :         m_pHangulAbove.reset( new RubyRadioButton( m_pPlayground.get(), CUI_RES( RB_HANJA_HANGUL_ABOVE ), sSecondaryHangul, PseudoRubyText::eAbove ) );
     526           0 :         m_pHangulBelow.reset( new RubyRadioButton( m_pPlayground.get(), CUI_RES( RB_HANJA_HANGUL_BELOW ), sSecondaryHangul, PseudoRubyText::eBelow ) );
     527             : 
     528             :         // since these 4 buttons are not created within the other members, they have a wrong initial Z-Order
     529             :         // correct this
     530           0 :         m_pHanjaAbove->SetZOrder( &m_aHanjaBracketed, WINDOW_ZORDER_BEHIND );
     531           0 :         m_pHanjaBelow->SetZOrder( m_pHanjaAbove.get(), WINDOW_ZORDER_BEHIND );
     532           0 :         m_pHangulAbove->SetZOrder( m_pHanjaBelow.get(), WINDOW_ZORDER_BEHIND );
     533           0 :         m_pHangulBelow->SetZOrder( m_pHangulAbove.get(), WINDOW_ZORDER_BEHIND );
     534             : 
     535             :         // VCL automatically sets the WB_GROUP bit, if the previous sibling (at the moment of creation)
     536             :         // is no radion button
     537           0 :         m_pHanjaAbove->SetStyle( m_pHanjaAbove->GetStyle() & ~WB_GROUP );
     538             : 
     539             :         // the "Find" button and the word input control may not have the proper distance/extensions
     540             :         // -> correct this
     541           0 :         Point aDistance = LogicToPixel( Point( 3, 0 ), MAP_APPFONT );
     542             :         sal_Int32 nTooLargeByPixels =
     543             :             // right margin of the word input control
     544           0 :             (   m_pPlayground->GetWordInputControl().GetPosPixel().X()
     545           0 :             +   m_pPlayground->GetWordInputControl().GetSizePixel().Width()
     546             :             )
     547             :             // minus left margin of the find button
     548           0 :             -   m_aFind.GetPosPixel().X()
     549             :             // plus desired distance between the both
     550           0 :             +   aDistance.X();
     551             :         // make the word input control smaller
     552           0 :         Size aSize = m_pPlayground->GetWordInputControl().GetSizePixel();
     553           0 :         aSize.Width() -= nTooLargeByPixels;
     554           0 :         m_pPlayground->GetWordInputControl().SetSizePixel( aSize );
     555             : 
     556             :         // additionall, the playground is not wide enough (in it's default size)
     557           0 :         sal_Int32 nEnlargeWidth = 0;
     558             :         {
     559           0 :             FixedText aBottomAnchor( m_pPlayground.get(), CUI_RES( FT_RESIZE_ANCHOR ) );
     560           0 :             Point aAnchorPos = aBottomAnchor.GetPosPixel();
     561             : 
     562           0 :             nEnlargeWidth = aAnchorPos.X() - m_pPlayground->GetActionButtonsLocation().X();
     563             :         }
     564           0 :         m_pPlayground->Enlarge( nEnlargeWidth, 0 );
     565             : 
     566             :         // insert our controls into the z-order of the playground
     567           0 :         m_pPlayground->InsertControlGroup( m_aFind, m_aFind, SvxCommonLinguisticControl::eLeftRightWords );
     568           0 :         m_pPlayground->InsertControlGroup( m_aSuggestions, m_aHanjaOnly, SvxCommonLinguisticControl::eSuggestionLabel );
     569           0 :         m_pPlayground->InsertControlGroup( m_aReplaceByChar, m_aReplaceByChar, SvxCommonLinguisticControl::eActionButtons );
     570             : 
     571           0 :         m_pPlayground->SetButtonHandler( SvxCommonLinguisticControl::eClose, LINK( this, HangulHanjaConversionDialog, OnClose ) );
     572           0 :         m_pPlayground->GetWordInputControl().SetModifyHdl( LINK( this,  HangulHanjaConversionDialog, OnSuggestionModified ) );
     573           0 :         m_aSuggestions.SetSelectHdl( LINK( this,  HangulHanjaConversionDialog, OnSuggestionSelected ) );
     574             : 
     575           0 :         m_aReplaceByChar.SetClickHdl( LINK( this, HangulHanjaConversionDialog, ClickByCharacterHdl ) );
     576             : 
     577           0 :         m_aHangulOnly.SetClickHdl( LINK( this,  HangulHanjaConversionDialog, OnConversionDirectionClicked ) );
     578           0 :         m_aHanjaOnly.SetClickHdl(  LINK( this,  HangulHanjaConversionDialog, OnConversionDirectionClicked ) );
     579             : 
     580             :         m_pPlayground->SetButtonHandler( SvxCommonLinguisticControl::eOptions,
     581           0 :                                         LINK( this, HangulHanjaConversionDialog, OnOption ) );
     582           0 :         m_pPlayground->GetButton( SvxCommonLinguisticControl::eOptions )->Show();
     583             : 
     584           0 :         if ( editeng::HangulHanjaConversion::eHangulToHanja == _ePrimaryDirection )
     585             :         {
     586           0 :             m_pIgnoreNonPrimary = &m_aHangulOnly;
     587             :         }
     588             :         else
     589             :         {
     590           0 :             m_pIgnoreNonPrimary = &m_aHanjaOnly;
     591             :         }
     592             : 
     593             :         // initial focus
     594           0 :         FocusSuggestion( );
     595             : 
     596             :         // initial control values
     597           0 :         m_aSimpleConversion.Check();
     598             : 
     599           0 :         m_pPlayground->GetButton(SvxCommonLinguisticControl::eClose     )->SetHelpId(HID_HANGULDLG_BUTTON_CLOSE    );
     600           0 :         m_pPlayground->GetButton(SvxCommonLinguisticControl::eIgnore    )->SetHelpId(HID_HANGULDLG_BUTTON_IGNORE   );
     601           0 :         m_pPlayground->GetButton(SvxCommonLinguisticControl::eIgnoreAll )->SetHelpId(HID_HANGULDLG_BUTTON_IGNOREALL);
     602           0 :         m_pPlayground->GetButton(SvxCommonLinguisticControl::eChange    )->SetHelpId(HID_HANGULDLG_BUTTON_CHANGE   );
     603           0 :         m_pPlayground->GetButton(SvxCommonLinguisticControl::eChangeAll )->SetHelpId(HID_HANGULDLG_BUTTON_CHANGEALL);
     604           0 :         m_pPlayground->GetButton(SvxCommonLinguisticControl::eOptions   )->SetHelpId(HID_HANGULDLG_BUTTON_OPTIONS  );
     605           0 :         m_pPlayground->GetWordInputControl().SetHelpId(HID_HANGULDLG_EDIT_NEWWORD);
     606             : 
     607           0 :         FreeResource();
     608             : 
     609           0 :         m_aSuggestions.SetHelpIds();
     610           0 :     }
     611             : 
     612             :     //-------------------------------------------------------------------------
     613           0 :     HangulHanjaConversionDialog::~HangulHanjaConversionDialog( )
     614             :     {
     615           0 :     }
     616             : 
     617             :     //-------------------------------------------------------------------------
     618           0 :     void HangulHanjaConversionDialog::FillSuggestions( const ::com::sun::star::uno::Sequence< ::rtl::OUString >& _rSuggestions )
     619             :     {
     620           0 :         m_aSuggestions.Clear();
     621             : 
     622           0 :         const ::rtl::OUString* pSuggestions = _rSuggestions.getConstArray();
     623           0 :         const ::rtl::OUString* pSuggestionsEnd = _rSuggestions.getConstArray() + _rSuggestions.getLength();
     624           0 :         while ( pSuggestions != pSuggestionsEnd )
     625           0 :             m_aSuggestions.InsertEntry( *pSuggestions++ );
     626             : 
     627             :         // select the first suggestion, and fill in the suggestion edit field
     628           0 :         String sFirstSuggestion;
     629           0 :         if ( m_aSuggestions.GetEntryCount() )
     630             :         {
     631           0 :             sFirstSuggestion = m_aSuggestions.GetEntry( 0 );
     632           0 :             m_aSuggestions.SelectEntryPos( 0 );
     633             :         }
     634           0 :         m_pPlayground->GetWordInputControl().SetText( sFirstSuggestion );
     635           0 :         m_pPlayground->GetWordInputControl().SaveValue();
     636           0 :         OnSuggestionModified( &m_pPlayground->GetWordInputControl() );
     637           0 :     }
     638             : 
     639             :     //-------------------------------------------------------------------------
     640           0 :     void HangulHanjaConversionDialog::SetOptionsChangedHdl( const Link& _rHdl )
     641             :     {
     642           0 :         m_aOptionsChangedLink = _rHdl;
     643           0 :     }
     644             : 
     645             :     //-------------------------------------------------------------------------
     646           0 :     void HangulHanjaConversionDialog::SetIgnoreHdl( const Link& _rHdl )
     647             :     {
     648           0 :         m_pPlayground->SetButtonHandler( SvxCommonLinguisticControl::eIgnore, _rHdl );
     649           0 :     }
     650             : 
     651             :     //-------------------------------------------------------------------------
     652           0 :     void HangulHanjaConversionDialog::SetIgnoreAllHdl( const Link& _rHdl )
     653             :     {
     654           0 :         m_pPlayground->SetButtonHandler( SvxCommonLinguisticControl::eIgnoreAll, _rHdl );
     655           0 :     }
     656             : 
     657             :     //-------------------------------------------------------------------------
     658           0 :     void HangulHanjaConversionDialog::SetChangeHdl( const Link& _rHdl )
     659             :     {
     660           0 :         m_pPlayground->SetButtonHandler( SvxCommonLinguisticControl::eChange, _rHdl );
     661           0 :     }
     662             : 
     663             :     //-------------------------------------------------------------------------
     664           0 :     void HangulHanjaConversionDialog::SetChangeAllHdl( const Link& _rHdl )
     665             :     {
     666           0 :         m_pPlayground->SetButtonHandler( SvxCommonLinguisticControl::eChangeAll, _rHdl );
     667           0 :     }
     668             : 
     669             :     //-------------------------------------------------------------------------
     670           0 :     void HangulHanjaConversionDialog::SetFindHdl( const Link& _rHdl )
     671             :     {
     672           0 :         m_aFind.SetClickHdl( _rHdl );
     673           0 :     }
     674             : 
     675             :     //-------------------------------------------------------------------------
     676           0 :     void HangulHanjaConversionDialog::SetConversionFormatChangedHdl( const Link& _rHdl )
     677             :     {
     678           0 :         m_aSimpleConversion.SetClickHdl( _rHdl );
     679           0 :         m_aHangulBracketed.SetClickHdl( _rHdl );
     680           0 :         m_aHanjaBracketed.SetClickHdl( _rHdl );
     681           0 :         m_pHanjaAbove->SetClickHdl( _rHdl );
     682           0 :         m_pHanjaBelow->SetClickHdl( _rHdl );
     683           0 :         m_pHangulAbove->SetClickHdl( _rHdl );
     684           0 :         m_pHangulBelow->SetClickHdl( _rHdl );
     685           0 :     }
     686             : 
     687             :     //-------------------------------------------------------------------------
     688           0 :     void HangulHanjaConversionDialog::SetClickByCharacterHdl( const Link& _rHdl )
     689             :     {
     690           0 :         m_aClickByCharacterLink = _rHdl;
     691           0 :     }
     692             : 
     693             :     //-------------------------------------------------------------------------
     694           0 :     IMPL_LINK_NOARG(HangulHanjaConversionDialog, OnSuggestionSelected)
     695             :     {
     696           0 :         m_pPlayground->GetWordInputControl().SetText( m_aSuggestions.GetSelectEntry() );
     697           0 :         OnSuggestionModified( NULL );
     698           0 :         return 0L;
     699             :     }
     700             : 
     701             :     //-------------------------------------------------------------------------
     702           0 :     IMPL_LINK_NOARG(HangulHanjaConversionDialog, OnSuggestionModified)
     703             :     {
     704           0 :         m_aFind.Enable( m_pPlayground->GetWordInputControl().GetSavedValue() != m_pPlayground->GetWordInputControl().GetText() );
     705             : 
     706           0 :         bool bSameLen = m_pPlayground->GetWordInputControl().GetText().Len() == m_pPlayground->GetCurrentText().Len();
     707           0 :         m_pPlayground->EnableButton( SvxCommonLinguisticControl::eChange, m_bDocumentMode && bSameLen );
     708           0 :         m_pPlayground->EnableButton( SvxCommonLinguisticControl::eChangeAll, m_bDocumentMode && bSameLen );
     709             : 
     710           0 :         return 0L;
     711             :     }
     712             : 
     713             :     //-------------------------------------------------------------------------
     714           0 :     IMPL_LINK( HangulHanjaConversionDialog, ClickByCharacterHdl, CheckBox *, pBox )
     715             :     {
     716           0 :         m_aClickByCharacterLink.Call(pBox);
     717             : 
     718           0 :         bool bByCharacter = pBox->IsChecked();
     719           0 :         m_aSuggestions.DisplayListBox( !bByCharacter );
     720             : 
     721           0 :         return 0L;
     722             :     }
     723             : 
     724             :     //-------------------------------------------------------------------------
     725           0 :     IMPL_LINK( HangulHanjaConversionDialog, OnConversionDirectionClicked, CheckBox *, pBox )
     726             :     {
     727           0 :         CheckBox *pOtherBox = 0;
     728           0 :         if (pBox == &m_aHangulOnly)
     729           0 :             pOtherBox = &m_aHanjaOnly;
     730           0 :         else if (pBox == &m_aHanjaOnly)
     731           0 :             pOtherBox = &m_aHangulOnly;
     732           0 :         if (pBox && pOtherBox)
     733             :         {
     734           0 :             sal_Bool bBoxChecked = pBox->IsChecked();
     735           0 :             if (bBoxChecked)
     736           0 :                 pOtherBox->Check( sal_False );
     737           0 :             pOtherBox->Enable( !bBoxChecked );
     738             :         }
     739             : 
     740           0 :         return 0L;
     741             :     }
     742             : 
     743             :     //-------------------------------------------------------------------------
     744           0 :     IMPL_LINK_NOARG(HangulHanjaConversionDialog, OnClose)
     745             :     {
     746           0 :         Close();
     747           0 :         return 0L;
     748             :     }
     749             : 
     750           0 :     IMPL_LINK_NOARG(HangulHanjaConversionDialog, OnOption)
     751             :     {
     752           0 :         HangulHanjaOptionsDialog        aOptDlg( this );
     753           0 :         aOptDlg.Execute();
     754           0 :         m_aOptionsChangedLink.Call(this);
     755           0 :         return 0L;
     756             :     }
     757             : 
     758             :     //-------------------------------------------------------------------------
     759           0 :     String HangulHanjaConversionDialog::GetCurrentString( ) const
     760             :     {
     761           0 :         return m_pPlayground->GetCurrentText( );
     762             :     }
     763             : 
     764             :     //-------------------------------------------------------------------------
     765           0 :     void HangulHanjaConversionDialog::FocusSuggestion( )
     766             :     {
     767           0 :         m_pPlayground->GetWordInputControl().GrabFocus();
     768           0 :     }
     769             : 
     770             :     //-------------------------------------------------------------------------
     771             :     namespace
     772             :     {
     773           0 :         void lcl_modifyWindowStyle( Window* _pWin, WinBits _nSet, WinBits _nReset )
     774             :         {
     775             :             DBG_ASSERT( 0 == ( _nSet & _nReset ), "lcl_modifyWindowStyle: set _and_ reset the same bit?" );
     776           0 :             if ( _pWin )
     777           0 :                 _pWin->SetStyle( ( _pWin->GetStyle() | _nSet ) & ~_nReset );
     778           0 :         }
     779             :     }
     780             : 
     781             :     //-------------------------------------------------------------------------
     782           0 :     void HangulHanjaConversionDialog::SetCurrentString( const String& _rNewString,
     783             :         const Sequence< ::rtl::OUString >& _rSuggestions, bool _bOriginatesFromDocument )
     784             :     {
     785           0 :         m_pPlayground->SetCurrentText( _rNewString );
     786             : 
     787           0 :         bool bOldDocumentMode = m_bDocumentMode;
     788           0 :         m_bDocumentMode = _bOriginatesFromDocument; // before FillSuggestions!
     789           0 :         FillSuggestions( _rSuggestions );
     790             : 
     791           0 :         m_pPlayground->EnableButton( SvxCommonLinguisticControl::eIgnoreAll, m_bDocumentMode );
     792             :             // all other buttons have been implicitly enabled or disabled during filling in the suggestions
     793             : 
     794             :         // switch the def button depending if we're working for document text
     795           0 :         if ( bOldDocumentMode != m_bDocumentMode )
     796             :         {
     797           0 :             Window* pOldDefButton = NULL;
     798           0 :             Window* pNewDefButton = NULL;
     799           0 :             if ( m_bDocumentMode )
     800             :             {
     801           0 :                 pOldDefButton = &m_aFind;
     802           0 :                 pNewDefButton = m_pPlayground->GetButton( SvxCommonLinguisticControl::eChange );
     803             :             }
     804             :             else
     805             :             {
     806           0 :                 pOldDefButton = m_pPlayground->GetButton( SvxCommonLinguisticControl::eChange );
     807           0 :                 pNewDefButton = &m_aFind;
     808             :             }
     809             : 
     810             :             DBG_ASSERT( WB_DEFBUTTON == ( pOldDefButton->GetStyle( ) & WB_DEFBUTTON ),
     811             :                 "HangulHanjaConversionDialog::SetCurrentString: wrong previous default button (1)!" );
     812             :             DBG_ASSERT( 0 == ( pNewDefButton->GetStyle( ) & WB_DEFBUTTON ),
     813             :                 "HangulHanjaConversionDialog::SetCurrentString: wrong previous default button (2)!" );
     814             : 
     815           0 :             lcl_modifyWindowStyle( pOldDefButton, 0, WB_DEFBUTTON );
     816           0 :             lcl_modifyWindowStyle( pNewDefButton, WB_DEFBUTTON, 0 );
     817             : 
     818             :             // give the focus to the new def button temporarily - VCL is somewhat peculiar
     819             :             // in recognizing a new default button
     820           0 :             sal_uInt32 nSaveFocusId = Window::SaveFocus();
     821           0 :             pNewDefButton->GrabFocus();
     822           0 :             Window::EndSaveFocus( nSaveFocusId );
     823             :         }
     824           0 :     }
     825             : 
     826             :     //-------------------------------------------------------------------------
     827           0 :     String HangulHanjaConversionDialog::GetCurrentSuggestion( ) const
     828             :     {
     829           0 :         return m_pPlayground->GetWordInputControl().GetText();
     830             :     }
     831             : 
     832             :     //-------------------------------------------------------------------------
     833           0 :     void HangulHanjaConversionDialog::SetByCharacter( sal_Bool _bByCharacter )
     834             :     {
     835           0 :         m_aReplaceByChar.Check( _bByCharacter );
     836           0 :         m_aSuggestions.DisplayListBox( !_bByCharacter );
     837           0 :     }
     838             : 
     839             :     //-------------------------------------------------------------------------
     840           0 :     void HangulHanjaConversionDialog::SetConversionDirectionState(
     841             :             sal_Bool _bTryBothDirections,
     842             :             HHC::ConversionDirection _ePrimaryConversionDirection )
     843             :     {
     844             :         // default state: try both direction
     845           0 :         m_aHangulOnly.Check( sal_False );
     846           0 :         m_aHangulOnly.Enable( sal_True );
     847           0 :         m_aHanjaOnly.Check( sal_False );
     848           0 :         m_aHanjaOnly.Enable( sal_True );
     849             : 
     850           0 :         if (!_bTryBothDirections)
     851             :         {
     852             :             CheckBox *pBox = _ePrimaryConversionDirection == HHC::eHangulToHanja?
     853           0 :                                     &m_aHangulOnly : &m_aHanjaOnly;
     854           0 :             pBox->Check( sal_True );
     855           0 :             OnConversionDirectionClicked( pBox );
     856             :         }
     857           0 :     }
     858             : 
     859             :     //-------------------------------------------------------------------------
     860           0 :     sal_Bool HangulHanjaConversionDialog::GetUseBothDirections( ) const
     861             :     {
     862           0 :         return !m_aHangulOnly.IsChecked() && !m_aHanjaOnly.IsChecked();
     863             :     }
     864             : 
     865             :     //-------------------------------------------------------------------------
     866           0 :     HHC::ConversionDirection HangulHanjaConversionDialog::GetDirection(
     867             :             HHC::ConversionDirection eDefaultDirection ) const
     868             :     {
     869           0 :         HHC::ConversionDirection eDirection = eDefaultDirection;
     870           0 :         if (m_aHangulOnly.IsChecked() && !m_aHanjaOnly.IsChecked())
     871           0 :             eDirection = HHC::eHangulToHanja;
     872           0 :         else if (!m_aHangulOnly.IsChecked() && m_aHanjaOnly.IsChecked())
     873           0 :             eDirection = HHC::eHanjaToHangul;
     874           0 :         return eDirection;
     875             :     }
     876             : 
     877             :     //-------------------------------------------------------------------------
     878           0 :     void HangulHanjaConversionDialog::SetConversionFormat( HHC::ConversionFormat _eType )
     879             :     {
     880           0 :         switch ( _eType )
     881             :         {
     882           0 :             case HHC::eSimpleConversion: m_aSimpleConversion.Check(); break;
     883           0 :             case HHC::eHangulBracketed: m_aHangulBracketed.Check(); break;
     884           0 :             case HHC::eHanjaBracketed:  m_aHanjaBracketed.Check(); break;
     885           0 :             case HHC::eRubyHanjaAbove:  m_pHanjaAbove->Check(); break;
     886           0 :             case HHC::eRubyHanjaBelow:  m_pHanjaBelow->Check(); break;
     887           0 :             case HHC::eRubyHangulAbove: m_pHangulAbove->Check(); break;
     888           0 :             case HHC::eRubyHangulBelow: m_pHangulBelow->Check(); break;
     889             :         default:
     890             :             OSL_FAIL( "HangulHanjaConversionDialog::SetConversionFormat: unknown type!" );
     891             :         }
     892           0 :     }
     893             : 
     894             :     //-------------------------------------------------------------------------
     895           0 :     HHC::ConversionFormat HangulHanjaConversionDialog::GetConversionFormat( ) const
     896             :     {
     897           0 :         if ( m_aSimpleConversion.IsChecked() )
     898           0 :             return HHC::eSimpleConversion;
     899           0 :         if ( m_aHangulBracketed.IsChecked() )
     900           0 :             return HHC::eHangulBracketed;
     901           0 :         if ( m_aHanjaBracketed.IsChecked() )
     902           0 :             return HHC::eHanjaBracketed;
     903           0 :         if ( m_pHanjaAbove->IsChecked() )
     904           0 :             return HHC::eRubyHanjaAbove;
     905           0 :         if ( m_pHanjaBelow->IsChecked() )
     906           0 :             return HHC::eRubyHanjaBelow;
     907           0 :         if ( m_pHangulAbove->IsChecked() )
     908           0 :             return HHC::eRubyHangulAbove;
     909           0 :         if ( m_pHangulBelow->IsChecked() )
     910           0 :             return HHC::eRubyHangulBelow;
     911             : 
     912             :         OSL_FAIL( "HangulHanjaConversionDialog::GetConversionFormat: no radio checked?" );
     913           0 :         return HHC::eSimpleConversion;
     914             :     }
     915             : 
     916             :     //-------------------------------------------------------------------------
     917           0 :     void HangulHanjaConversionDialog::EnableRubySupport( sal_Bool bVal )
     918             :     {
     919           0 :         m_pHanjaAbove->Enable( bVal );
     920           0 :         m_pHanjaBelow->Enable( bVal );
     921           0 :         m_pHangulAbove->Enable( bVal );
     922           0 :         m_pHangulBelow->Enable( bVal );
     923           0 :     }
     924             : 
     925             : 
     926             :     //=========================================================================
     927             :     //= HangulHanjaOptionsDialog
     928             :     //=========================================================================
     929             :     //-------------------------------------------------------------------------
     930             : 
     931           0 :     void HangulHanjaOptionsDialog::Init( void )
     932             :     {
     933           0 :         if( !m_xConversionDictionaryList.is() )
     934             :         {
     935           0 :             Reference< XMultiServiceFactory > xMgr( ::comphelper::getProcessServiceFactory() );
     936           0 :             if( xMgr.is() )
     937             :             {
     938           0 :                 m_xConversionDictionaryList = Reference< XConversionDictionaryList >( xMgr->createInstance(
     939           0 :                     OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.linguistic2.ConversionDictionaryList")) ),
     940           0 :                     UNO_QUERY );
     941           0 :             }
     942             :         }
     943             : 
     944           0 :         m_aDictList.clear();
     945           0 :         m_aDictsLB.Clear();
     946             : 
     947           0 :         if( m_xConversionDictionaryList.is() )
     948             :         {
     949           0 :             Reference< XNameContainer > xNameCont = m_xConversionDictionaryList->getDictionaryContainer();
     950           0 :             Reference< XNameAccess >    xNameAccess = Reference< XNameAccess >( xNameCont, UNO_QUERY );
     951           0 :             if( xNameAccess.is() )
     952             :             {
     953           0 :                 Sequence< ::rtl::OUString >     aDictNames( xNameAccess->getElementNames() );
     954             : 
     955           0 :                 const ::rtl::OUString*          pDic = aDictNames.getConstArray();
     956           0 :                 sal_Int32                       nCount = aDictNames.getLength();
     957             : 
     958             :                 sal_Int32                       i;
     959           0 :                 for( i = 0 ; i < nCount ; ++i )
     960             :                 {
     961           0 :                     Any                                 aAny( xNameAccess->getByName( pDic[ i ] ) );
     962           0 :                     Reference< XConversionDictionary >  xDic;
     963           0 :                     if( ( aAny >>= xDic ) && xDic.is() )
     964             :                     {
     965           0 :                         if( LANGUAGE_KOREAN == LanguageTag( xDic->getLocale() ).getLanguageType() )
     966             :                         {
     967           0 :                             m_aDictList.push_back( xDic );
     968           0 :                             AddDict( xDic->getName(), xDic->isActive() );
     969             :                         }
     970             :                     }
     971           0 :                 }
     972           0 :             }
     973             :         }
     974           0 :     }
     975             : 
     976           0 :     IMPL_LINK_NOARG(HangulHanjaOptionsDialog, OkHdl)
     977             :     {
     978           0 :         sal_uInt32              nCnt = m_aDictList.size();
     979           0 :         sal_uInt32              n = 0;
     980           0 :         sal_uInt32              nActiveDics = 0;
     981           0 :         Sequence< OUString >    aActiveDics;
     982             : 
     983           0 :         aActiveDics.realloc( nCnt );
     984           0 :         OUString*               pActActiveDic = aActiveDics.getArray();
     985             : 
     986           0 :         while( nCnt )
     987             :         {
     988           0 :             Reference< XConversionDictionary >  xDict = m_aDictList[ n ];
     989           0 :             SvTreeListEntry*                        pEntry = m_aDictsLB.SvTreeListBox::GetEntry( n );
     990             : 
     991             :             DBG_ASSERT( xDict.is(), "-HangulHanjaOptionsDialog::OkHdl(): someone is evaporated..." );
     992             :             DBG_ASSERT( pEntry, "-HangulHanjaOptionsDialog::OkHdl(): no one there in list?" );
     993             : 
     994           0 :             bool    bActive = m_aDictsLB.GetCheckButtonState( pEntry ) == SV_BUTTON_CHECKED;
     995           0 :             xDict->setActive( bActive );
     996           0 :             Reference< util::XFlushable > xFlush( xDict, uno::UNO_QUERY );
     997           0 :             if( xFlush.is() )
     998           0 :                 xFlush->flush();
     999             : 
    1000           0 :             if( bActive )
    1001             :             {
    1002           0 :                 pActActiveDic[ nActiveDics ] = xDict->getName();
    1003           0 :                 ++nActiveDics;
    1004             :             }
    1005             : 
    1006           0 :             ++n;
    1007           0 :             --nCnt;
    1008           0 :         }
    1009             : 
    1010             :         // save configuration
    1011           0 :         aActiveDics.realloc( nActiveDics );
    1012           0 :         Any             aTmp;
    1013           0 :         SvtLinguConfig  aLngCfg;
    1014           0 :         aTmp <<= aActiveDics;
    1015           0 :         aLngCfg.SetProperty( UPH_ACTIVE_CONVERSION_DICTIONARIES, aTmp );
    1016             : 
    1017           0 :         aTmp <<= bool( m_aIgnorepostCB.IsChecked() );
    1018           0 :         aLngCfg.SetProperty( UPH_IS_IGNORE_POST_POSITIONAL_WORD, aTmp );
    1019             : 
    1020           0 :         aTmp <<= bool( m_aShowrecentlyfirstCB.IsChecked() );
    1021           0 :         aLngCfg.SetProperty( UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST, aTmp );
    1022             : 
    1023           0 :         aTmp <<= bool( m_aAutoreplaceuniqueCB.IsChecked() );
    1024           0 :         aLngCfg.SetProperty( UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES, aTmp );
    1025             : 
    1026           0 :         EndDialog( RET_OK );
    1027           0 :         return 0;
    1028             :     }
    1029             : 
    1030           0 :     IMPL_LINK_NOARG(HangulHanjaOptionsDialog, DictsLB_SelectHdl)
    1031             :     {
    1032           0 :         bool    bSel = m_aDictsLB.FirstSelected() != NULL;
    1033             : 
    1034           0 :         m_aEditPB.Enable( bSel );
    1035           0 :         m_aDeletePB.Enable( bSel );
    1036             : 
    1037           0 :         return 0;
    1038             :     }
    1039             : 
    1040           0 :     IMPL_LINK_NOARG(HangulHanjaOptionsDialog, NewDictHdl)
    1041             :     {
    1042           0 :         String                      aName;
    1043           0 :         HangulHanjaNewDictDialog    aNewDlg( this );
    1044           0 :         aNewDlg.Execute();
    1045           0 :         if( aNewDlg.GetName( aName ) )
    1046             :         {
    1047           0 :             if( m_xConversionDictionaryList.is() )
    1048             :             {
    1049             :                 try
    1050             :                 {
    1051             :                     Reference< XConversionDictionary >  xDic =
    1052           0 :                         m_xConversionDictionaryList->addNewDictionary( aName, LanguageTag( LANGUAGE_KOREAN ).getLocale(), ConversionDictionaryType::HANGUL_HANJA );
    1053             : 
    1054           0 :                     if( xDic.is() )
    1055             :                     {
    1056             :                         //adapt local caches:
    1057           0 :                         m_aDictList.push_back( xDic );
    1058           0 :                         AddDict( xDic->getName(), xDic->isActive() );
    1059           0 :                     }
    1060             :                 }
    1061           0 :                 catch( const ElementExistException& )
    1062             :                 {
    1063             :                 }
    1064           0 :                 catch( const NoSupportException& )
    1065             :                 {
    1066             :                 }
    1067             :             }
    1068             :         }
    1069             : 
    1070           0 :         return 0L;
    1071             :     }
    1072             : 
    1073           0 :     IMPL_LINK_NOARG(HangulHanjaOptionsDialog, EditDictHdl)
    1074             :     {
    1075           0 :         SvTreeListEntry*    pEntry = m_aDictsLB.FirstSelected();
    1076             :         DBG_ASSERT( pEntry, "+HangulHanjaEditDictDialog::EditDictHdl(): call of edit should not be possible with no selection!" );
    1077           0 :         if( pEntry )
    1078             :         {
    1079           0 :             HangulHanjaEditDictDialog   aEdDlg( this, m_aDictList, m_aDictsLB.GetSelectEntryPos() );
    1080           0 :             aEdDlg.Execute();
    1081             :         }
    1082           0 :         return 0L;
    1083             :     }
    1084             : 
    1085           0 :     IMPL_LINK_NOARG(HangulHanjaOptionsDialog, DeleteDictHdl)
    1086             :     {
    1087           0 :         sal_uInt16 nSelPos = m_aDictsLB.GetSelectEntryPos();
    1088           0 :         if( nSelPos != LISTBOX_ENTRY_NOTFOUND )
    1089             :         {
    1090           0 :             Reference< XConversionDictionary >  xDic( m_aDictList[ nSelPos ] );
    1091           0 :             if( m_xConversionDictionaryList.is() && xDic.is() )
    1092             :             {
    1093           0 :                 Reference< XNameContainer >     xNameCont = m_xConversionDictionaryList->getDictionaryContainer();
    1094           0 :                 if( xNameCont.is() )
    1095             :                 {
    1096             :                     try
    1097             :                     {
    1098           0 :                         xNameCont->removeByName( xDic->getName() );
    1099             : 
    1100             :                         //adapt local caches:
    1101           0 :                         HHDictList::iterator aIter(m_aDictList.begin());
    1102           0 :                         m_aDictList.erase(aIter+nSelPos );
    1103           0 :                         m_aDictsLB.RemoveEntry( nSelPos );
    1104             :                     }
    1105           0 :                     catch( const ElementExistException& )
    1106             :                     {
    1107             :                     }
    1108           0 :                     catch( const NoSupportException& )
    1109             :                     {
    1110             :                     }
    1111           0 :                 }
    1112           0 :             }
    1113             :         }
    1114             : 
    1115           0 :         return 0L;
    1116             :     }
    1117             : 
    1118           0 :     HangulHanjaOptionsDialog::HangulHanjaOptionsDialog( Window* _pParent )
    1119           0 :         :ModalDialog            ( _pParent, CUI_RES( RID_SVX_MDLG_HANGULHANJA_OPT ) )
    1120           0 :         ,m_aUserdefdictFT       ( this, CUI_RES( FT_USERDEFDICT ) )
    1121           0 :         ,m_aDictsLB             ( this, CUI_RES( LB_DICTS ) )
    1122           0 :         ,m_aOptionsFL           ( this, CUI_RES( FL_OPTIONS ) )
    1123           0 :         ,m_aIgnorepostCB        ( this, CUI_RES( CB_IGNOREPOST ) )
    1124           0 :         ,m_aShowrecentlyfirstCB ( this, CUI_RES( CB_SHOWRECENTLYFIRST ) )
    1125           0 :         ,m_aAutoreplaceuniqueCB ( this, CUI_RES( CB_AUTOREPLACEUNIQUE ) )
    1126           0 :         ,m_aNewPB               ( this, CUI_RES( PB_HHO_NEW ) )
    1127           0 :         ,m_aEditPB              ( this, CUI_RES( PB_HHO_EDIT ) )
    1128           0 :         ,m_aDeletePB            ( this, CUI_RES( PB_HHO_DELETE ) )
    1129           0 :         ,m_aOkPB                ( this, CUI_RES( PB_HHO_OK ) )
    1130           0 :         ,m_aCancelPB            ( this, CUI_RES( PB_HHO_CANCEL ) )
    1131           0 :         ,m_aHelpPB              ( this, CUI_RES( PB_HHO_HELP ) )
    1132             : 
    1133             :         ,m_pCheckButtonData     ( NULL )
    1134           0 :         ,m_xConversionDictionaryList( NULL )
    1135             :     {
    1136           0 :         m_aDictsLB.SetStyle( m_aDictsLB.GetStyle() | WB_CLIPCHILDREN | WB_HSCROLL | WB_FORCE_MAKEVISIBLE );
    1137           0 :         m_aDictsLB.SetSelectionMode( SINGLE_SELECTION );
    1138           0 :         m_aDictsLB.SetHighlightRange();
    1139           0 :         m_aDictsLB.SetSelectHdl( LINK( this, HangulHanjaOptionsDialog, DictsLB_SelectHdl ) );
    1140           0 :         m_aDictsLB.SetDeselectHdl( LINK( this, HangulHanjaOptionsDialog, DictsLB_SelectHdl ) );
    1141             : 
    1142           0 :         m_aOkPB.SetClickHdl( LINK( this, HangulHanjaOptionsDialog, OkHdl ) );
    1143           0 :         m_aNewPB.SetClickHdl( LINK( this, HangulHanjaOptionsDialog, NewDictHdl ) );
    1144           0 :         m_aEditPB.SetClickHdl( LINK( this, HangulHanjaOptionsDialog, EditDictHdl ) );
    1145           0 :         m_aDeletePB.SetClickHdl( LINK( this, HangulHanjaOptionsDialog, DeleteDictHdl ) );
    1146             : 
    1147           0 :         FreeResource();
    1148             : 
    1149           0 :         SvtLinguConfig  aLngCfg;
    1150           0 :         Any             aTmp;
    1151           0 :         bool            bVal = bool();
    1152           0 :         aTmp = aLngCfg.GetProperty( UPH_IS_IGNORE_POST_POSITIONAL_WORD );
    1153           0 :         if( aTmp >>= bVal )
    1154           0 :             m_aIgnorepostCB.Check( bVal );
    1155             : 
    1156           0 :         aTmp = aLngCfg.GetProperty( UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST );
    1157           0 :         if( aTmp >>= bVal )
    1158           0 :             m_aShowrecentlyfirstCB.Check( bVal );
    1159             : 
    1160           0 :         aTmp = aLngCfg.GetProperty( UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES );
    1161           0 :         if( aTmp >>= bVal )
    1162           0 :             m_aAutoreplaceuniqueCB.Check( bVal );
    1163             : 
    1164           0 :         Init();
    1165           0 :     }
    1166             : 
    1167           0 :     HangulHanjaOptionsDialog::~HangulHanjaOptionsDialog()
    1168             :     {
    1169           0 :         SvTreeListEntry*    pEntry = m_aDictsLB.First();
    1170             :         String*         pDel;
    1171           0 :         while( pEntry )
    1172             :         {
    1173           0 :             pDel = ( String* ) pEntry->GetUserData();
    1174           0 :             if( pDel )
    1175           0 :                 delete pDel;
    1176           0 :             pEntry = m_aDictsLB.Next( pEntry );
    1177             :         }
    1178             : 
    1179           0 :         if( m_pCheckButtonData )
    1180           0 :             delete m_pCheckButtonData;
    1181           0 :     }
    1182             : 
    1183           0 :     void HangulHanjaOptionsDialog::AddDict( const String& _rName, bool _bChecked )
    1184             :     {
    1185           0 :         SvTreeListEntry*    pEntry = m_aDictsLB.SvTreeListBox::InsertEntry( _rName );
    1186           0 :         m_aDictsLB.SetCheckButtonState( pEntry, _bChecked? SV_BUTTON_CHECKED : SV_BUTTON_UNCHECKED );
    1187           0 :         pEntry->SetUserData( new String( _rName ) );
    1188           0 :     }
    1189             : 
    1190             :     //=========================================================================
    1191             :     //= HangulHanjaNewDictDialog
    1192             :     //=========================================================================
    1193             :     //-------------------------------------------------------------------------
    1194             : 
    1195           0 :     IMPL_LINK_NOARG(HangulHanjaNewDictDialog, OKHdl)
    1196             :     {
    1197           0 :         String  aName(comphelper::string::stripEnd(m_aDictNameED.GetText(), ' '));
    1198             : 
    1199           0 :         m_bEntered = aName.Len() > 0;
    1200           0 :         if( m_bEntered )
    1201           0 :             m_aDictNameED.SetText( aName );     // do this in case of trailing chars have been deleted
    1202             : 
    1203           0 :         EndDialog( RET_OK );
    1204           0 :         return 0;
    1205             :     }
    1206             : 
    1207           0 :     IMPL_LINK_NOARG(HangulHanjaNewDictDialog, ModifyHdl)
    1208             :     {
    1209           0 :         String aName(comphelper::string::stripEnd(m_aDictNameED.GetText(), ' '));
    1210             : 
    1211           0 :         m_aOkBtn.Enable( aName.Len() > 0 );
    1212             : 
    1213           0 :         return 0;
    1214             :     }
    1215             : 
    1216           0 :     HangulHanjaNewDictDialog::HangulHanjaNewDictDialog( Window* _pParent )
    1217           0 :         :ModalDialog    ( _pParent, CUI_RES( RID_SVX_MDLG_HANGULHANJA_NEWDICT ) )
    1218           0 :         ,m_aNewDictFL   ( this, CUI_RES( FL_NEWDICT ) )
    1219           0 :         ,m_aDictNameFT  ( this, CUI_RES( FT_DICTNAME ) )
    1220           0 :         ,m_aDictNameED  ( this, CUI_RES( ED_DICTNAME ) )
    1221           0 :         ,m_aOkBtn       ( this, CUI_RES( PB_NEWDICT_OK ) )
    1222           0 :         ,m_aCancelBtn   ( this, CUI_RES( PB_NEWDICT_ESC ) )
    1223           0 :         ,m_aHelpBtn     ( this, CUI_RES( PB_NEWDICT_HLP ) )
    1224             : 
    1225           0 :         ,m_bEntered     ( false )
    1226             :     {
    1227           0 :         m_aOkBtn.SetClickHdl( LINK( this, HangulHanjaNewDictDialog, OKHdl ) );
    1228             : 
    1229           0 :         m_aDictNameED.SetModifyHdl( LINK( this, HangulHanjaNewDictDialog, ModifyHdl ) );
    1230             : 
    1231           0 :         FreeResource();
    1232           0 :     }
    1233             : 
    1234           0 :     HangulHanjaNewDictDialog::~HangulHanjaNewDictDialog()
    1235             :     {
    1236           0 :     }
    1237             : 
    1238           0 :     bool HangulHanjaNewDictDialog::GetName( String& _rRetName ) const
    1239             :     {
    1240           0 :         if( m_bEntered )
    1241           0 :             _rRetName = comphelper::string::stripEnd(m_aDictNameED.GetText(), ' ');
    1242             : 
    1243           0 :         return m_bEntered;
    1244             :     }
    1245             : 
    1246             :     //=========================================================================
    1247             :     //= HangulHanjaEditDictDialog
    1248             :     //=========================================================================
    1249             :     //-------------------------------------------------------------------------
    1250             : 
    1251             :     class SuggestionList
    1252             :     {
    1253             :     private:
    1254             :     protected:
    1255             :         sal_uInt16          m_nSize;
    1256             :         String**            m_ppElements;
    1257             :         sal_uInt16          m_nNumOfEntries;
    1258             :         sal_uInt16          m_nAct;
    1259             : 
    1260             :         const String*       _Next( void );
    1261             :     public:
    1262             :                             SuggestionList( sal_uInt16 _nNumOfElements );
    1263             :         virtual             ~SuggestionList();
    1264             : 
    1265             :         bool                Set( const String& _rElement, sal_uInt16 _nNumOfElement );
    1266             :         bool                Reset( sal_uInt16 _nNumOfElement );
    1267             :         const String*       Get( sal_uInt16 _nNumOfElement ) const;
    1268             :         void                Clear( void );
    1269             : 
    1270             :         const String*       First( void );
    1271             :         const String*       Next( void );
    1272             : 
    1273             :         inline sal_uInt16   GetCount( void ) const;
    1274             :     };
    1275             : 
    1276           0 :     inline sal_uInt16 SuggestionList::GetCount( void ) const
    1277             :     {
    1278           0 :         return m_nNumOfEntries;
    1279             :     }
    1280             : 
    1281           0 :     SuggestionList::SuggestionList( sal_uInt16 _nNumOfElements )
    1282             :     {
    1283           0 :         if( !_nNumOfElements )
    1284           0 :             _nNumOfElements = 1;
    1285             : 
    1286           0 :         m_nSize = _nNumOfElements;
    1287             : 
    1288           0 :         m_ppElements = new String*[ m_nSize ];
    1289           0 :         m_nAct = m_nNumOfEntries = 0;
    1290             : 
    1291           0 :         String**    ppNull = m_ppElements;
    1292           0 :         sal_uInt16  n = _nNumOfElements;
    1293           0 :         while( n )
    1294             :         {
    1295           0 :             *ppNull = NULL;
    1296           0 :             ++ppNull;
    1297           0 :             --n;
    1298             :         }
    1299           0 :     }
    1300             : 
    1301           0 :     SuggestionList::~SuggestionList()
    1302             :     {
    1303           0 :         Clear();
    1304           0 :     }
    1305             : 
    1306           0 :     bool SuggestionList::Set( const String& _rElement, sal_uInt16 _nNumOfElement )
    1307             :     {
    1308           0 :         bool    bRet = _nNumOfElement < m_nSize;
    1309           0 :         if( bRet )
    1310             :         {
    1311           0 :             String**    ppElem = m_ppElements + _nNumOfElement;
    1312           0 :             if( *ppElem )
    1313           0 :                 **ppElem = _rElement;
    1314             :             else
    1315             :             {
    1316           0 :                 *ppElem = new String( _rElement );
    1317           0 :                 ++m_nNumOfEntries;
    1318             :             }
    1319             :         }
    1320             : 
    1321           0 :         return bRet;
    1322             :     }
    1323             : 
    1324           0 :     bool SuggestionList::Reset( sal_uInt16 _nNumOfElement )
    1325             :     {
    1326           0 :         bool    bRet = _nNumOfElement < m_nSize;
    1327           0 :         if( bRet )
    1328             :         {
    1329           0 :             String**    ppElem = m_ppElements + _nNumOfElement;
    1330           0 :             if( *ppElem )
    1331             :             {
    1332           0 :                 delete *ppElem;
    1333           0 :                 *ppElem = NULL;
    1334           0 :                 --m_nNumOfEntries;
    1335             :             }
    1336             :         }
    1337             : 
    1338           0 :         return bRet;
    1339             :     }
    1340             : 
    1341           0 :     const String* SuggestionList::Get( sal_uInt16 _nNumOfElement ) const
    1342             :     {
    1343             :         const String*   pRet;
    1344             : 
    1345           0 :         if( _nNumOfElement < m_nSize )
    1346           0 :             pRet = m_ppElements[ _nNumOfElement ];
    1347             :         else
    1348           0 :             pRet = NULL;
    1349             : 
    1350           0 :         return pRet;
    1351             :     }
    1352             : 
    1353           0 :     void SuggestionList::Clear( void )
    1354             :     {
    1355           0 :         if( m_nNumOfEntries )
    1356             :         {
    1357           0 :             String**    ppDel = m_ppElements;
    1358           0 :             sal_uInt16  nCnt = m_nSize;
    1359           0 :             while( nCnt )
    1360             :             {
    1361           0 :                 if( *ppDel )
    1362             :                 {
    1363           0 :                     delete *ppDel;
    1364           0 :                     *ppDel = NULL;
    1365             :                 }
    1366             : 
    1367           0 :                 ++ppDel;
    1368           0 :                 --nCnt;
    1369             :             }
    1370             : 
    1371           0 :             m_nNumOfEntries = m_nAct = 0;
    1372             :         }
    1373           0 :     }
    1374             : 
    1375           0 :     const String* SuggestionList::_Next( void )
    1376             :     {
    1377           0 :         const String*   pRet = NULL;
    1378           0 :         while( m_nAct < m_nSize && !pRet )
    1379             :         {
    1380           0 :             pRet = m_ppElements[ m_nAct ];
    1381           0 :             if( !pRet )
    1382           0 :                 ++m_nAct;
    1383             :         }
    1384             : 
    1385           0 :         return pRet;
    1386             :     }
    1387             : 
    1388           0 :     const String* SuggestionList::First( void )
    1389             :     {
    1390           0 :         m_nAct = 0;
    1391           0 :         return _Next();
    1392             :     }
    1393             : 
    1394           0 :     const String* SuggestionList::Next( void )
    1395             :     {
    1396             :         const String*   pRet;
    1397             : 
    1398           0 :         if( m_nAct < m_nNumOfEntries )
    1399             :         {
    1400           0 :             ++m_nAct;
    1401           0 :             pRet = _Next();
    1402             :         }
    1403             :         else
    1404           0 :             pRet = NULL;
    1405             : 
    1406           0 :         return pRet;
    1407             :     }
    1408             : 
    1409             : 
    1410           0 :     bool SuggestionEdit::ShouldScroll( bool _bUp ) const
    1411             :     {
    1412           0 :         bool    bRet = false;
    1413             : 
    1414           0 :         if( _bUp )
    1415             :         {
    1416           0 :             if( !m_pPrev )
    1417           0 :                 bRet = m_rScrollBar.GetThumbPos() > m_rScrollBar.GetRangeMin();
    1418             :         }
    1419             :         else
    1420             :         {
    1421           0 :             if( !m_pNext )
    1422           0 :                 bRet = m_rScrollBar.GetThumbPos() < ( m_rScrollBar.GetRangeMax() - 4 );
    1423             :         }
    1424             : 
    1425           0 :         return bRet;
    1426             :     }
    1427             : 
    1428           0 :     void SuggestionEdit::DoJump( bool _bUp )
    1429             :     {
    1430           0 :         const Link&     rLoseFocusHdl = GetLoseFocusHdl();
    1431           0 :         if( rLoseFocusHdl.IsSet() )
    1432           0 :             rLoseFocusHdl.Call( this );
    1433           0 :         m_rScrollBar.SetThumbPos( m_rScrollBar.GetThumbPos() + ( _bUp? -1 : 1 ) );
    1434             : 
    1435           0 :         ( static_cast< HangulHanjaEditDictDialog* >( GetParent() ) )->UpdateScrollbar();
    1436           0 :     }
    1437             : 
    1438           0 :     SuggestionEdit::SuggestionEdit( Window* pParent, const ResId& rResId,
    1439             :         ScrollBar& _rScrollBar, SuggestionEdit* _pPrev, SuggestionEdit* _pNext  )
    1440             :         :Edit( pParent, rResId )
    1441             :         ,m_pPrev( _pPrev )
    1442             :         ,m_pNext( _pNext )
    1443           0 :         ,m_rScrollBar( _rScrollBar )
    1444             :     {
    1445           0 :     }
    1446             : 
    1447           0 :     SuggestionEdit::~SuggestionEdit()
    1448             :     {
    1449           0 :     }
    1450             : 
    1451           0 :     long SuggestionEdit::PreNotify( NotifyEvent& rNEvt )
    1452             :     {
    1453           0 :         long    nHandled = 0;
    1454           0 :         if( rNEvt.GetType() == EVENT_KEYINPUT )
    1455             :         {
    1456           0 :             const KeyEvent*             pKEvt = rNEvt.GetKeyEvent();
    1457           0 :             const KeyCode&              rKeyCode = pKEvt->GetKeyCode();
    1458           0 :             sal_uInt16                      nMod = rKeyCode.GetModifier();
    1459           0 :             sal_uInt16                      nCode = rKeyCode.GetCode();
    1460           0 :             if( nCode == KEY_TAB && ( !nMod || KEY_SHIFT == nMod ) )
    1461             :             {
    1462           0 :                 bool        bUp = KEY_SHIFT == nMod;
    1463           0 :                 if( ShouldScroll( bUp ) )
    1464             :                 {
    1465           0 :                     DoJump( bUp );
    1466           0 :                     SetSelection( Selection( 0, SELECTION_MAX ) );
    1467             :                         // Tab-travel doesn't really happen, so emulate it by setting a selection manually
    1468           0 :                     nHandled = 1;
    1469           0 :                 }
    1470             :             }
    1471           0 :             else if( KEY_UP == nCode || KEY_DOWN == nCode )
    1472             :             {
    1473           0 :                 bool        bUp = KEY_UP == nCode;
    1474           0 :                 if( ShouldScroll( bUp ) )
    1475             :                 {
    1476           0 :                     DoJump( bUp );
    1477           0 :                     nHandled = 1;
    1478             :                 }
    1479           0 :                 else if( bUp )
    1480             :                 {
    1481           0 :                     if( m_pPrev )
    1482             :                     {
    1483           0 :                         m_pPrev->GrabFocus();
    1484           0 :                         nHandled = 1;
    1485             :                     }
    1486             :                 }
    1487           0 :                 else if( m_pNext )
    1488             :                 {
    1489           0 :                     m_pNext->GrabFocus();
    1490           0 :                     nHandled = 1;
    1491             :                 }
    1492             :             }
    1493             :         }
    1494             : 
    1495           0 :         if( !nHandled )
    1496           0 :             nHandled = Edit::PreNotify( rNEvt );
    1497           0 :         return nHandled;
    1498             :     }
    1499             : 
    1500             : 
    1501             :     namespace
    1502             :     {
    1503           0 :         bool GetConversions(    Reference< XConversionDictionary >  _xDict,
    1504             :                                 const OUString& _rOrg,
    1505             :                                 Sequence< OUString >& _rEntries )
    1506             :         {
    1507           0 :             bool    bRet = false;
    1508           0 :             if( _xDict.is() && !_rOrg.isEmpty() )
    1509             :             {
    1510             :                 try
    1511             :                 {
    1512           0 :                     _rEntries = _xDict->getConversions( _rOrg,
    1513             :                                                         0,
    1514             :                                                         _rOrg.getLength(),
    1515             :                                                         ConversionDirection_FROM_LEFT,
    1516           0 :                                                         ::com::sun::star::i18n::TextConversionOption::NONE );
    1517           0 :                     bRet = _rEntries.getLength() > 0;
    1518             :                 }
    1519           0 :                 catch( const IllegalArgumentException& )
    1520             :                 {
    1521             :                 }
    1522             :             }
    1523             : 
    1524           0 :             return bRet;
    1525             :         }
    1526             :     }
    1527             : 
    1528             : 
    1529           0 :     IMPL_LINK_NOARG(HangulHanjaEditDictDialog, ScrollHdl)
    1530             :     {
    1531           0 :         UpdateScrollbar();
    1532             : 
    1533           0 :         return 0;
    1534             :     }
    1535             : 
    1536           0 :     IMPL_LINK_NOARG(HangulHanjaEditDictDialog, OriginalModifyHdl)
    1537             :     {
    1538           0 :         m_bModifiedOriginal = true;
    1539           0 :         m_aOriginal = comphelper::string::stripEnd(m_aOriginalLB.GetText(), ' ');
    1540             : 
    1541           0 :         UpdateSuggestions();
    1542           0 :         UpdateButtonStates();
    1543             : 
    1544           0 :         return 0;
    1545             :     }
    1546             : 
    1547           0 :     IMPL_LINK( HangulHanjaEditDictDialog, EditModifyHdl1, Edit*, pEdit )
    1548             :     {
    1549           0 :         EditModify( pEdit, 0 );
    1550           0 :         return 0;
    1551             :     }
    1552             : 
    1553           0 :     IMPL_LINK( HangulHanjaEditDictDialog, EditModifyHdl2, Edit*, pEdit )
    1554             :     {
    1555           0 :         EditModify( pEdit, 1 );
    1556           0 :         return 0;
    1557             :     }
    1558             : 
    1559           0 :     IMPL_LINK( HangulHanjaEditDictDialog, EditModifyHdl3, Edit*, pEdit )
    1560             :     {
    1561           0 :         EditModify( pEdit, 2 );
    1562           0 :         return 0;
    1563             :     }
    1564             : 
    1565           0 :     IMPL_LINK( HangulHanjaEditDictDialog, EditModifyHdl4, Edit*, pEdit )
    1566             :     {
    1567           0 :         EditModify( pEdit, 3 );
    1568           0 :         return 0;
    1569             :     }
    1570             : 
    1571           0 :     IMPL_LINK_NOARG(HangulHanjaEditDictDialog, BookLBSelectHdl)
    1572             :     {
    1573           0 :         InitEditDictDialog( m_aBookLB.GetSelectEntryPos() );
    1574           0 :         return 0;
    1575             :     }
    1576             : 
    1577           0 :     IMPL_LINK_NOARG(HangulHanjaEditDictDialog, NewPBPushHdl)
    1578             :     {
    1579             :         DBG_ASSERT( m_pSuggestions, "-HangulHanjaEditDictDialog::NewPBPushHdl(): no suggestions... search in hell..." );
    1580           0 :         Reference< XConversionDictionary >  xDict = m_rDictList[ m_nCurrentDict ];
    1581           0 :         if( xDict.is() && m_pSuggestions )
    1582             :         {
    1583             :             //delete old entry
    1584           0 :             bool bRemovedSomething = DeleteEntryFromDictionary( m_aOriginal, xDict );
    1585             : 
    1586           0 :             OUString                aLeft( m_aOriginal );
    1587           0 :             const String*           pRight = m_pSuggestions->First();
    1588           0 :             bool bAddedSomething = false;
    1589           0 :             while( pRight )
    1590             :             {
    1591             :                 try
    1592             :                 {
    1593             :                     //add new entry
    1594           0 :                     xDict->addEntry( aLeft, *pRight );
    1595           0 :                     bAddedSomething = true;
    1596             :                 }
    1597           0 :                 catch( const IllegalArgumentException& )
    1598             :                 {
    1599             :                 }
    1600           0 :                 catch( const ElementExistException& )
    1601             :                 {
    1602             :                 }
    1603             : 
    1604           0 :                 pRight = m_pSuggestions->Next();
    1605             :             }
    1606             : 
    1607           0 :             if(bAddedSomething||bRemovedSomething)
    1608           0 :                 InitEditDictDialog( m_nCurrentDict );
    1609             :         }
    1610             :         else
    1611             :         {
    1612             :             DBG_WARNING( "+HangulHanjaEditDictDialog::NewPBPushHdl(): dictionary faded away..." );
    1613             :         }
    1614           0 :         return 0;
    1615             :     }
    1616             : 
    1617           0 :     bool HangulHanjaEditDictDialog::DeleteEntryFromDictionary( const OUString&, const Reference< XConversionDictionary >& xDict  )
    1618             :     {
    1619           0 :         bool bRemovedSomething = false;
    1620           0 :         if( xDict.is() )
    1621             :         {
    1622           0 :             OUString                aOrg( m_aOriginal );
    1623           0 :             Sequence< OUString >    aEntries;
    1624           0 :             GetConversions( xDict, m_aOriginal, aEntries );
    1625             : 
    1626           0 :             sal_uInt32  n = aEntries.getLength();
    1627           0 :             OUString*   pEntry = aEntries.getArray();
    1628           0 :             while( n )
    1629             :             {
    1630             :                 try
    1631             :                 {
    1632           0 :                     xDict->removeEntry( aOrg, *pEntry );
    1633           0 :                     bRemovedSomething = true;
    1634             :                 }
    1635           0 :                 catch( const NoSuchElementException& )
    1636             :                 {   // can not be...
    1637             :                 }
    1638             : 
    1639           0 :                 ++pEntry;
    1640           0 :                 --n;
    1641           0 :             }
    1642             :         }
    1643           0 :         return bRemovedSomething;
    1644             :     }
    1645             : 
    1646           0 :     IMPL_LINK_NOARG(HangulHanjaEditDictDialog, DeletePBPushHdl)
    1647             :     {
    1648           0 :         if( DeleteEntryFromDictionary( m_aOriginal, m_rDictList[ m_nCurrentDict ] ) )
    1649             :         {
    1650           0 :             m_aOriginal.Erase();
    1651           0 :             m_bModifiedOriginal = true;
    1652           0 :             InitEditDictDialog( m_nCurrentDict );
    1653             :         }
    1654           0 :         return 0;
    1655             :     }
    1656             : 
    1657           0 :     void HangulHanjaEditDictDialog::InitEditDictDialog( sal_uInt32 _nSelDict )
    1658             :     {
    1659           0 :         if( m_pSuggestions )
    1660           0 :             m_pSuggestions->Clear();
    1661             : 
    1662           0 :         if( m_nCurrentDict != _nSelDict )
    1663             :         {
    1664           0 :             m_nCurrentDict = _nSelDict;
    1665           0 :             m_aOriginal.Erase();
    1666           0 :             m_bModifiedOriginal = true;
    1667             :         }
    1668             : 
    1669           0 :         UpdateOriginalLB();
    1670             : 
    1671           0 :         m_aOriginalLB.SetText( m_aOriginal.Len()? m_aOriginal : m_aEditHintText, Selection( 0, SELECTION_MAX ) );
    1672           0 :         m_aOriginalLB.GrabFocus();
    1673             : 
    1674           0 :         UpdateSuggestions();
    1675           0 :         UpdateButtonStates();
    1676           0 :     }
    1677             : 
    1678           0 :     void HangulHanjaEditDictDialog::UpdateOriginalLB( void )
    1679             :     {
    1680           0 :         m_aOriginalLB.Clear();
    1681           0 :         Reference< XConversionDictionary >  xDict = m_rDictList[ m_nCurrentDict ];
    1682           0 :         if( xDict.is() )
    1683             :         {
    1684           0 :             Sequence< OUString >    aEntries = xDict->getConversionEntries( ConversionDirection_FROM_LEFT );
    1685           0 :             sal_uInt32              n = aEntries.getLength();
    1686           0 :             OUString*               pEntry = aEntries.getArray();
    1687           0 :             while( n )
    1688             :             {
    1689           0 :                 m_aOriginalLB.InsertEntry( *pEntry );
    1690             : 
    1691           0 :                 ++pEntry;
    1692           0 :                 --n;
    1693           0 :             }
    1694             :         }
    1695             :         else
    1696             :         {
    1697             :             DBG_WARNING( "+HangulHanjaEditDictDialog::UpdateOriginalLB(): dictionary faded away..." );
    1698           0 :         }
    1699           0 :     }
    1700             : 
    1701           0 :     void HangulHanjaEditDictDialog::UpdateButtonStates()
    1702             :     {
    1703           0 :         bool bHaveValidOriginalString = m_aOriginal.Len() && m_aOriginal != m_aEditHintText;
    1704           0 :         bool bNew = bHaveValidOriginalString && m_pSuggestions && m_pSuggestions->GetCount() > 0;
    1705           0 :         bNew = bNew && (m_bModifiedSuggestions || m_bModifiedOriginal);
    1706             : 
    1707           0 :         m_aNewPB.Enable( bNew );
    1708           0 :         m_aDeletePB.Enable( !m_bModifiedOriginal && bHaveValidOriginalString );
    1709           0 :     }
    1710             : 
    1711           0 :     void HangulHanjaEditDictDialog::UpdateSuggestions( void )
    1712             :     {
    1713           0 :         Sequence< OUString > aEntries;
    1714           0 :         bool bFound = GetConversions( m_rDictList[ m_nCurrentDict ], m_aOriginal, aEntries );
    1715           0 :         if( bFound )
    1716             :         {
    1717           0 :             m_bModifiedOriginal = false;
    1718             : 
    1719           0 :             if( m_pSuggestions )
    1720           0 :                 m_pSuggestions->Clear();
    1721             : 
    1722             :             //fill found entries into boxes
    1723           0 :             sal_uInt32 nCnt = aEntries.getLength();
    1724           0 :             if( nCnt )
    1725             :             {
    1726           0 :                 if( !m_pSuggestions )
    1727           0 :                     m_pSuggestions = new SuggestionList( MAXNUM_SUGGESTIONS );
    1728             : 
    1729           0 :                 const OUString* pSugg = aEntries.getConstArray();
    1730           0 :                 sal_uInt32 n = 0;
    1731           0 :                 while( nCnt )
    1732             :                 {
    1733           0 :                     m_pSuggestions->Set( pSugg[ n ], sal_uInt16( n ) );
    1734           0 :                     ++n;
    1735           0 :                     --nCnt;
    1736             :                 }
    1737             :             }
    1738           0 :             m_bModifiedSuggestions=false;
    1739             :         }
    1740             : 
    1741           0 :         m_aScrollSB.SetThumbPos( 0 );
    1742           0 :         UpdateScrollbar();              // will force edits to be filled new
    1743           0 :     }
    1744             : 
    1745           0 :     void HangulHanjaEditDictDialog::SetEditText( Edit& _rEdit, sal_uInt16 _nEntryNum )
    1746             :     {
    1747           0 :         String  aStr;
    1748           0 :         if( m_pSuggestions )
    1749             :         {
    1750           0 :             const String*   p = m_pSuggestions->Get( _nEntryNum );
    1751           0 :             if( p )
    1752           0 :                 aStr = *p;
    1753             :         }
    1754             : 
    1755           0 :         _rEdit.SetText( aStr );
    1756           0 :     }
    1757             : 
    1758           0 :     void HangulHanjaEditDictDialog::EditModify( Edit* _pEdit, sal_uInt8 _nEntryOffset )
    1759             :     {
    1760           0 :         m_bModifiedSuggestions = true;
    1761             : 
    1762           0 :         String  aTxt( _pEdit->GetText() );
    1763           0 :         sal_uInt16 nEntryNum = m_nTopPos + _nEntryOffset;
    1764           0 :         if( aTxt.Len() == 0 )
    1765             :         {
    1766             :             //reset suggestion
    1767           0 :             if( m_pSuggestions )
    1768           0 :                 m_pSuggestions->Reset( nEntryNum );
    1769             :         }
    1770             :         else
    1771             :         {
    1772             :             //set suggestion
    1773           0 :             if( !m_pSuggestions )
    1774           0 :                 m_pSuggestions = new SuggestionList( MAXNUM_SUGGESTIONS );
    1775           0 :             m_pSuggestions->Set( aTxt, nEntryNum );
    1776             :         }
    1777             : 
    1778           0 :         UpdateButtonStates();
    1779           0 :     }
    1780             : 
    1781           0 :     HangulHanjaEditDictDialog::HangulHanjaEditDictDialog( Window* _pParent, HHDictList& _rDictList, sal_uInt32 _nSelDict )
    1782           0 :         :ModalDialog            ( _pParent, CUI_RES( RID_SVX_MDLG_HANGULHANJA_EDIT ) )
    1783           0 :         ,m_aEditHintText        ( CUI_RES( STR_EDITHINT ) )
    1784             :         ,m_rDictList            ( _rDictList )
    1785             :         ,m_nCurrentDict         ( 0xFFFFFFFF )
    1786             :         ,m_pSuggestions         ( NULL )
    1787           0 :         ,m_aBookFT              ( this, CUI_RES( FT_BOOK ) )
    1788           0 :         ,m_aBookLB              ( this, CUI_RES( LB_BOOK ) )
    1789           0 :         ,m_aOriginalFT          ( this, CUI_RES( FT_ORIGINAL ) )
    1790           0 :         ,m_aOriginalLB          ( this, CUI_RES( LB_ORIGINAL ) )
    1791           0 :         ,m_aSuggestionsFT       ( this, CUI_RES( FT_SUGGESTIONS ) )
    1792           0 :         ,m_aEdit1               ( this, CUI_RES( ED_1 ), m_aScrollSB, NULL, &m_aEdit2 )
    1793           0 :         ,m_aEdit2               ( this, CUI_RES( ED_2 ), m_aScrollSB, &m_aEdit1, &m_aEdit3 )
    1794           0 :         ,m_aEdit3               ( this, CUI_RES( ED_3 ), m_aScrollSB, &m_aEdit2, &m_aEdit4 )
    1795           0 :         ,m_aEdit4               ( this, CUI_RES( ED_4 ), m_aScrollSB, &m_aEdit3, NULL )
    1796           0 :         ,m_aScrollSB            ( this, CUI_RES( SB_SCROLL ) )
    1797           0 :         ,m_aNewPB               ( this, CUI_RES( PB_HHE_NEW ) )
    1798           0 :         ,m_aDeletePB            ( this, CUI_RES( PB_HHE_DELETE ) )
    1799           0 :         ,m_aHelpPB              ( this, CUI_RES( PB_HHE_HELP ) )
    1800           0 :         ,m_aClosePB             ( this, CUI_RES( PB_HHE_CLOSE ) )
    1801             :         ,m_nTopPos              ( 0 )
    1802             :         ,m_bModifiedSuggestions ( false )
    1803           0 :         ,m_bModifiedOriginal    ( false )
    1804             :     {
    1805           0 :         m_aOriginalLB.SetModifyHdl( LINK( this, HangulHanjaEditDictDialog, OriginalModifyHdl ) );
    1806             : 
    1807           0 :         m_aNewPB.SetClickHdl( LINK( this, HangulHanjaEditDictDialog, NewPBPushHdl ) );
    1808           0 :         m_aNewPB.Enable( false );
    1809             : 
    1810           0 :         m_aDeletePB.SetClickHdl( LINK( this, HangulHanjaEditDictDialog, DeletePBPushHdl ) );
    1811             : 
    1812           0 :         m_aDeletePB.Enable( false );
    1813             : 
    1814             :     #if( MAXNUM_SUGGESTIONS <= 4 )
    1815             :         #error number of suggestions should not under-run the value of 5
    1816             :     #endif
    1817             : 
    1818           0 :         Link    aScrLk( LINK( this, HangulHanjaEditDictDialog, ScrollHdl ) );
    1819           0 :         m_aScrollSB.SetScrollHdl( aScrLk );
    1820           0 :         m_aScrollSB.SetEndScrollHdl( aScrLk );
    1821           0 :         m_aScrollSB.SetRangeMin( 0 );
    1822           0 :         m_aScrollSB.SetRangeMax( MAXNUM_SUGGESTIONS );
    1823           0 :         m_aScrollSB.SetPageSize( 4 );       // because we have 4 edits / page
    1824           0 :         m_aScrollSB.SetVisibleSize( 4 );
    1825             : 
    1826           0 :         m_aEdit1.SetModifyHdl( LINK( this, HangulHanjaEditDictDialog, EditModifyHdl1 ) );
    1827           0 :         m_aEdit2.SetModifyHdl( LINK( this, HangulHanjaEditDictDialog, EditModifyHdl2 ) );
    1828           0 :         m_aEdit3.SetModifyHdl( LINK( this, HangulHanjaEditDictDialog, EditModifyHdl3 ) );
    1829           0 :         m_aEdit4.SetModifyHdl( LINK( this, HangulHanjaEditDictDialog, EditModifyHdl4 ) );
    1830             : 
    1831           0 :         m_aBookLB.SetSelectHdl( LINK( this, HangulHanjaEditDictDialog, BookLBSelectHdl ) );
    1832           0 :         sal_uInt32  nDictCnt = m_rDictList.size();
    1833           0 :         for( sal_uInt32 n = 0 ; n < nDictCnt ; ++n )
    1834             :         {
    1835           0 :             Reference< XConversionDictionary >  xDic( m_rDictList[n] );
    1836           0 :             String aName;
    1837           0 :             if(xDic.is())
    1838           0 :                 aName = xDic->getName();
    1839           0 :             m_aBookLB.InsertEntry( aName );
    1840           0 :         }
    1841           0 :         m_aBookLB.SelectEntryPos( sal_uInt16( _nSelDict ) );
    1842             : 
    1843           0 :         FreeResource();
    1844             : 
    1845           0 :         InitEditDictDialog( _nSelDict );
    1846           0 :     }
    1847             : 
    1848           0 :     HangulHanjaEditDictDialog::~HangulHanjaEditDictDialog()
    1849             :     {
    1850           0 :         if( m_pSuggestions )
    1851           0 :             delete m_pSuggestions;
    1852           0 :     }
    1853             : 
    1854           0 :     void HangulHanjaEditDictDialog::UpdateScrollbar( void )
    1855             :     {
    1856           0 :         sal_uInt16  nPos = sal_uInt16( m_aScrollSB.GetThumbPos() );
    1857           0 :         m_nTopPos = nPos;
    1858             : 
    1859           0 :         SetEditText( m_aEdit1, nPos++ );
    1860           0 :         SetEditText( m_aEdit2, nPos++ );
    1861           0 :         SetEditText( m_aEdit3, nPos++ );
    1862           0 :         SetEditText( m_aEdit4, nPos );
    1863           0 :     }
    1864             : 
    1865             : //.............................................................................
    1866             : }   // namespace svx
    1867             : //.............................................................................
    1868             : 
    1869             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10