| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_cui.hxx" |
| |
| #include "hangulhanjadlg.hxx" |
| #include "hangulhanjadlg.hrc" |
| #include "commonlingui.hxx" |
| #include <dialmgr.hxx> |
| |
| #include <cuires.hrc> |
| #include "helpid.hrc" |
| |
| #include <algorithm> |
| #include <tools/urlobj.hxx> |
| #include <vcl/controllayout.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <unotools/lingucfg.hxx> |
| #include <unotools/linguprops.hxx> |
| #include <com/sun/star/linguistic2/ConversionDictionaryType.hpp> |
| #include <com/sun/star/linguistic2/ConversionDirection.hdl> |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> |
| #include <com/sun/star/i18n/TextConversionOption.hdl> |
| #include <com/sun/star/util/XFlushable.hpp> |
| |
| #include <comphelper/processfactory.hxx> |
| |
| #define HHC editeng::HangulHanjaConversion |
| #define LINE_CNT static_cast< sal_uInt16 >(2) |
| |
| //............................................................................. |
| namespace svx |
| { |
| //............................................................................. |
| /* |
| using HangulHanjaConversion::eSimpleConversion; |
| using HangulHanjaConversion::eHangulBracketed; |
| using HangulHanjaConversion::eHanjaBracketed; |
| using HangulHanjaConversion::eRubyHanjaAbove; |
| using HangulHanjaConversion::eRubyHanjaBelow; |
| using HangulHanjaConversion::eRubyHangulAbove; |
| using HangulHanjaConversion::eRubyHangulBelow; |
| */ |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::linguistic2; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::container; |
| using ::rtl::OUString; |
| |
| //------------------------------------------------------------------------- |
| namespace |
| { |
| class FontSwitch |
| { |
| private: |
| OutputDevice& m_rDev; |
| |
| public: |
| inline FontSwitch( OutputDevice& _rDev, const Font& _rTemporaryFont ) |
| :m_rDev( _rDev ) |
| { |
| m_rDev.Push( PUSH_FONT ); |
| m_rDev.SetFont( _rTemporaryFont ); |
| } |
| inline ~FontSwitch( ) |
| { |
| m_rDev.Pop( ); |
| } |
| }; |
| } |
| |
| //========================================================================= |
| //= PseudoRubyText |
| //========================================================================= |
| /** a class which allows to draw two texts in a pseudo-ruby way (which basically |
| means one text above or below the other, and a little bit smaller) |
| */ |
| class PseudoRubyText |
| { |
| public: |
| enum RubyPosition |
| { |
| eAbove, eBelow |
| }; |
| |
| protected: |
| const String m_sPrimaryText; |
| const String m_sSecondaryText; |
| const RubyPosition m_ePosition; |
| |
| public: |
| PseudoRubyText( const String& _rPrimary, const String& _rSecondary, const RubyPosition _ePosition ); |
| |
| public: |
| void Paint( OutputDevice& _rDevice, const Rectangle& _rRect, sal_uInt16 _nTextStyle, |
| Rectangle* _pPrimaryLocation = NULL, Rectangle* _pSecondaryLocation = NULL, |
| ::vcl::ControlLayoutData* _pLayoutData = NULL ); |
| }; |
| |
| //------------------------------------------------------------------------- |
| PseudoRubyText::PseudoRubyText( const String& _rPrimary, const String& _rSecondary, const RubyPosition _ePosition ) |
| :m_sPrimaryText( _rPrimary ) |
| ,m_sSecondaryText( _rSecondary ) |
| ,m_ePosition( _ePosition ) |
| { |
| } |
| |
| //------------------------------------------------------------------------- |
| void PseudoRubyText::Paint( OutputDevice& _rDevice, const Rectangle& _rRect, sal_uInt16 _nTextStyle, |
| Rectangle* _pPrimaryLocation, Rectangle* _pSecondaryLocation, ::vcl::ControlLayoutData* _pLayoutData ) |
| { |
| bool bLayoutOnly = NULL != _pLayoutData; |
| MetricVector* pTextMetrics = bLayoutOnly ? &_pLayoutData->m_aUnicodeBoundRects : NULL; |
| String* pDisplayText = bLayoutOnly ? &_pLayoutData->m_aDisplayText : NULL; |
| |
| Size aPlaygroundSize( _rRect.GetSize() ); |
| |
| // the font for the secondary text: |
| Font aSmallerFont( _rDevice.GetFont() ); |
| // heuristic: 80% of the original size |
| aSmallerFont.SetHeight( (long)( 0.8 * aSmallerFont.GetHeight() ) ); |
| |
| // let's calculate the size of our two texts |
| Rectangle aPrimaryRect = _rDevice.GetTextRect( _rRect, m_sPrimaryText, _nTextStyle ); |
| Rectangle aSecondaryRect; |
| { |
| FontSwitch aFontRestore( _rDevice, aSmallerFont ); |
| aSecondaryRect = _rDevice.GetTextRect( _rRect, m_sSecondaryText, _nTextStyle ); |
| } |
| |
| // position these rectangles properly |
| // x-axis: |
| sal_Int32 nCombinedWidth = ::std::max( aSecondaryRect.GetWidth(), aPrimaryRect.GetWidth() ); |
| // the rectangle where both texts will reside is as high as possible, and as wide as the |
| // widest of both text rects |
| aPrimaryRect.Left() = aSecondaryRect.Left() = _rRect.Left(); |
| aPrimaryRect.Right() = aSecondaryRect.Right() = _rRect.Left() + nCombinedWidth; |
| if ( TEXT_DRAW_RIGHT & _nTextStyle ) |
| { |
| // move the rectangles to the right |
| aPrimaryRect.Move( aPlaygroundSize.Width() - nCombinedWidth, 0 ); |
| aSecondaryRect.Move( aPlaygroundSize.Width() - nCombinedWidth, 0 ); |
| } |
| else if ( TEXT_DRAW_CENTER & _nTextStyle ) |
| { |
| // center the rectangles |
| aPrimaryRect.Move( ( aPlaygroundSize.Width() - nCombinedWidth ) / 2, 0 ); |
| aSecondaryRect.Move( ( aPlaygroundSize.Width() - nCombinedWidth ) / 2, 0 ); |
| } |
| |
| // y-axis: |
| sal_Int32 nCombinedHeight = aPrimaryRect.GetHeight() + aSecondaryRect.GetHeight(); |
| // align to the top, for the moment |
| aPrimaryRect.Move( 0, _rRect.Top() - aPrimaryRect.Top() ); |
| aSecondaryRect.Move( 0, aPrimaryRect.Top() + aPrimaryRect.GetHeight() - aSecondaryRect.Top() ); |
| if ( TEXT_DRAW_BOTTOM & _nTextStyle ) |
| { |
| // move the rects to the bottom |
| aPrimaryRect.Move( 0, aPlaygroundSize.Height() - nCombinedHeight ); |
| aSecondaryRect.Move( 0, aPlaygroundSize.Height() - nCombinedHeight ); |
| } |
| else if ( TEXT_DRAW_VCENTER & _nTextStyle ) |
| { |
| // move the rects to the bottom |
| aPrimaryRect.Move( 0, ( aPlaygroundSize.Height() - nCombinedHeight ) / 2 ); |
| aSecondaryRect.Move( 0, ( aPlaygroundSize.Height() - nCombinedHeight ) / 2 ); |
| } |
| |
| // 'til here, everything we did assumes that the secondary text is painted _below_ the primary |
| // text. If this isn't the case, we need to correct the rectangles |
| if ( eAbove == m_ePosition ) |
| { |
| sal_Int32 nVertDistance = aSecondaryRect.Top() - aPrimaryRect.Top(); |
| aSecondaryRect.Move( 0, -nVertDistance ); |
| aPrimaryRect.Move( 0, nCombinedHeight - nVertDistance ); |
| } |
| |
| // now draw the texts |
| // as we already calculated the precise rectangles for the texts, we don't want to |
| // use the alignment flags given - within it's rect, every text is centered |
| sal_uInt16 nDrawTextStyle( _nTextStyle ); |
| nDrawTextStyle &= ~( TEXT_DRAW_RIGHT | TEXT_DRAW_LEFT | TEXT_DRAW_BOTTOM | TEXT_DRAW_TOP ); |
| nDrawTextStyle |= TEXT_DRAW_CENTER | TEXT_DRAW_VCENTER; |
| |
| _rDevice.DrawText( aPrimaryRect, m_sPrimaryText, nDrawTextStyle, pTextMetrics, pDisplayText ); |
| { |
| FontSwitch aFontRestore( _rDevice, aSmallerFont ); |
| _rDevice.DrawText( aSecondaryRect, m_sSecondaryText, nDrawTextStyle, pTextMetrics, pDisplayText ); |
| } |
| |
| // outta here |
| if ( _pPrimaryLocation ) |
| *_pPrimaryLocation = aPrimaryRect; |
| if ( _pSecondaryLocation ) |
| *_pSecondaryLocation = aSecondaryRect; |
| } |
| |
| //========================================================================= |
| //= RubyRadioButton |
| //========================================================================= |
| class RubyRadioButton :public RadioButton |
| ,protected PseudoRubyText |
| { |
| using svx::PseudoRubyText::Paint; |
| |
| public: |
| RubyRadioButton( |
| Window* _pParent, |
| const ResId& _rId, // the text in the resource will be taken as primary text |
| const String& _rSecondary, // this will be the secondary text which will be printed somewhat smaller |
| const PseudoRubyText::RubyPosition _ePosition ); |
| |
| protected: |
| virtual void Paint( const Rectangle& _rRect ); |
| }; |
| |
| //------------------------------------------------------------------------- |
| RubyRadioButton::RubyRadioButton( Window* _pParent, const ResId& _rId, |
| const String& _rSecondary, const PseudoRubyText::RubyPosition _ePosition ) |
| :RadioButton( _pParent, _rId ) |
| ,PseudoRubyText( RadioButton::GetText(), _rSecondary, _ePosition ) |
| { |
| } |
| |
| //------------------------------------------------------------------------- |
| void RubyRadioButton::Paint( const Rectangle& ) |
| { |
| HideFocus(); |
| |
| // calculate the size of the radio image - we're to paint our text _after_ this image |
| DBG_ASSERT( !GetModeRadioImage(), "RubyRadioButton::Paint: images not supported!" ); |
| Size aImageSize = GetRadioImage( GetSettings(), 0 ).GetSizePixel(); |
| aImageSize.Width() = CalcZoom( aImageSize.Width() ); |
| aImageSize.Height() = CalcZoom( aImageSize.Height() ); |
| |
| Rectangle aOverallRect( Point( 0, 0 ), GetOutputSizePixel() ); |
| aOverallRect.Left() += aImageSize.Width() + 4; // 4 is the separator between the image and the text |
| // inflate the rect a little bit (because the VCL radio button does the same) |
| Rectangle aTextRect( aOverallRect ); |
| ++aTextRect.Left(); --aTextRect.Right(); |
| ++aTextRect.Top(); --aTextRect.Bottom(); |
| |
| // calculate the text flags for the painting |
| sal_uInt16 nTextStyle = TEXT_DRAW_MNEMONIC; |
| WinBits nStyle = GetStyle( ); |
| |
| // the horizontal alignment |
| if ( nStyle & WB_RIGHT ) |
| nTextStyle |= TEXT_DRAW_RIGHT; |
| else if ( nStyle & WB_CENTER ) |
| nTextStyle |= TEXT_DRAW_CENTER; |
| else |
| nTextStyle |= TEXT_DRAW_LEFT; |
| // the vertical alignment |
| if ( nStyle & WB_BOTTOM ) |
| nTextStyle |= TEXT_DRAW_BOTTOM; |
| else if ( nStyle & WB_VCENTER ) |
| nTextStyle |= TEXT_DRAW_VCENTER; |
| else |
| nTextStyle |= TEXT_DRAW_TOP; |
| // mnemonics |
| if ( 0 == ( nStyle & WB_NOLABEL ) ) |
| nTextStyle |= TEXT_DRAW_MNEMONIC; |
| |
| // paint the ruby text |
| Rectangle aPrimaryTextLocation, aSecondaryTextLocation; |
| PseudoRubyText::Paint( *this, aTextRect, nTextStyle, &aPrimaryTextLocation, &aSecondaryTextLocation ); |
| |
| // the focus rectangle is to be painted around both texts |
| Rectangle aCombinedRect( aPrimaryTextLocation ); |
| aCombinedRect.Union( aSecondaryTextLocation ); |
| SetFocusRect( aCombinedRect ); |
| |
| // let the base class paint the radio button |
| // for this, give it the proper location to paint the image (vertically centered, relative to our text) |
| Rectangle aImageLocation( Point( 0, 0 ), aImageSize ); |
| sal_Int32 nTextHeight = aSecondaryTextLocation.Bottom() - aPrimaryTextLocation.Top(); |
| aImageLocation.Top() = aPrimaryTextLocation.Top() + ( nTextHeight - aImageSize.Height() ) / 2; |
| aImageLocation.Bottom() = aImageLocation.Top() + aImageSize.Height(); |
| SetStateRect( aImageLocation ); |
| DrawRadioButtonState( ); |
| |
| // mouse clicks should be recognized in a rect which is one pixel larger in each direction, plus |
| // includes the image |
| aCombinedRect.Left() = aImageLocation.Left(); ++aCombinedRect.Right(); |
| --aCombinedRect.Top(); ++aCombinedRect.Bottom(); |
| SetMouseRect( aCombinedRect ); |
| |
| // paint the focus rect, if necessary |
| if ( HasFocus() ) |
| ShowFocus( aTextRect ); |
| } |
| |
| //========================================================================= |
| //= SuggestionSet |
| //========================================================================= |
| //------------------------------------------------------------------------- |
| |
| SuggestionSet::SuggestionSet( Window* pParent ) |
| : ValueSet( pParent, pParent->GetStyle() | WB_BORDER ) |
| |
| { |
| } |
| |
| SuggestionSet::~SuggestionSet() |
| { |
| ClearSet(); |
| } |
| |
| void SuggestionSet::UserDraw( const UserDrawEvent& rUDEvt ) |
| { |
| OutputDevice* pDev = rUDEvt.GetDevice(); |
| Rectangle aRect = rUDEvt.GetRect(); |
| sal_uInt16 nItemId = rUDEvt.GetItemId(); |
| |
| String sText = *static_cast< String* >( GetItemData( nItemId ) ); |
| pDev->DrawText( aRect, sText, TEXT_DRAW_CENTER | TEXT_DRAW_VCENTER ); |
| } |
| |
| void SuggestionSet::ClearSet() |
| { |
| sal_uInt16 i, nCount = GetItemCount(); |
| for ( i = 0; i < nCount; ++i ) |
| delete static_cast< String* >( GetItemData(i) ); |
| Clear(); |
| } |
| |
| //========================================================================= |
| //= SuggestionDisplay |
| //========================================================================= |
| //------------------------------------------------------------------------- |
| |
| SuggestionDisplay::SuggestionDisplay( Window* pParent, const ResId& rResId ) |
| : Control( pParent, rResId ) |
| , m_bDisplayListBox(true) |
| , m_aValueSet(this) |
| , m_aListBox(this,GetStyle() | WB_BORDER ) |
| , m_bInSelectionUpdate(false) |
| { |
| m_aValueSet.SetSelectHdl( LINK( this, SuggestionDisplay, SelectSuggestionHdl ) ); |
| m_aListBox.SetSelectHdl( LINK( this, SuggestionDisplay, SelectSuggestionHdl ) ); |
| |
| m_aValueSet.SetLineCount( LINE_CNT ); |
| m_aValueSet.SetStyle( m_aValueSet.GetStyle() | WB_ITEMBORDER | WB_FLATVALUESET | WB_VSCROLL ); |
| m_aValueSet.SetBorderStyle( WINDOW_BORDER_MONO ); |
| String aOneCharacter(RTL_CONSTASCII_STRINGPARAM("AU")); |
| long nItemWidth = 2*GetTextWidth( aOneCharacter ); |
| m_aValueSet.SetItemWidth( nItemWidth ); |
| |
| Point aPos(0,0); |
| Size aSize(GetSizePixel()); |
| m_aValueSet.SetSizePixel(aSize); |
| m_aListBox.SetSizePixel(aSize); |
| |
| implUpdateDisplay(); |
| } |
| |
| SuggestionDisplay::~SuggestionDisplay() |
| { |
| } |
| |
| void SuggestionDisplay::implUpdateDisplay() |
| { |
| bool bShowBox = IsVisible() && m_bDisplayListBox; |
| bool bShowSet = IsVisible() && !m_bDisplayListBox; |
| |
| m_aListBox.Show(bShowBox); |
| m_aValueSet.Show(bShowSet); |
| } |
| |
| void SuggestionDisplay::StateChanged( StateChangedType nStateChange ) |
| { |
| if( STATE_CHANGE_VISIBLE == nStateChange ) |
| implUpdateDisplay(); |
| } |
| |
| Control& SuggestionDisplay::implGetCurrentControl() |
| { |
| if( m_bDisplayListBox ) |
| return m_aListBox; |
| return m_aValueSet; |
| } |
| |
| void SuggestionDisplay::KeyInput( const KeyEvent& rKEvt ) |
| { |
| implGetCurrentControl().KeyInput( rKEvt ); |
| } |
| void SuggestionDisplay::KeyUp( const KeyEvent& rKEvt ) |
| { |
| implGetCurrentControl().KeyUp( rKEvt ); |
| } |
| void SuggestionDisplay::Activate() |
| { |
| implGetCurrentControl().Activate(); |
| } |
| void SuggestionDisplay::Deactivate() |
| { |
| implGetCurrentControl().Deactivate(); |
| } |
| void SuggestionDisplay::GetFocus() |
| { |
| implGetCurrentControl().GetFocus(); |
| } |
| void SuggestionDisplay::LoseFocus() |
| { |
| implGetCurrentControl().LoseFocus(); |
| } |
| void SuggestionDisplay::Command( const CommandEvent& rCEvt ) |
| { |
| implGetCurrentControl().Command( rCEvt ); |
| } |
| |
| void SuggestionDisplay::DisplayListBox( bool bDisplayListBox ) |
| { |
| if( m_bDisplayListBox != bDisplayListBox ) |
| { |
| Control& rOldControl = implGetCurrentControl(); |
| sal_Bool bHasFocus = rOldControl.HasFocus(); |
| |
| m_bDisplayListBox = bDisplayListBox; |
| |
| if( bHasFocus ) |
| { |
| Control& rNewControl = implGetCurrentControl(); |
| rNewControl.GrabFocus(); |
| } |
| |
| implUpdateDisplay(); |
| } |
| } |
| |
| IMPL_LINK( SuggestionDisplay, SelectSuggestionHdl, Control*, pControl ) |
| { |
| if( m_bInSelectionUpdate ) |
| return 0L; |
| |
| m_bInSelectionUpdate = true; |
| if(pControl==&m_aListBox) |
| { |
| sal_uInt16 nPos = m_aListBox.GetSelectEntryPos(); |
| m_aValueSet.SelectItem( nPos+1 ); //itemid == pos+1 (id 0 has special meaning) |
| } |
| else |
| { |
| sal_uInt16 nPos = m_aValueSet.GetSelectItemId()-1; //itemid == pos+1 (id 0 has special meaning) |
| m_aListBox.SelectEntryPos( nPos ); |
| } |
| m_bInSelectionUpdate = false; |
| m_aSelectLink.Call(this); |
| return 0L; |
| } |
| |
| void SuggestionDisplay::SetSelectHdl( const Link& rLink ) |
| { |
| m_aSelectLink = rLink; |
| } |
| void SuggestionDisplay::Clear() |
| { |
| m_aListBox.Clear(); |
| m_aValueSet.Clear(); |
| } |
| void SuggestionDisplay::InsertEntry( const XubString& rStr ) |
| { |
| sal_uInt16 nItemId = m_aListBox.InsertEntry( rStr ) + 1; //itemid == pos+1 (id 0 has special meaning) |
| m_aValueSet.InsertItem( nItemId ); |
| String* pItemData = new String(rStr); |
| m_aValueSet.SetItemData( nItemId, pItemData ); |
| } |
| void SuggestionDisplay::SelectEntryPos( sal_uInt16 nPos ) |
| { |
| m_aListBox.SelectEntryPos( nPos ); |
| m_aValueSet.SelectItem( nPos+1 ); //itemid == pos+1 (id 0 has special meaning) |
| } |
| sal_uInt16 SuggestionDisplay::GetEntryCount() const |
| { |
| return m_aListBox.GetEntryCount(); |
| } |
| XubString SuggestionDisplay::GetEntry( sal_uInt16 nPos ) const |
| { |
| return m_aListBox.GetEntry( nPos ); |
| } |
| XubString SuggestionDisplay::GetSelectEntry() const |
| { |
| return m_aListBox.GetSelectEntry(); |
| } |
| void SuggestionDisplay::SetHelpIds() |
| { |
| this->SetHelpId( HID_HANGULDLG_SUGGESTIONS ); |
| m_aValueSet.SetHelpId( HID_HANGULDLG_SUGGESTIONS_GRID ); |
| m_aListBox.SetHelpId( HID_HANGULDLG_SUGGESTIONS_LIST ); |
| } |
| |
| //========================================================================= |
| //= HangulHanjaConversionDialog |
| //========================================================================= |
| //------------------------------------------------------------------------- |
| HangulHanjaConversionDialog::HangulHanjaConversionDialog( Window* _pParent, HHC::ConversionDirection _ePrimaryDirection ) |
| :ModalDialog( _pParent, CUI_RES( RID_SVX_MDLG_HANGULHANJA ) ) |
| ,m_pPlayground( new SvxCommonLinguisticControl( this ) ) |
| ,m_aFind ( m_pPlayground.get(), CUI_RES( PB_FIND ) ) |
| ,m_aSuggestions ( m_pPlayground.get(), CUI_RES( CTL_SUGGESTIONS ) ) |
| ,m_aFormat ( m_pPlayground.get(), CUI_RES( FT_FORMAT ) ) |
| ,m_aSimpleConversion( m_pPlayground.get(), CUI_RES( RB_SIMPLE_CONVERSION ) ) |
| ,m_aHangulBracketed ( m_pPlayground.get(), CUI_RES( RB_HANJA_HANGUL_BRACKETED ) ) |
| ,m_aHanjaBracketed ( m_pPlayground.get(), CUI_RES( RB_HANGUL_HANJA_BRACKETED ) ) |
| ,m_aConversion ( m_pPlayground.get(), CUI_RES( FT_CONVERSION ) ) |
| ,m_aHangulOnly ( m_pPlayground.get(), CUI_RES( CB_HANGUL_ONLY ) ) |
| ,m_aHanjaOnly ( m_pPlayground.get(), CUI_RES( CB_HANJA_ONLY ) ) |
| ,m_aReplaceByChar ( m_pPlayground.get(), CUI_RES( CB_REPLACE_BY_CHARACTER ) ) |
| ,m_pIgnoreNonPrimary( NULL ) |
| ,m_bDocumentMode( true ) |
| { |
| // special creation of the 4 pseudo-ruby radio buttons |
| String sSecondaryHangul( CUI_RES( STR_HANGUL ) ); |
| String sSecondaryHanja( CUI_RES( STR_HANJA ) ); |
| m_pHanjaAbove.reset( new RubyRadioButton( m_pPlayground.get(), CUI_RES( RB_HANGUL_HANJA_ABOVE ), sSecondaryHanja, PseudoRubyText::eAbove ) ); |
| m_pHanjaBelow.reset( new RubyRadioButton( m_pPlayground.get(), CUI_RES( RB_HANGUL_HANJA_BELOW ), sSecondaryHanja, PseudoRubyText::eBelow ) ); |
| m_pHangulAbove.reset( new RubyRadioButton( m_pPlayground.get(), CUI_RES( RB_HANJA_HANGUL_ABOVE ), sSecondaryHangul, PseudoRubyText::eAbove ) ); |
| m_pHangulBelow.reset( new RubyRadioButton( m_pPlayground.get(), CUI_RES( RB_HANJA_HANGUL_BELOW ), sSecondaryHangul, PseudoRubyText::eBelow ) ); |
| |
| // since these 4 buttons are not created within the other members, they have a wrong initial Z-Order |
| // correct this |
| m_pHanjaAbove->SetZOrder( &m_aHanjaBracketed, WINDOW_ZORDER_BEHIND ); |
| m_pHanjaBelow->SetZOrder( m_pHanjaAbove.get(), WINDOW_ZORDER_BEHIND ); |
| m_pHangulAbove->SetZOrder( m_pHanjaBelow.get(), WINDOW_ZORDER_BEHIND ); |
| m_pHangulBelow->SetZOrder( m_pHangulAbove.get(), WINDOW_ZORDER_BEHIND ); |
| |
| // VCL automatically sets the WB_GROUP bit, if the previous sibling (at the moment of creation) |
| // is no radion button |
| m_pHanjaAbove->SetStyle( m_pHanjaAbove->GetStyle() & ~WB_GROUP ); |
| |
| // the "Find" button and the word input control may not have the proper distance/extensions |
| // -> correct this |
| Point aDistance = LogicToPixel( Point( 3, 0 ), MAP_APPFONT ); |
| sal_Int32 nTooLargeByPixels = |
| // right margin of the word input control |
| ( m_pPlayground->GetWordInputControl().GetPosPixel().X() |
| + m_pPlayground->GetWordInputControl().GetSizePixel().Width() |
| ) |
| // minus left margin of the find button |
| - m_aFind.GetPosPixel().X() |
| // plus desired distance between the both |
| + aDistance.X(); |
| // make the word input control smaller |
| Size aSize = m_pPlayground->GetWordInputControl().GetSizePixel(); |
| aSize.Width() -= nTooLargeByPixels; |
| m_pPlayground->GetWordInputControl().SetSizePixel( aSize ); |
| |
| // additionall, the playground is not wide enough (in it's default size) |
| sal_Int32 nEnlargeWidth = 0; |
| { |
| FixedText aBottomAnchor( m_pPlayground.get(), CUI_RES( FT_RESIZE_ANCHOR ) ); |
| Point aAnchorPos = aBottomAnchor.GetPosPixel(); |
| |
| nEnlargeWidth = aAnchorPos.X() - m_pPlayground->GetActionButtonsLocation().X(); |
| } |
| m_pPlayground->Enlarge( nEnlargeWidth, 0 ); |
| |
| // insert our controls into the z-order of the playground |
| m_pPlayground->InsertControlGroup( m_aFind, m_aFind, SvxCommonLinguisticControl::eLeftRightWords ); |
| m_pPlayground->InsertControlGroup( m_aSuggestions, m_aHanjaOnly, SvxCommonLinguisticControl::eSuggestionLabel ); |
| m_pPlayground->InsertControlGroup( m_aReplaceByChar, m_aReplaceByChar, SvxCommonLinguisticControl::eActionButtons ); |
| |
| m_pPlayground->SetButtonHandler( SvxCommonLinguisticControl::eClose, LINK( this, HangulHanjaConversionDialog, OnClose ) ); |
| m_pPlayground->GetWordInputControl().SetModifyHdl( LINK( this, HangulHanjaConversionDialog, OnSuggestionModified ) ); |
| m_aSuggestions.SetSelectHdl( LINK( this, HangulHanjaConversionDialog, OnSuggestionSelected ) ); |
| |
| m_aReplaceByChar.SetClickHdl( LINK( this, HangulHanjaConversionDialog, ClickByCharacterHdl ) ); |
| |
| m_aHangulOnly.SetClickHdl( LINK( this, HangulHanjaConversionDialog, OnConversionDirectionClicked ) ); |
| m_aHanjaOnly.SetClickHdl( LINK( this, HangulHanjaConversionDialog, OnConversionDirectionClicked ) ); |
| |
| m_pPlayground->SetButtonHandler( SvxCommonLinguisticControl::eOptions, |
| LINK( this, HangulHanjaConversionDialog, OnOption ) ); |
| m_pPlayground->GetButton( SvxCommonLinguisticControl::eOptions )->Show(); |
| // m_pPlayground->EnableButton( SvxCommonLinguisticControl::eOptions, true ); |
| |
| if ( editeng::HangulHanjaConversion::eHangulToHanja == _ePrimaryDirection ) |
| { |
| // m_aHanjaOnly.Enable( sal_False ); |
| m_pIgnoreNonPrimary = &m_aHangulOnly; |
| } |
| else |
| { |
| // m_aHangulOnly.Enable( sal_False ); |
| m_pIgnoreNonPrimary = &m_aHanjaOnly; |
| } |
| // m_pIgnoreNonPrimary->Check(); |
| |
| // initial focus |
| FocusSuggestion( ); |
| |
| // initial control values |
| m_aSimpleConversion.Check(); |
| |
| m_pPlayground->GetButton(SvxCommonLinguisticControl::eClose )->SetHelpId(HID_HANGULDLG_BUTTON_CLOSE ); |
| m_pPlayground->GetButton(SvxCommonLinguisticControl::eIgnore )->SetHelpId(HID_HANGULDLG_BUTTON_IGNORE ); |
| m_pPlayground->GetButton(SvxCommonLinguisticControl::eIgnoreAll )->SetHelpId(HID_HANGULDLG_BUTTON_IGNOREALL); |
| m_pPlayground->GetButton(SvxCommonLinguisticControl::eChange )->SetHelpId(HID_HANGULDLG_BUTTON_CHANGE ); |
| m_pPlayground->GetButton(SvxCommonLinguisticControl::eChangeAll )->SetHelpId(HID_HANGULDLG_BUTTON_CHANGEALL); |
| m_pPlayground->GetButton(SvxCommonLinguisticControl::eOptions )->SetHelpId(HID_HANGULDLG_BUTTON_OPTIONS ); |
| m_pPlayground->GetWordInputControl().SetHelpId(HID_HANGULDLG_EDIT_NEWWORD); |
| |
| FreeResource(); |
| |
| m_aSuggestions.SetHelpIds(); |
| } |
| |
| //------------------------------------------------------------------------- |
| HangulHanjaConversionDialog::~HangulHanjaConversionDialog( ) |
| { |
| } |
| |
| //------------------------------------------------------------------------- |
| void HangulHanjaConversionDialog::FillSuggestions( const ::com::sun::star::uno::Sequence< ::rtl::OUString >& _rSuggestions ) |
| { |
| m_aSuggestions.Clear(); |
| |
| const ::rtl::OUString* pSuggestions = _rSuggestions.getConstArray(); |
| const ::rtl::OUString* pSuggestionsEnd = _rSuggestions.getConstArray() + _rSuggestions.getLength(); |
| while ( pSuggestions != pSuggestionsEnd ) |
| m_aSuggestions.InsertEntry( *pSuggestions++ ); |
| |
| // select the first suggestion, and fill in the suggestion edit field |
| String sFirstSuggestion; |
| if ( m_aSuggestions.GetEntryCount() ) |
| { |
| sFirstSuggestion = m_aSuggestions.GetEntry( 0 ); |
| m_aSuggestions.SelectEntryPos( 0 ); |
| } |
| m_pPlayground->GetWordInputControl().SetText( sFirstSuggestion ); |
| m_pPlayground->GetWordInputControl().SaveValue(); |
| OnSuggestionModified( &m_pPlayground->GetWordInputControl() ); |
| } |
| |
| //------------------------------------------------------------------------- |
| void HangulHanjaConversionDialog::SetOptionsChangedHdl( const Link& _rHdl ) |
| { |
| m_aOptionsChangedLink = _rHdl; |
| } |
| |
| //------------------------------------------------------------------------- |
| void HangulHanjaConversionDialog::SetIgnoreHdl( const Link& _rHdl ) |
| { |
| m_pPlayground->SetButtonHandler( SvxCommonLinguisticControl::eIgnore, _rHdl ); |
| } |
| |
| //------------------------------------------------------------------------- |
| void HangulHanjaConversionDialog::SetIgnoreAllHdl( const Link& _rHdl ) |
| { |
| m_pPlayground->SetButtonHandler( SvxCommonLinguisticControl::eIgnoreAll, _rHdl ); |
| } |
| |
| //------------------------------------------------------------------------- |
| void HangulHanjaConversionDialog::SetChangeHdl( const Link& _rHdl ) |
| { |
| m_pPlayground->SetButtonHandler( SvxCommonLinguisticControl::eChange, _rHdl ); |
| } |
| |
| //------------------------------------------------------------------------- |
| void HangulHanjaConversionDialog::SetChangeAllHdl( const Link& _rHdl ) |
| { |
| m_pPlayground->SetButtonHandler( SvxCommonLinguisticControl::eChangeAll, _rHdl ); |
| } |
| |
| //------------------------------------------------------------------------- |
| void HangulHanjaConversionDialog::SetFindHdl( const Link& _rHdl ) |
| { |
| m_aFind.SetClickHdl( _rHdl ); |
| } |
| |
| //------------------------------------------------------------------------- |
| void HangulHanjaConversionDialog::SetConversionFormatChangedHdl( const Link& _rHdl ) |
| { |
| m_aSimpleConversion.SetClickHdl( _rHdl ); |
| m_aHangulBracketed.SetClickHdl( _rHdl ); |
| m_aHanjaBracketed.SetClickHdl( _rHdl ); |
| m_pHanjaAbove->SetClickHdl( _rHdl ); |
| m_pHanjaBelow->SetClickHdl( _rHdl ); |
| m_pHangulAbove->SetClickHdl( _rHdl ); |
| m_pHangulBelow->SetClickHdl( _rHdl ); |
| } |
| |
| //------------------------------------------------------------------------- |
| void HangulHanjaConversionDialog::SetClickByCharacterHdl( const Link& _rHdl ) |
| { |
| m_aClickByCharacterLink = _rHdl; |
| } |
| |
| //------------------------------------------------------------------------- |
| IMPL_LINK( HangulHanjaConversionDialog, OnSuggestionSelected, void*, EMPTYARG ) |
| { |
| m_pPlayground->GetWordInputControl().SetText( m_aSuggestions.GetSelectEntry() ); |
| OnSuggestionModified( NULL ); |
| return 0L; |
| } |
| |
| //------------------------------------------------------------------------- |
| IMPL_LINK( HangulHanjaConversionDialog, OnSuggestionModified, void*, EMPTYARG ) |
| { |
| m_aFind.Enable( m_pPlayground->GetWordInputControl().GetSavedValue() != m_pPlayground->GetWordInputControl().GetText() ); |
| |
| bool bSameLen = m_pPlayground->GetWordInputControl().GetText().Len() == m_pPlayground->GetCurrentText().Len(); |
| m_pPlayground->EnableButton( SvxCommonLinguisticControl::eChange, m_bDocumentMode && bSameLen ); |
| m_pPlayground->EnableButton( SvxCommonLinguisticControl::eChangeAll, m_bDocumentMode && bSameLen ); |
| |
| return 0L; |
| } |
| |
| //------------------------------------------------------------------------- |
| IMPL_LINK( HangulHanjaConversionDialog, ClickByCharacterHdl, CheckBox *, pBox ) |
| { |
| m_aClickByCharacterLink.Call(pBox); |
| |
| bool bByCharacter = pBox->IsChecked(); |
| m_aSuggestions.DisplayListBox( !bByCharacter ); |
| |
| return 0L; |
| } |
| |
| //------------------------------------------------------------------------- |
| IMPL_LINK( HangulHanjaConversionDialog, OnConversionDirectionClicked, CheckBox *, pBox ) |
| { |
| CheckBox *pOtherBox = 0; |
| if (pBox == &m_aHangulOnly) |
| pOtherBox = &m_aHanjaOnly; |
| else if (pBox == &m_aHanjaOnly) |
| pOtherBox = &m_aHangulOnly; |
| if (pBox && pOtherBox) |
| { |
| sal_Bool bBoxChecked = pBox->IsChecked(); |
| if (bBoxChecked) |
| pOtherBox->Check( sal_False ); |
| pOtherBox->Enable( !bBoxChecked ); |
| } |
| |
| return 0L; |
| } |
| |
| //------------------------------------------------------------------------- |
| IMPL_LINK( HangulHanjaConversionDialog, OnClose, void*, EMPTYARG ) |
| { |
| Close(); |
| return 0L; |
| } |
| |
| IMPL_LINK( HangulHanjaConversionDialog, OnOption, void*, EMPTYARG ) |
| { |
| HangulHanjaOptionsDialog aOptDlg( this ); |
| aOptDlg.Execute(); |
| m_aOptionsChangedLink.Call(this); |
| return 0L; |
| } |
| |
| //------------------------------------------------------------------------- |
| String HangulHanjaConversionDialog::GetCurrentString( ) const |
| { |
| return m_pPlayground->GetCurrentText( ); |
| } |
| |
| //------------------------------------------------------------------------- |
| void HangulHanjaConversionDialog::FocusSuggestion( ) |
| { |
| m_pPlayground->GetWordInputControl().GrabFocus(); |
| } |
| |
| //------------------------------------------------------------------------- |
| namespace |
| { |
| void lcl_modifyWindowStyle( Window* _pWin, WinBits _nSet, WinBits _nReset ) |
| { |
| DBG_ASSERT( 0 == ( _nSet & _nReset ), "lcl_modifyWindowStyle: set _and_ reset the same bit?" ); |
| if ( _pWin ) |
| _pWin->SetStyle( ( _pWin->GetStyle() | _nSet ) & ~_nReset ); |
| } |
| } |
| |
| //------------------------------------------------------------------------- |
| void HangulHanjaConversionDialog::SetCurrentString( const String& _rNewString, |
| const Sequence< ::rtl::OUString >& _rSuggestions, bool _bOriginatesFromDocument ) |
| { |
| m_pPlayground->SetCurrentText( _rNewString ); |
| |
| bool bOldDocumentMode = m_bDocumentMode; |
| m_bDocumentMode = _bOriginatesFromDocument; // before FillSuggestions! |
| FillSuggestions( _rSuggestions ); |
| |
| m_pPlayground->EnableButton( SvxCommonLinguisticControl::eIgnoreAll, m_bDocumentMode ); |
| // all other buttons have been implicitly enabled or disabled during filling in the suggestions |
| |
| // switch the def button depending if we're working for document text |
| if ( bOldDocumentMode != m_bDocumentMode ) |
| { |
| Window* pOldDefButton = NULL; |
| Window* pNewDefButton = NULL; |
| if ( m_bDocumentMode ) |
| { |
| pOldDefButton = &m_aFind; |
| pNewDefButton = m_pPlayground->GetButton( SvxCommonLinguisticControl::eChange ); |
| } |
| else |
| { |
| pOldDefButton = m_pPlayground->GetButton( SvxCommonLinguisticControl::eChange ); |
| pNewDefButton = &m_aFind; |
| } |
| |
| DBG_ASSERT( WB_DEFBUTTON == ( pOldDefButton->GetStyle( ) & WB_DEFBUTTON ), |
| "HangulHanjaConversionDialog::SetCurrentString: wrong previous default button (1)!" ); |
| DBG_ASSERT( 0 == ( pNewDefButton->GetStyle( ) & WB_DEFBUTTON ), |
| "HangulHanjaConversionDialog::SetCurrentString: wrong previous default button (2)!" ); |
| |
| lcl_modifyWindowStyle( pOldDefButton, 0, WB_DEFBUTTON ); |
| lcl_modifyWindowStyle( pNewDefButton, WB_DEFBUTTON, 0 ); |
| |
| // give the focus to the new def button temporarily - VCL is somewhat peculiar |
| // in recognizing a new default button |
| sal_uInt32 nSaveFocusId = Window::SaveFocus(); |
| pNewDefButton->GrabFocus(); |
| Window::EndSaveFocus( nSaveFocusId ); |
| } |
| } |
| |
| //------------------------------------------------------------------------- |
| String HangulHanjaConversionDialog::GetCurrentSuggestion( ) const |
| { |
| return m_pPlayground->GetWordInputControl().GetText(); |
| } |
| |
| //------------------------------------------------------------------------- |
| void HangulHanjaConversionDialog::SetByCharacter( sal_Bool _bByCharacter ) |
| { |
| m_aReplaceByChar.Check( _bByCharacter ); |
| m_aSuggestions.DisplayListBox( !_bByCharacter ); |
| } |
| |
| //------------------------------------------------------------------------- |
| void HangulHanjaConversionDialog::SetConversionDirectionState( |
| sal_Bool _bTryBothDirections, |
| HHC::ConversionDirection _ePrimaryConversionDirection ) |
| { |
| // default state: try both direction |
| m_aHangulOnly.Check( sal_False ); |
| m_aHangulOnly.Enable( sal_True ); |
| m_aHanjaOnly.Check( sal_False ); |
| m_aHanjaOnly.Enable( sal_True ); |
| |
| if (!_bTryBothDirections) |
| { |
| CheckBox *pBox = _ePrimaryConversionDirection == HHC::eHangulToHanja? |
| &m_aHangulOnly : &m_aHanjaOnly; |
| pBox->Check( sal_True ); |
| OnConversionDirectionClicked( pBox ); |
| } |
| } |
| |
| //------------------------------------------------------------------------- |
| sal_Bool HangulHanjaConversionDialog::GetUseBothDirections( ) const |
| { |
| // DBG_ASSERT( m_pIgnoreNonPrimary, "HangulHanjaConversionDialog::GetUseBothDirections: where's the check box pointer?" ); |
| // return m_pIgnoreNonPrimary ? !m_pIgnoreNonPrimary->IsChecked( ) : sal_True; |
| return !m_aHangulOnly.IsChecked() && !m_aHanjaOnly.IsChecked(); |
| } |
| |
| //------------------------------------------------------------------------- |
| HHC::ConversionDirection HangulHanjaConversionDialog::GetDirection( |
| HHC::ConversionDirection eDefaultDirection ) const |
| { |
| HHC::ConversionDirection eDirection = eDefaultDirection; |
| if (m_aHangulOnly.IsChecked() && !m_aHanjaOnly.IsChecked()) |
| eDirection = HHC::eHangulToHanja; |
| else if (!m_aHangulOnly.IsChecked() && m_aHanjaOnly.IsChecked()) |
| eDirection = HHC::eHanjaToHangul; |
| return eDirection; |
| } |
| |
| //------------------------------------------------------------------------- |
| void HangulHanjaConversionDialog::SetConversionFormat( HHC::ConversionFormat _eType ) |
| { |
| switch ( _eType ) |
| { |
| case HHC::eSimpleConversion: m_aSimpleConversion.Check(); break; |
| case HHC::eHangulBracketed: m_aHangulBracketed.Check(); break; |
| case HHC::eHanjaBracketed: m_aHanjaBracketed.Check(); break; |
| case HHC::eRubyHanjaAbove: m_pHanjaAbove->Check(); break; |
| case HHC::eRubyHanjaBelow: m_pHanjaBelow->Check(); break; |
| case HHC::eRubyHangulAbove: m_pHangulAbove->Check(); break; |
| case HHC::eRubyHangulBelow: m_pHangulBelow->Check(); break; |
| default: |
| DBG_ERROR( "HangulHanjaConversionDialog::SetConversionFormat: unknown type!" ); |
| } |
| } |
| |
| //------------------------------------------------------------------------- |
| HHC::ConversionFormat HangulHanjaConversionDialog::GetConversionFormat( ) const |
| { |
| if ( m_aSimpleConversion.IsChecked() ) |
| return HHC::eSimpleConversion; |
| if ( m_aHangulBracketed.IsChecked() ) |
| return HHC::eHangulBracketed; |
| if ( m_aHanjaBracketed.IsChecked() ) |
| return HHC::eHanjaBracketed; |
| if ( m_pHanjaAbove->IsChecked() ) |
| return HHC::eRubyHanjaAbove; |
| if ( m_pHanjaBelow->IsChecked() ) |
| return HHC::eRubyHanjaBelow; |
| if ( m_pHangulAbove->IsChecked() ) |
| return HHC::eRubyHangulAbove; |
| if ( m_pHangulBelow->IsChecked() ) |
| return HHC::eRubyHangulBelow; |
| |
| DBG_ERROR( "HangulHanjaConversionDialog::GetConversionFormat: no radio checked?" ); |
| return HHC::eSimpleConversion; |
| } |
| |
| //------------------------------------------------------------------------- |
| void HangulHanjaConversionDialog::EnableRubySupport( sal_Bool bVal ) |
| { |
| m_pHanjaAbove->Enable( bVal ); |
| m_pHanjaBelow->Enable( bVal ); |
| m_pHangulAbove->Enable( bVal ); |
| m_pHangulBelow->Enable( bVal ); |
| } |
| |
| |
| //========================================================================= |
| //= HangulHanjaOptionsDialog |
| //========================================================================= |
| //------------------------------------------------------------------------- |
| |
| void HangulHanjaOptionsDialog::Init( void ) |
| { |
| if( !m_xConversionDictionaryList.is() ) |
| { |
| Reference< XMultiServiceFactory > xMgr( ::comphelper::getProcessServiceFactory() ); |
| if( xMgr.is() ) |
| { |
| m_xConversionDictionaryList = Reference< XConversionDictionaryList >( xMgr->createInstance( |
| OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.linguistic2.ConversionDictionaryList")) ), |
| UNO_QUERY ); |
| } |
| } |
| |
| m_aDictList.clear(); |
| m_aDictsLB.Clear(); |
| |
| if( m_xConversionDictionaryList.is() ) |
| { |
| Reference< XNameContainer > xNameCont = m_xConversionDictionaryList->getDictionaryContainer(); |
| Reference< XNameAccess > xNameAccess = Reference< XNameAccess >( xNameCont, UNO_QUERY ); |
| if( xNameAccess.is() ) |
| { |
| Sequence< ::rtl::OUString > aDictNames( xNameAccess->getElementNames() ); |
| |
| const ::rtl::OUString* pDic = aDictNames.getConstArray(); |
| sal_Int32 nCount = aDictNames.getLength(); |
| |
| sal_Int32 i; |
| for( i = 0 ; i < nCount ; ++i ) |
| { |
| Any aAny( xNameAccess->getByName( pDic[ i ] ) ); |
| Reference< XConversionDictionary > xDic; |
| if( ( aAny >>= xDic ) && xDic.is() ) |
| { |
| if( LANGUAGE_KOREAN == SvxLocaleToLanguage( xDic->getLocale() ) ) |
| { |
| m_aDictList.push_back( xDic ); |
| AddDict( xDic->getName(), xDic->isActive() ); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| IMPL_LINK( HangulHanjaOptionsDialog, OkHdl, void*, EMPTYARG ) |
| { |
| sal_uInt32 nCnt = m_aDictList.size(); |
| sal_uInt32 n = 0; |
| sal_uInt32 nActiveDics = 0; |
| Sequence< OUString > aActiveDics; |
| |
| aActiveDics.realloc( nCnt ); |
| OUString* pActActiveDic = aActiveDics.getArray(); |
| |
| while( nCnt ) |
| { |
| Reference< XConversionDictionary > xDict = m_aDictList[ n ]; |
| SvLBoxEntry* pEntry = m_aDictsLB.SvTreeListBox::GetEntry( n ); |
| |
| DBG_ASSERT( xDict.is(), "-HangulHanjaOptionsDialog::OkHdl(): someone is evaporated..." ); |
| DBG_ASSERT( pEntry, "-HangulHanjaOptionsDialog::OkHdl(): no one there in list?" ); |
| |
| bool bActive = m_aDictsLB.GetCheckButtonState( pEntry ) == SV_BUTTON_CHECKED; |
| xDict->setActive( bActive ); |
| Reference< util::XFlushable > xFlush( xDict, uno::UNO_QUERY ); |
| if( xFlush.is() ) |
| xFlush->flush(); |
| |
| if( bActive ) |
| { |
| pActActiveDic[ nActiveDics ] = xDict->getName(); |
| ++nActiveDics; |
| } |
| |
| ++n; |
| --nCnt; |
| } |
| |
| // save configuration |
| aActiveDics.realloc( nActiveDics ); |
| Any aTmp; |
| SvtLinguConfig aLngCfg; |
| aTmp <<= aActiveDics; |
| aLngCfg.SetProperty( UPH_ACTIVE_CONVERSION_DICTIONARIES, aTmp ); |
| |
| aTmp <<= bool( m_aIgnorepostCB.IsChecked() ); |
| aLngCfg.SetProperty( UPH_IS_IGNORE_POST_POSITIONAL_WORD, aTmp ); |
| |
| aTmp <<= bool( m_aShowrecentlyfirstCB.IsChecked() ); |
| aLngCfg.SetProperty( UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST, aTmp ); |
| |
| aTmp <<= bool( m_aAutoreplaceuniqueCB.IsChecked() ); |
| aLngCfg.SetProperty( UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES, aTmp ); |
| |
| EndDialog( RET_OK ); |
| return 0; |
| } |
| |
| IMPL_LINK( HangulHanjaOptionsDialog, DictsLB_SelectHdl, void*, EMPTYARG ) |
| { |
| bool bSel = m_aDictsLB.FirstSelected() != NULL; |
| |
| m_aEditPB.Enable( bSel ); |
| m_aDeletePB.Enable( bSel ); |
| |
| return 0; |
| } |
| |
| IMPL_LINK( HangulHanjaOptionsDialog, NewDictHdl, void*, EMPTYARG ) |
| { |
| String aName; |
| HangulHanjaNewDictDialog aNewDlg( this ); |
| aNewDlg.Execute(); |
| if( aNewDlg.GetName( aName ) ) |
| { |
| if( m_xConversionDictionaryList.is() ) |
| { |
| try |
| { |
| Reference< XConversionDictionary > xDic = |
| m_xConversionDictionaryList->addNewDictionary( aName, SvxCreateLocale( LANGUAGE_KOREAN ), ConversionDictionaryType::HANGUL_HANJA ); |
| |
| if( xDic.is() ) |
| { |
| //adapt local caches: |
| m_aDictList.push_back( xDic ); |
| AddDict( xDic->getName(), xDic->isActive() ); |
| } |
| } |
| catch( const ElementExistException& ) |
| { |
| } |
| catch( const NoSupportException& ) |
| { |
| } |
| } |
| } |
| |
| return 0L; |
| } |
| |
| IMPL_LINK( HangulHanjaOptionsDialog, EditDictHdl, void*, EMPTYARG ) |
| { |
| SvLBoxEntry* pEntry = m_aDictsLB.FirstSelected(); |
| DBG_ASSERT( pEntry, "+HangulHanjaEditDictDialog::EditDictHdl(): call of edit should not be possible with no selection!" ); |
| if( pEntry ) |
| { |
| HangulHanjaEditDictDialog aEdDlg( this, m_aDictList, m_aDictsLB.GetSelectEntryPos() ); |
| aEdDlg.Execute(); |
| } |
| return 0L; |
| } |
| |
| IMPL_LINK( HangulHanjaOptionsDialog, DeleteDictHdl, void*, EMPTYARG ) |
| { |
| sal_uInt16 nSelPos = m_aDictsLB.GetSelectEntryPos(); |
| if( nSelPos != LISTBOX_ENTRY_NOTFOUND ) |
| { |
| Reference< XConversionDictionary > xDic( m_aDictList[ nSelPos ] ); |
| if( m_xConversionDictionaryList.is() && xDic.is() ) |
| { |
| Reference< XNameContainer > xNameCont = m_xConversionDictionaryList->getDictionaryContainer(); |
| if( xNameCont.is() ) |
| { |
| try |
| { |
| xNameCont->removeByName( xDic->getName() ); |
| |
| //adapt local caches: |
| HHDictList::iterator aIter(m_aDictList.begin()); |
| m_aDictList.erase(aIter+nSelPos ); |
| m_aDictsLB.RemoveEntry( nSelPos ); |
| } |
| catch( const ElementExistException& ) |
| { |
| } |
| catch( const NoSupportException& ) |
| { |
| } |
| } |
| } |
| } |
| |
| return 0L; |
| } |
| |
| HangulHanjaOptionsDialog::HangulHanjaOptionsDialog( Window* _pParent ) |
| :ModalDialog ( _pParent, CUI_RES( RID_SVX_MDLG_HANGULHANJA_OPT ) ) |
| ,m_aUserdefdictFT ( this, CUI_RES( FT_USERDEFDICT ) ) |
| ,m_aDictsLB ( this, CUI_RES( LB_DICTS ) ) |
| ,m_aOptionsFL ( this, CUI_RES( FL_OPTIONS ) ) |
| ,m_aIgnorepostCB ( this, CUI_RES( CB_IGNOREPOST ) ) |
| ,m_aShowrecentlyfirstCB ( this, CUI_RES( CB_SHOWRECENTLYFIRST ) ) |
| ,m_aAutoreplaceuniqueCB ( this, CUI_RES( CB_AUTOREPLACEUNIQUE ) ) |
| ,m_aNewPB ( this, CUI_RES( PB_HHO_NEW ) ) |
| ,m_aEditPB ( this, CUI_RES( PB_HHO_EDIT ) ) |
| ,m_aDeletePB ( this, CUI_RES( PB_HHO_DELETE ) ) |
| ,m_aOkPB ( this, CUI_RES( PB_HHO_OK ) ) |
| ,m_aCancelPB ( this, CUI_RES( PB_HHO_CANCEL ) ) |
| ,m_aHelpPB ( this, CUI_RES( PB_HHO_HELP ) ) |
| |
| ,m_pCheckButtonData ( NULL ) |
| ,m_xConversionDictionaryList( NULL ) |
| { |
| m_aDictsLB.SetStyle( m_aDictsLB.GetStyle() | WB_CLIPCHILDREN | WB_HSCROLL | WB_FORCE_MAKEVISIBLE ); |
| m_aDictsLB.SetSelectionMode( SINGLE_SELECTION ); |
| m_aDictsLB.SetHighlightRange(); |
| // m_aDictsLB.SetHelpId( xxx ); |
| m_aDictsLB.SetSelectHdl( LINK( this, HangulHanjaOptionsDialog, DictsLB_SelectHdl ) ); |
| m_aDictsLB.SetDeselectHdl( LINK( this, HangulHanjaOptionsDialog, DictsLB_SelectHdl ) ); |
| |
| m_aOkPB.SetClickHdl( LINK( this, HangulHanjaOptionsDialog, OkHdl ) ); |
| m_aNewPB.SetClickHdl( LINK( this, HangulHanjaOptionsDialog, NewDictHdl ) ); |
| m_aEditPB.SetClickHdl( LINK( this, HangulHanjaOptionsDialog, EditDictHdl ) ); |
| m_aDeletePB.SetClickHdl( LINK( this, HangulHanjaOptionsDialog, DeleteDictHdl ) ); |
| |
| FreeResource(); |
| |
| SvtLinguConfig aLngCfg; |
| Any aTmp; |
| bool bVal = bool(); |
| aTmp = aLngCfg.GetProperty( UPH_IS_IGNORE_POST_POSITIONAL_WORD ); |
| if( aTmp >>= bVal ) |
| m_aIgnorepostCB.Check( bVal ); |
| |
| aTmp = aLngCfg.GetProperty( UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST ); |
| if( aTmp >>= bVal ) |
| m_aShowrecentlyfirstCB.Check( bVal ); |
| |
| aTmp = aLngCfg.GetProperty( UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES ); |
| if( aTmp >>= bVal ) |
| m_aAutoreplaceuniqueCB.Check( bVal ); |
| |
| Init(); |
| } |
| |
| HangulHanjaOptionsDialog::~HangulHanjaOptionsDialog() |
| { |
| SvLBoxEntry* pEntry = m_aDictsLB.First(); |
| String* pDel; |
| while( pEntry ) |
| { |
| pDel = ( String* ) pEntry->GetUserData(); |
| if( pDel ) |
| delete pDel; |
| pEntry = m_aDictsLB.Next( pEntry ); |
| } |
| |
| if( m_pCheckButtonData ) |
| delete m_pCheckButtonData; |
| } |
| |
| void HangulHanjaOptionsDialog::AddDict( const String& _rName, bool _bChecked ) |
| { |
| SvLBoxEntry* pEntry = m_aDictsLB.SvTreeListBox::InsertEntry( _rName ); |
| m_aDictsLB.SetCheckButtonState( pEntry, _bChecked? SV_BUTTON_CHECKED : SV_BUTTON_UNCHECKED ); |
| pEntry->SetUserData( new String( _rName ) ); |
| } |
| |
| //========================================================================= |
| //= HangulHanjaNewDictDialog |
| //========================================================================= |
| //------------------------------------------------------------------------- |
| |
| IMPL_LINK( HangulHanjaNewDictDialog, OKHdl, void*, EMPTYARG ) |
| { |
| String aName( m_aDictNameED.GetText() ); |
| |
| aName.EraseTrailingChars(); |
| m_bEntered = aName.Len() > 0; |
| if( m_bEntered ) |
| m_aDictNameED.SetText( aName ); // do this in case of trailing chars have been deleted |
| |
| EndDialog( RET_OK ); |
| return 0; |
| } |
| |
| IMPL_LINK( HangulHanjaNewDictDialog, ModifyHdl, void*, EMPTYARG ) |
| { |
| String aName( m_aDictNameED.GetText() ); |
| |
| aName.EraseTrailingChars(); |
| m_aOkBtn.Enable( aName.Len() > 0 ); |
| |
| return 0; |
| } |
| |
| HangulHanjaNewDictDialog::HangulHanjaNewDictDialog( Window* _pParent ) |
| :ModalDialog ( _pParent, CUI_RES( RID_SVX_MDLG_HANGULHANJA_NEWDICT ) ) |
| ,m_aNewDictFL ( this, CUI_RES( FL_NEWDICT ) ) |
| ,m_aDictNameFT ( this, CUI_RES( FT_DICTNAME ) ) |
| ,m_aDictNameED ( this, CUI_RES( ED_DICTNAME ) ) |
| ,m_aOkBtn ( this, CUI_RES( PB_NEWDICT_OK ) ) |
| ,m_aCancelBtn ( this, CUI_RES( PB_NEWDICT_ESC ) ) |
| ,m_aHelpBtn ( this, CUI_RES( PB_NEWDICT_HLP ) ) |
| |
| ,m_bEntered ( false ) |
| { |
| m_aOkBtn.SetClickHdl( LINK( this, HangulHanjaNewDictDialog, OKHdl ) ); |
| |
| m_aDictNameED.SetModifyHdl( LINK( this, HangulHanjaNewDictDialog, ModifyHdl ) ); |
| |
| FreeResource(); |
| } |
| |
| HangulHanjaNewDictDialog::~HangulHanjaNewDictDialog() |
| { |
| } |
| |
| bool HangulHanjaNewDictDialog::GetName( String& _rRetName ) const |
| { |
| if( m_bEntered ) |
| { |
| _rRetName = m_aDictNameED.GetText(); |
| _rRetName.EraseTrailingChars(); |
| } |
| |
| return m_bEntered; |
| } |
| |
| //========================================================================= |
| //= HangulHanjaEditDictDialog |
| //========================================================================= |
| //------------------------------------------------------------------------- |
| |
| class SuggestionList |
| { |
| private: |
| protected: |
| sal_uInt16 m_nSize; |
| String** m_ppElements; |
| sal_uInt16 m_nNumOfEntries; |
| sal_uInt16 m_nAct; |
| |
| const String* _Next( void ); |
| public: |
| SuggestionList( sal_uInt16 _nNumOfElements ); |
| virtual ~SuggestionList(); |
| |
| bool Set( const String& _rElement, sal_uInt16 _nNumOfElement ); |
| bool Reset( sal_uInt16 _nNumOfElement ); |
| const String* Get( sal_uInt16 _nNumOfElement ) const; |
| void Clear( void ); |
| |
| const String* First( void ); |
| const String* Next( void ); |
| |
| inline sal_uInt16 GetCount( void ) const; |
| }; |
| |
| inline sal_uInt16 SuggestionList::GetCount( void ) const |
| { |
| return m_nNumOfEntries; |
| } |
| |
| SuggestionList::SuggestionList( sal_uInt16 _nNumOfElements ) |
| { |
| if( !_nNumOfElements ) |
| _nNumOfElements = 1; |
| |
| m_nSize = _nNumOfElements; |
| |
| m_ppElements = new String*[ m_nSize ]; |
| m_nAct = m_nNumOfEntries = 0; |
| |
| String** ppNull = m_ppElements; |
| sal_uInt16 n = _nNumOfElements; |
| while( n ) |
| { |
| *ppNull = NULL; |
| ++ppNull; |
| --n; |
| } |
| } |
| |
| SuggestionList::~SuggestionList() |
| { |
| Clear(); |
| } |
| |
| bool SuggestionList::Set( const String& _rElement, sal_uInt16 _nNumOfElement ) |
| { |
| bool bRet = _nNumOfElement < m_nSize; |
| if( bRet ) |
| { |
| String** ppElem = m_ppElements + _nNumOfElement; |
| if( *ppElem ) |
| **ppElem = _rElement; |
| else |
| { |
| *ppElem = new String( _rElement ); |
| ++m_nNumOfEntries; |
| } |
| } |
| |
| return bRet; |
| } |
| |
| bool SuggestionList::Reset( sal_uInt16 _nNumOfElement ) |
| { |
| bool bRet = _nNumOfElement < m_nSize; |
| if( bRet ) |
| { |
| String** ppElem = m_ppElements + _nNumOfElement; |
| if( *ppElem ) |
| { |
| delete *ppElem; |
| *ppElem = NULL; |
| --m_nNumOfEntries; |
| } |
| } |
| |
| return bRet; |
| } |
| |
| const String* SuggestionList::Get( sal_uInt16 _nNumOfElement ) const |
| { |
| const String* pRet; |
| |
| if( _nNumOfElement < m_nSize ) |
| pRet = m_ppElements[ _nNumOfElement ]; |
| else |
| pRet = NULL; |
| |
| return pRet; |
| } |
| |
| void SuggestionList::Clear( void ) |
| { |
| if( m_nNumOfEntries ) |
| { |
| String** ppDel = m_ppElements; |
| sal_uInt16 nCnt = m_nSize; |
| while( nCnt ) |
| { |
| if( *ppDel ) |
| { |
| delete *ppDel; |
| *ppDel = NULL; |
| } |
| |
| ++ppDel; |
| --nCnt; |
| } |
| |
| m_nNumOfEntries = m_nAct = 0; |
| } |
| } |
| |
| const String* SuggestionList::_Next( void ) |
| { |
| const String* pRet = NULL; |
| while( m_nAct < m_nSize && !pRet ) |
| { |
| pRet = m_ppElements[ m_nAct ]; |
| if( !pRet ) |
| ++m_nAct; |
| } |
| |
| return pRet; |
| } |
| |
| const String* SuggestionList::First( void ) |
| { |
| m_nAct = 0; |
| return _Next(); |
| } |
| |
| const String* SuggestionList::Next( void ) |
| { |
| const String* pRet; |
| |
| if( m_nAct < m_nNumOfEntries ) |
| { |
| ++m_nAct; |
| pRet = _Next(); |
| } |
| else |
| pRet = NULL; |
| |
| return pRet; |
| } |
| |
| |
| bool SuggestionEdit::ShouldScroll( bool _bUp ) const |
| { |
| bool bRet = false; |
| |
| if( _bUp ) |
| { |
| if( !m_pPrev ) |
| bRet = m_rScrollBar.GetThumbPos() > m_rScrollBar.GetRangeMin(); |
| } |
| else |
| { |
| if( !m_pNext ) |
| bRet = m_rScrollBar.GetThumbPos() < ( m_rScrollBar.GetRangeMax() - 4 ); |
| } |
| |
| return bRet; |
| } |
| |
| void SuggestionEdit::DoJump( bool _bUp ) |
| { |
| const Link& rLoseFocusHdl = GetLoseFocusHdl(); |
| if( rLoseFocusHdl.IsSet() ) |
| rLoseFocusHdl.Call( this ); |
| m_rScrollBar.SetThumbPos( m_rScrollBar.GetThumbPos() + ( _bUp? -1 : 1 ) ); |
| |
| ( static_cast< HangulHanjaEditDictDialog* >( GetParent() ) )->UpdateScrollbar(); |
| } |
| |
| SuggestionEdit::SuggestionEdit( Window* pParent, const ResId& rResId, |
| ScrollBar& _rScrollBar, SuggestionEdit* _pPrev, SuggestionEdit* _pNext ) |
| :Edit( pParent, rResId ) |
| ,m_pPrev( _pPrev ) |
| ,m_pNext( _pNext ) |
| ,m_rScrollBar( _rScrollBar ) |
| { |
| } |
| |
| SuggestionEdit::~SuggestionEdit() |
| { |
| } |
| |
| long SuggestionEdit::PreNotify( NotifyEvent& rNEvt ) |
| { |
| long nHandled = 0; |
| if( rNEvt.GetType() == EVENT_KEYINPUT ) |
| { |
| const KeyEvent* pKEvt = rNEvt.GetKeyEvent(); |
| const KeyCode& rKeyCode = pKEvt->GetKeyCode(); |
| sal_uInt16 nMod = rKeyCode.GetModifier(); |
| sal_uInt16 nCode = rKeyCode.GetCode(); |
| if( nCode == KEY_TAB && ( !nMod || KEY_SHIFT == nMod ) ) |
| { |
| bool bUp = KEY_SHIFT == nMod; |
| if( ShouldScroll( bUp ) ) |
| { |
| DoJump( bUp ); |
| SetSelection( Selection( 0, SELECTION_MAX ) ); |
| // Tab-travel doesn't really happen, so emulate it by setting a selection manually |
| nHandled = 1; |
| } |
| } |
| else if( KEY_UP == nCode || KEY_DOWN == nCode ) |
| { |
| bool bUp = KEY_UP == nCode; |
| if( ShouldScroll( bUp ) ) |
| { |
| DoJump( bUp ); |
| nHandled = 1; |
| } |
| else if( bUp ) |
| { |
| if( m_pPrev ) |
| { |
| m_pPrev->GrabFocus(); |
| nHandled = 1; |
| } |
| } |
| else if( m_pNext ) |
| { |
| m_pNext->GrabFocus(); |
| nHandled = 1; |
| } |
| } |
| } |
| |
| if( !nHandled ) |
| nHandled = Edit::PreNotify( rNEvt ); |
| return nHandled; |
| } |
| |
| |
| namespace |
| { |
| bool GetConversions( Reference< XConversionDictionary > _xDict, |
| const OUString& _rOrg, |
| Sequence< OUString >& _rEntries ) |
| { |
| bool bRet = false; |
| if( _xDict.is() && _rOrg.getLength() ) |
| { |
| try |
| { |
| _rEntries = _xDict->getConversions( _rOrg, |
| 0, |
| _rOrg.getLength(), |
| ConversionDirection_FROM_LEFT, |
| ::com::sun::star::i18n::TextConversionOption::NONE ); |
| bRet = _rEntries.getLength() > 0; |
| } |
| catch( const IllegalArgumentException& ) |
| { |
| } |
| } |
| |
| return bRet; |
| } |
| } |
| |
| |
| IMPL_LINK( HangulHanjaEditDictDialog, ScrollHdl, void*, EMPTYARG ) |
| { |
| UpdateScrollbar(); |
| |
| return 0; |
| } |
| |
| IMPL_LINK( HangulHanjaEditDictDialog, OriginalModifyHdl, void*, EMPTYARG ) |
| { |
| m_bModifiedOriginal = true; |
| m_aOriginal = m_aOriginalLB.GetText(); |
| m_aOriginal.EraseTrailingChars(); |
| |
| UpdateSuggestions(); |
| UpdateButtonStates(); |
| |
| return 0; |
| } |
| |
| IMPL_LINK( HangulHanjaEditDictDialog, EditModifyHdl1, Edit*, pEdit ) |
| { |
| EditModify( pEdit, 0 ); |
| return 0; |
| } |
| |
| IMPL_LINK( HangulHanjaEditDictDialog, EditModifyHdl2, Edit*, pEdit ) |
| { |
| EditModify( pEdit, 1 ); |
| return 0; |
| } |
| |
| IMPL_LINK( HangulHanjaEditDictDialog, EditModifyHdl3, Edit*, pEdit ) |
| { |
| EditModify( pEdit, 2 ); |
| return 0; |
| } |
| |
| IMPL_LINK( HangulHanjaEditDictDialog, EditModifyHdl4, Edit*, pEdit ) |
| { |
| EditModify( pEdit, 3 ); |
| return 0; |
| } |
| |
| IMPL_LINK( HangulHanjaEditDictDialog, BookLBSelectHdl, void*, EMPTYARG ) |
| { |
| InitEditDictDialog( m_aBookLB.GetSelectEntryPos() ); |
| return 0; |
| } |
| |
| IMPL_LINK( HangulHanjaEditDictDialog, NewPBPushHdl, void*, EMPTYARG ) |
| { |
| DBG_ASSERT( m_pSuggestions, "-HangulHanjaEditDictDialog::NewPBPushHdl(): no suggestions... search in hell..." ); |
| Reference< XConversionDictionary > xDict = m_rDictList[ m_nCurrentDict ]; |
| if( xDict.is() && m_pSuggestions ) |
| { |
| //delete old entry |
| bool bRemovedSomething = DeleteEntryFromDictionary( m_aOriginal, xDict ); |
| |
| OUString aLeft( m_aOriginal ); |
| const String* pRight = m_pSuggestions->First(); |
| bool bAddedSomething = false; |
| while( pRight ) |
| { |
| try |
| { |
| //add new entry |
| xDict->addEntry( aLeft, *pRight ); |
| bAddedSomething = true; |
| } |
| catch( const IllegalArgumentException& ) |
| { |
| } |
| catch( const ElementExistException& ) |
| { |
| } |
| |
| pRight = m_pSuggestions->Next(); |
| } |
| |
| if(bAddedSomething||bRemovedSomething) |
| InitEditDictDialog( m_nCurrentDict ); |
| } |
| else |
| { |
| DBG_WARNING( "+HangulHanjaEditDictDialog::NewPBPushHdl(): dictionary faded away..." ); |
| } |
| return 0; |
| } |
| |
| bool HangulHanjaEditDictDialog::DeleteEntryFromDictionary( const OUString&, const Reference< XConversionDictionary >& xDict ) |
| { |
| bool bRemovedSomething = false; |
| if( xDict.is() ) |
| { |
| OUString aOrg( m_aOriginal ); |
| Sequence< OUString > aEntries; |
| GetConversions( xDict, m_aOriginal, aEntries ); |
| |
| sal_uInt32 n = aEntries.getLength(); |
| OUString* pEntry = aEntries.getArray(); |
| while( n ) |
| { |
| try |
| { |
| xDict->removeEntry( aOrg, *pEntry ); |
| bRemovedSomething = true; |
| } |
| catch( const NoSuchElementException& ) |
| { // can not be... |
| } |
| |
| ++pEntry; |
| --n; |
| } |
| } |
| return bRemovedSomething; |
| } |
| |
| IMPL_LINK( HangulHanjaEditDictDialog, DeletePBPushHdl, void*, EMPTYARG ) |
| { |
| if( DeleteEntryFromDictionary( m_aOriginal, m_rDictList[ m_nCurrentDict ] ) ) |
| { |
| m_aOriginal.Erase(); |
| m_bModifiedOriginal = true; |
| InitEditDictDialog( m_nCurrentDict ); |
| } |
| return 0; |
| } |
| |
| void HangulHanjaEditDictDialog::InitEditDictDialog( sal_uInt32 _nSelDict ) |
| { |
| if( m_pSuggestions ) |
| m_pSuggestions->Clear(); |
| |
| if( m_nCurrentDict != _nSelDict ) |
| { |
| m_nCurrentDict = _nSelDict; |
| m_aOriginal.Erase(); |
| m_bModifiedOriginal = true; |
| } |
| |
| UpdateOriginalLB(); |
| |
| m_aOriginalLB.SetText( m_aOriginal.Len()? m_aOriginal : m_aEditHintText, Selection( 0, SELECTION_MAX ) ); |
| m_aOriginalLB.GrabFocus(); |
| |
| UpdateSuggestions(); |
| UpdateButtonStates(); |
| } |
| |
| void HangulHanjaEditDictDialog::UpdateOriginalLB( void ) |
| { |
| m_aOriginalLB.Clear(); |
| Reference< XConversionDictionary > xDict = m_rDictList[ m_nCurrentDict ]; |
| if( xDict.is() ) |
| { |
| Sequence< OUString > aEntries = xDict->getConversionEntries( ConversionDirection_FROM_LEFT ); |
| sal_uInt32 n = aEntries.getLength(); |
| OUString* pEntry = aEntries.getArray(); |
| while( n ) |
| { |
| m_aOriginalLB.InsertEntry( *pEntry ); |
| |
| ++pEntry; |
| --n; |
| } |
| } |
| else |
| { |
| DBG_WARNING( "+HangulHanjaEditDictDialog::UpdateOriginalLB(): dictionary faded away..." ); |
| } |
| } |
| |
| void HangulHanjaEditDictDialog::UpdateButtonStates() |
| { |
| bool bHaveValidOriginalString = m_aOriginal.Len() && m_aOriginal != m_aEditHintText; |
| bool bNew = bHaveValidOriginalString && m_pSuggestions && m_pSuggestions->GetCount() > 0; |
| bNew = bNew && (m_bModifiedSuggestions || m_bModifiedOriginal); |
| |
| m_aNewPB.Enable( bNew ); |
| m_aDeletePB.Enable( !m_bModifiedOriginal && bHaveValidOriginalString ); |
| } |
| |
| void HangulHanjaEditDictDialog::UpdateSuggestions( void ) |
| { |
| Sequence< OUString > aEntries; |
| bool bFound = GetConversions( m_rDictList[ m_nCurrentDict ], m_aOriginal, aEntries ); |
| if( bFound ) |
| { |
| m_bModifiedOriginal = false; |
| |
| if( m_pSuggestions ) |
| m_pSuggestions->Clear(); |
| |
| //fill found entries into boxes |
| sal_uInt32 nCnt = aEntries.getLength(); |
| sal_uInt32 n = 0; |
| if( nCnt ) |
| { |
| if( !m_pSuggestions ) |
| m_pSuggestions = new SuggestionList( MAXNUM_SUGGESTIONS ); |
| |
| const OUString* pSugg = aEntries.getConstArray(); |
| while( nCnt ) |
| { |
| m_pSuggestions->Set( pSugg[ n ], sal_uInt16( n ) ); |
| ++n; |
| --nCnt; |
| } |
| } |
| m_bModifiedSuggestions=false; |
| } |
| |
| m_aScrollSB.SetThumbPos( 0 ); |
| UpdateScrollbar(); // will force edits to be filled new |
| } |
| |
| void HangulHanjaEditDictDialog::SetEditText( Edit& _rEdit, sal_uInt16 _nEntryNum ) |
| { |
| String aStr; |
| if( m_pSuggestions ) |
| { |
| const String* p = m_pSuggestions->Get( _nEntryNum ); |
| if( p ) |
| aStr = *p; |
| } |
| |
| _rEdit.SetText( aStr ); |
| } |
| |
| void HangulHanjaEditDictDialog::EditModify( Edit* _pEdit, sal_uInt8 _nEntryOffset ) |
| { |
| m_bModifiedSuggestions = true; |
| |
| String aTxt( _pEdit->GetText() ); |
| sal_uInt16 nEntryNum = m_nTopPos + _nEntryOffset; |
| if( aTxt.Len() == 0 ) |
| { |
| //reset suggestion |
| if( m_pSuggestions ) |
| m_pSuggestions->Reset( nEntryNum ); |
| } |
| else |
| { |
| //set suggestion |
| if( !m_pSuggestions ) |
| m_pSuggestions = new SuggestionList( MAXNUM_SUGGESTIONS ); |
| m_pSuggestions->Set( aTxt, nEntryNum ); |
| } |
| |
| UpdateButtonStates(); |
| } |
| |
| HangulHanjaEditDictDialog::HangulHanjaEditDictDialog( Window* _pParent, HHDictList& _rDictList, sal_uInt32 _nSelDict ) |
| :ModalDialog ( _pParent, CUI_RES( RID_SVX_MDLG_HANGULHANJA_EDIT ) ) |
| ,m_aEditHintText ( CUI_RES( STR_EDITHINT ) ) |
| ,m_rDictList ( _rDictList ) |
| ,m_nCurrentDict ( 0xFFFFFFFF ) |
| ,m_pSuggestions ( NULL ) |
| ,m_aBookFT ( this, CUI_RES( FT_BOOK ) ) |
| ,m_aBookLB ( this, CUI_RES( LB_BOOK ) ) |
| ,m_aOriginalFT ( this, CUI_RES( FT_ORIGINAL ) ) |
| ,m_aOriginalLB ( this, CUI_RES( LB_ORIGINAL ) ) |
| ,m_aSuggestionsFT ( this, CUI_RES( FT_SUGGESTIONS ) ) |
| ,m_aEdit1 ( this, CUI_RES( ED_1 ), m_aScrollSB, NULL, &m_aEdit2 ) |
| ,m_aEdit2 ( this, CUI_RES( ED_2 ), m_aScrollSB, &m_aEdit1, &m_aEdit3 ) |
| ,m_aEdit3 ( this, CUI_RES( ED_3 ), m_aScrollSB, &m_aEdit2, &m_aEdit4 ) |
| ,m_aEdit4 ( this, CUI_RES( ED_4 ), m_aScrollSB, &m_aEdit3, NULL ) |
| ,m_aScrollSB ( this, CUI_RES( SB_SCROLL ) ) |
| ,m_aNewPB ( this, CUI_RES( PB_HHE_NEW ) ) |
| ,m_aDeletePB ( this, CUI_RES( PB_HHE_DELETE ) ) |
| ,m_aHelpPB ( this, CUI_RES( PB_HHE_HELP ) ) |
| ,m_aClosePB ( this, CUI_RES( PB_HHE_CLOSE ) ) |
| ,m_nTopPos ( 0 ) |
| ,m_bModifiedSuggestions ( false ) |
| ,m_bModifiedOriginal ( false ) |
| { |
| m_aOriginalLB.SetModifyHdl( LINK( this, HangulHanjaEditDictDialog, OriginalModifyHdl ) ); |
| |
| m_aNewPB.SetClickHdl( LINK( this, HangulHanjaEditDictDialog, NewPBPushHdl ) ); |
| m_aNewPB.Enable( false ); |
| |
| m_aDeletePB.SetClickHdl( LINK( this, HangulHanjaEditDictDialog, DeletePBPushHdl ) ); |
| |
| m_aDeletePB.Enable( false ); |
| |
| #if( MAXNUM_SUGGESTIONS <= 4 ) |
| #error number of suggestions should not under-run the value of 5 |
| #endif |
| |
| Link aScrLk( LINK( this, HangulHanjaEditDictDialog, ScrollHdl ) ); |
| m_aScrollSB.SetScrollHdl( aScrLk ); |
| m_aScrollSB.SetEndScrollHdl( aScrLk ); |
| m_aScrollSB.SetRangeMin( 0 ); |
| m_aScrollSB.SetRangeMax( MAXNUM_SUGGESTIONS ); |
| m_aScrollSB.SetPageSize( 4 ); // because we have 4 edits / page |
| m_aScrollSB.SetVisibleSize( 4 ); |
| |
| m_aEdit1.SetModifyHdl( LINK( this, HangulHanjaEditDictDialog, EditModifyHdl1 ) ); |
| m_aEdit2.SetModifyHdl( LINK( this, HangulHanjaEditDictDialog, EditModifyHdl2 ) ); |
| m_aEdit3.SetModifyHdl( LINK( this, HangulHanjaEditDictDialog, EditModifyHdl3 ) ); |
| m_aEdit4.SetModifyHdl( LINK( this, HangulHanjaEditDictDialog, EditModifyHdl4 ) ); |
| |
| m_aBookLB.SetSelectHdl( LINK( this, HangulHanjaEditDictDialog, BookLBSelectHdl ) ); |
| sal_uInt32 nDictCnt = m_rDictList.size(); |
| for( sal_uInt32 n = 0 ; n < nDictCnt ; ++n ) |
| { |
| Reference< XConversionDictionary > xDic( m_rDictList[n] ); |
| String aName; |
| if(xDic.is()) |
| aName = xDic->getName(); |
| m_aBookLB.InsertEntry( aName ); |
| } |
| m_aBookLB.SelectEntryPos( sal_uInt16( _nSelDict ) ); |
| |
| FreeResource(); |
| |
| InitEditDictDialog( _nSelDict ); |
| } |
| |
| HangulHanjaEditDictDialog::~HangulHanjaEditDictDialog() |
| { |
| if( m_pSuggestions ) |
| delete m_pSuggestions; |
| } |
| |
| void HangulHanjaEditDictDialog::UpdateScrollbar( void ) |
| { |
| sal_uInt16 nPos = sal_uInt16( m_aScrollSB.GetThumbPos() ); |
| m_nTopPos = nPos; |
| |
| SetEditText( m_aEdit1, nPos++ ); |
| SetEditText( m_aEdit2, nPos++ ); |
| SetEditText( m_aEdit3, nPos++ ); |
| SetEditText( m_aEdit4, nPos ); |
| } |
| |
| //............................................................................. |
| } // namespace svx |
| //............................................................................. |