?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 6.4.0.3
[LibreOffice.git] / cui / source / dialogs / hangulhanjadlg.cxx
blobe3b0b2e5d592a31f045a58be7b695d1701ebe37f
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 <dialmgr.hxx>
22
23 #include <helpids.h>
24 #include <strings.hrc>
25
26 #include <algorithm>
27 #include <sal/log.hxx>
28 #include <osl/diagnose.h>
29 #include <tools/debug.hxx>
30 #include <i18nlangtag/languagetag.hxx>
31 #include <vcl/svapp.hxx>
32 #include <vcl/virdev.hxx>
33 #include <unotools/lingucfg.hxx>
34 #include <unotools/linguprops.hxx>
35 #include <com/sun/star/lang/NoSupportException.hpp>
36 #include <com/sun/star/linguistic2/ConversionDictionaryType.hpp>
37 #include <com/sun/star/linguistic2/ConversionDirection.hpp>
38 #include <com/sun/star/linguistic2/ConversionDictionaryList.hpp>
39 #include <com/sun/star/i18n/TextConversionOption.hpp>
40 #include <com/sun/star/util/XFlushable.hpp>
41
42 #include <comphelper/processfactory.hxx>
43 #include <comphelper/string.hxx>
44
45 #define HHC editeng::HangulHanjaConversion
46 #define LINE_CNT static_cast< sal_uInt16 >(2)
47 #define MAXNUM_SUGGESTIONS 50
48
49
50 namespace svx
51 {
52
53 using namespace ::com::sun::star;
54 using namespace css::uno;
55 using namespace css::linguistic2;
56 using namespace css::lang;
57 using namespace css::container;
58
59
60 namespace
61 {
62 class FontSwitch
63 {
64 private:
65 OutputDevice& m_rDev;
66
67 public:
68 FontSwitch( OutputDevice& _rDev, const vcl::Font& _rTemporaryFont )
69 :m_rDev( _rDev )
70 {
71 m_rDev.Push( PushFlags::FONT );
72 m_rDev.SetFont( _rTemporaryFont );
73 }
74 ~FontSwitch() COVERITY_NOEXCEPT_FALSE
75 {
76 m_rDev.Pop();
77 }
78 };
79 }
80
81 /** a class which allows to draw two texts in a pseudo-ruby way (which basically
82 means one text above or below the other, and a little bit smaller)
83 */
84 class PseudoRubyText
85 {
86 public:
87 enum RubyPosition
88 {
89 eAbove, eBelow
90 };
91
92 protected:
93 OUString m_sPrimaryText;
94 OUString m_sSecondaryText;
95 RubyPosition m_ePosition;
96
97 public:
98 PseudoRubyText();
99 void init( const OUString& rPrimaryText, const OUString& rSecondaryText, const RubyPosition& rPosition );
100 const OUString& getPrimaryText() const { return m_sPrimaryText; }
101 const OUString& getSecondaryText() const { return m_sSecondaryText; }
102
103 public:
104 void Paint( vcl::RenderContext& _rDevice, const ::tools::Rectangle& _rRect,
105 ::tools::Rectangle* _pPrimaryLocation, ::tools::Rectangle* _pSecondaryLocation );
106 };
107
108 PseudoRubyText::PseudoRubyText()
109 : m_ePosition(eAbove)
110 {
111 }
112
113 void PseudoRubyText::init( const OUString& rPrimaryText, const OUString& rSecondaryText, const RubyPosition& rPosition )
114 {
115 m_sPrimaryText = rPrimaryText;
116 m_sSecondaryText = rSecondaryText;
117 m_ePosition = rPosition;
118 }
119
120
121 void PseudoRubyText::Paint(vcl::RenderContext& rRenderContext, const ::tools::Rectangle& _rRect,
122 ::tools::Rectangle* _pPrimaryLocation, ::tools::Rectangle* _pSecondaryLocation )
123 {
124 // calculate the text flags for the painting
125 constexpr DrawTextFlags nTextStyle = DrawTextFlags::Mnemonic |
126 DrawTextFlags::Left |
127 DrawTextFlags::VCenter;
128
129 Size aPlaygroundSize(_rRect.GetSize());
130
131 // the font for the secondary text:
132 vcl::Font aSmallerFont(rRenderContext.GetFont());
133 // heuristic: 80% of the original size
134 aSmallerFont.SetFontHeight( static_cast<long>( 0.8 * aSmallerFont.GetFontHeight() ) );
135
136 // let's calculate the size of our two texts
137 ::tools::Rectangle aPrimaryRect = rRenderContext.GetTextRect( _rRect, m_sPrimaryText, nTextStyle );
138 ::tools::Rectangle aSecondaryRect;
139 {
140 FontSwitch aFontRestore(rRenderContext, aSmallerFont);
141 aSecondaryRect = rRenderContext.GetTextRect(_rRect, m_sSecondaryText, nTextStyle);
142 }
143
144 // position these rectangles properly
145 // x-axis:
146 sal_Int32 nCombinedWidth = std::max( aSecondaryRect.GetWidth(), aPrimaryRect.GetWidth() );
147 // the rectangle where both texts will reside is as high as possible, and as wide as the
148 // widest of both text rects
149 aPrimaryRect.SetLeft( _rRect.Left() );
150 aSecondaryRect.SetLeft( aPrimaryRect.Left() );
151 aPrimaryRect.SetRight( _rRect.Left() + nCombinedWidth );
152 aSecondaryRect.SetRight( aPrimaryRect.Right() );
153
154 // y-axis:
155 sal_Int32 nCombinedHeight = aPrimaryRect.GetHeight() + aSecondaryRect.GetHeight();
156 // align to the top, for the moment
157 aPrimaryRect.Move( 0, _rRect.Top() - aPrimaryRect.Top() );
158 aSecondaryRect.Move( 0, aPrimaryRect.Top() + aPrimaryRect.GetHeight() - aSecondaryRect.Top() );
159 // move the rects to the bottom
160 aPrimaryRect.Move( 0, ( aPlaygroundSize.Height() - nCombinedHeight ) / 2 );
161 aSecondaryRect.Move( 0, ( aPlaygroundSize.Height() - nCombinedHeight ) / 2 );
162
163 // 'til here, everything we did assumes that the secondary text is painted _below_ the primary
164 // text. If this isn't the case, we need to correct the rectangles
165 if (eAbove == m_ePosition)
166 {
167 sal_Int32 nVertDistance = aSecondaryRect.Top() - aPrimaryRect.Top();
168 aSecondaryRect.Move( 0, -nVertDistance );
169 aPrimaryRect.Move( 0, nCombinedHeight - nVertDistance );
170 }
171
172 // now draw the texts
173 // as we already calculated the precise rectangles for the texts, we don't want to
174 // use the alignment flags given - within it's rect, every text is centered
175 DrawTextFlags nDrawTextStyle( nTextStyle );
176 nDrawTextStyle &= ~DrawTextFlags( DrawTextFlags::Right | DrawTextFlags::Left | DrawTextFlags::Bottom | DrawTextFlags::Top );
177 nDrawTextStyle |= DrawTextFlags::Center | DrawTextFlags::VCenter;
178
179 rRenderContext.DrawText( aPrimaryRect, m_sPrimaryText, nDrawTextStyle );
180 {
181 FontSwitch aFontRestore(rRenderContext, aSmallerFont);
182 rRenderContext.DrawText( aSecondaryRect, m_sSecondaryText, nDrawTextStyle );
183 }
184
185 // outta here
186 if (_pPrimaryLocation)
187 *_pPrimaryLocation = aPrimaryRect;
188 if (_pSecondaryLocation)
189 *_pSecondaryLocation = aSecondaryRect;
190 }
191
192 class RubyRadioButton
193 {
194 public:
195 RubyRadioButton(std::unique_ptr<weld::RadioButton> xControl);
196 void init(const OUString& rPrimaryText, const OUString& rSecondaryText, const PseudoRubyText::RubyPosition& rPosition);
197
198 void set_sensitive(bool sensitive) { m_xControl->set_sensitive(sensitive); }
199 void set_active(bool active) { m_xControl->set_active(active); }
200 bool get_active() const { return m_xControl->get_active(); }
201
202 void connect_clicked(const Link<weld::Button&, void>& rLink) { m_xControl->connect_clicked(rLink); }
203
204 private:
205 Size GetOptimalSize() const;
206 void Paint(vcl::RenderContext& rRenderContext);
207
208 ScopedVclPtr<VirtualDevice> m_xVirDev;
209 std::unique_ptr<weld::RadioButton> m_xControl;
210 PseudoRubyText m_aRubyText;
211 };
212
213 RubyRadioButton::RubyRadioButton(std::unique_ptr<weld::RadioButton> xControl)
214 : m_xVirDev(xControl->create_virtual_device())
215 , m_xControl(std::move(xControl))
216 {
217 // expand the point size of the desired font to the equivalent pixel size
218 if (vcl::Window* pDefaultDevice = dynamic_cast<vcl::Window*>(Application::GetDefaultDevice()))
219 pDefaultDevice->SetPointFont(*m_xVirDev, m_xControl->get_font());
220 }
221
222 void RubyRadioButton::init( const OUString& rPrimaryText, const OUString& rSecondaryText, const PseudoRubyText::RubyPosition& rPosition )
223 {
224 m_aRubyText.init(rPrimaryText, rSecondaryText, rPosition);
225
226 m_xVirDev->SetOutputSizePixel(GetOptimalSize());
227
228 Paint(*m_xVirDev);
229
230 m_xControl->set_image(m_xVirDev.get());
231 }
232
233 void RubyRadioButton::Paint(vcl::RenderContext& rRenderContext)
234 {
235 ::tools::Rectangle aOverallRect(Point(0, 0), rRenderContext.GetOutputSizePixel());
236 // inflate the rect a little bit (because the VCL radio button does the same)
237 ::tools::Rectangle aTextRect( aOverallRect );
238 aTextRect.AdjustLeft( 1 ); aTextRect.AdjustRight( -1 );
239 aTextRect.AdjustTop( 1 ); aTextRect.AdjustBottom( -1 );
240
241 // paint the ruby text
242 ::tools::Rectangle aPrimaryTextLocation;
243 ::tools::Rectangle aSecondaryTextLocation;
244
245 m_aRubyText.Paint(rRenderContext, aTextRect, &aPrimaryTextLocation, &aSecondaryTextLocation);
246 }
247
248 Size RubyRadioButton::GetOptimalSize() const
249 {
250 vcl::Font aSmallerFont(m_xVirDev->GetFont());
251 aSmallerFont.SetFontHeight( static_cast<long>( 0.8 * aSmallerFont.GetFontHeight() ) );
252 ::tools::Rectangle rect( Point(), Size( SAL_MAX_INT32, SAL_MAX_INT32 ) );
253
254 Size aPrimarySize = m_xVirDev->GetTextRect( rect, m_aRubyText.getPrimaryText() ).GetSize();
255 Size aSecondarySize;
256 {
257 FontSwitch aFontRestore(*m_xVirDev, aSmallerFont);
258 aSecondarySize = m_xVirDev->GetTextRect( rect, m_aRubyText.getSecondaryText() ).GetSize();
259 }
260
261 Size minimumSize;
262 minimumSize.setHeight( aPrimarySize.Height() + aSecondarySize.Height() + 5 );
263 minimumSize.setWidth( aPrimarySize.Width() + aSecondarySize.Width() + 5 );
264 return minimumSize;
265 }
266
267 SuggestionSet::SuggestionSet(std::unique_ptr<weld::ScrolledWindow> xScrolledWindow)
268 : SvtValueSet(std::move(xScrolledWindow))
269
270 {
271 }
272
273 void SuggestionSet::UserDraw( const UserDrawEvent& rUDEvt )
274 {
275 vcl::RenderContext* pDev = rUDEvt.GetRenderContext();
276 ::tools::Rectangle aRect = rUDEvt.GetRect();
277 sal_uInt16 nItemId = rUDEvt.GetItemId();
278
279 OUString sText = *static_cast< OUString* >( GetItemData( nItemId ) );
280 pDev->DrawText( aRect, sText, DrawTextFlags::Center | DrawTextFlags::VCenter );
281 }
282
283 SuggestionDisplay::SuggestionDisplay(weld::Builder& rBuilder)
284 : m_bDisplayListBox( true )
285 , m_bInSelectionUpdate( false )
286 , m_xValueSet(new SuggestionSet(rBuilder.weld_scrolled_window("scrollwin")))
287 , m_xValueSetWin(new weld::CustomWeld(rBuilder, "valueset", *m_xValueSet))
288 , m_xListBox(rBuilder.weld_tree_view("listbox"))
289 {
290 m_xValueSet->SetSelectHdl( LINK( this, SuggestionDisplay, SelectSuggestionValueSetHdl ) );
291 m_xListBox->connect_changed( LINK( this, SuggestionDisplay, SelectSuggestionListBoxHdl ) );
292
293 m_xValueSet->SetLineCount( LINE_CNT );
294 m_xValueSet->SetStyle( m_xValueSet->GetStyle() | WB_ITEMBORDER | WB_VSCROLL );
295
296 OUString const aOneCharacter("AU");
297 auto nItemWidth = 2 * m_xListBox->get_pixel_size(aOneCharacter).Width();
298 m_xValueSet->SetItemWidth( nItemWidth );
299
300 Size aSize(m_xListBox->get_approximate_digit_width() * 42, m_xListBox->get_text_height() * 5);
301 m_xValueSet->set_size_request(aSize.Width(), aSize.Height());
302 m_xListBox->set_size_request(aSize.Width(), aSize.Height());
303
304 implUpdateDisplay();
305 }
306
307 void SuggestionDisplay::implUpdateDisplay()
308 {
309 m_xListBox->set_visible(m_bDisplayListBox);
310 if (!m_bDisplayListBox)
311 m_xValueSetWin->show();
312 else
313 m_xValueSetWin->hide();
314 }
315
316 weld::Widget& SuggestionDisplay::implGetCurrentControl()
317 {
318 if (m_bDisplayListBox)
319 return *m_xListBox;
320 return *m_xValueSet->GetDrawingArea();
321 }
322
323 void SuggestionDisplay::DisplayListBox( bool bDisplayListBox )
324 {
325 if( m_bDisplayListBox != bDisplayListBox )
326 {
327 weld::Widget& rOldControl = implGetCurrentControl();
328 bool bHasFocus = rOldControl.has_focus();
329
330 m_bDisplayListBox = bDisplayListBox;
331
332 if( bHasFocus )
333 {
334 weld::Widget& rNewControl = implGetCurrentControl();
335 rNewControl.grab_focus();
336 }
337
338 implUpdateDisplay();
339 }
340 }
341
342 IMPL_LINK_NOARG(SuggestionDisplay, SelectSuggestionValueSetHdl, SvtValueSet*, void)
343 {
344 SelectSuggestionHdl(false);
345 }
346
347 IMPL_LINK_NOARG(SuggestionDisplay, SelectSuggestionListBoxHdl, weld::TreeView&, void)
348 {
349 SelectSuggestionHdl(true);
350 }
351
352 void SuggestionDisplay::SelectSuggestionHdl(bool bListBox)
353 {
354 if( m_bInSelectionUpdate )
355 return;
356
357 m_bInSelectionUpdate = true;
358 if (bListBox)
359 {
360 sal_uInt16 nPos = m_xListBox->get_selected_index();
361 m_xValueSet->SelectItem( nPos+1 ); //itemid == pos+1 (id 0 has special meaning)
362 }
363 else
364 {
365 sal_uInt16 nPos = m_xValueSet->GetSelectedItemId()-1; //itemid == pos+1 (id 0 has special meaning)
366 m_xListBox->select(nPos);
367 }
368 m_bInSelectionUpdate = false;
369 m_aSelectLink.Call( *this );
370 }
371
372 void SuggestionDisplay::SetSelectHdl( const Link<SuggestionDisplay&,void>& rLink )
373 {
374 m_aSelectLink = rLink;
375 }
376
377 void SuggestionDisplay::Clear()
378 {
379 m_xListBox->clear();
380 m_xValueSet->Clear();
381 }
382
383 void SuggestionDisplay::InsertEntry( const OUString& rStr )
384 {
385 m_xListBox->append_text(rStr);
386 sal_uInt16 nItemId = m_xListBox->n_children(); //itemid == pos+1 (id 0 has special meaning)
387 m_xValueSet->InsertItem( nItemId );
388 OUString* pItemData = new OUString( rStr );
389 m_xValueSet->SetItemData( nItemId, pItemData );
390 }
391
392 void SuggestionDisplay::SelectEntryPos( sal_uInt16 nPos )
393 {
394 m_xListBox->select(nPos);
395 m_xValueSet->SelectItem( nPos+1 ); //itemid == pos+1 (id 0 has special meaning)
396 }
397
398 sal_uInt16 SuggestionDisplay::GetEntryCount() const
399 {
400 return m_xListBox->n_children();
401 }
402
403 OUString SuggestionDisplay::GetEntry( sal_uInt16 nPos ) const
404 {
405 return m_xListBox->get_text( nPos );
406 }
407
408 OUString SuggestionDisplay::GetSelectedEntry() const
409 {
410 return m_xListBox->get_selected_text();
411 }
412
413 void SuggestionDisplay::SetHelpIds()
414 {
415 m_xValueSet->SetHelpId(HID_HANGULDLG_SUGGESTIONS_GRID);
416 m_xListBox->set_help_id(HID_HANGULDLG_SUGGESTIONS_LIST);
417 }
418
419 HangulHanjaConversionDialog::HangulHanjaConversionDialog(weld::Window* pParent)
420 : GenericDialogController(pParent, "cui/ui/hangulhanjaconversiondialog.ui", "HangulHanjaConversionDialog")
421 , m_bDocumentMode( true )
422 , m_xFind(m_xBuilder->weld_button("find"))
423 , m_xIgnore(m_xBuilder->weld_button("ignore"))
424 , m_xIgnoreAll(m_xBuilder->weld_button("ignoreall"))
425 , m_xReplace(m_xBuilder->weld_button("replace"))
426 , m_xReplaceAll(m_xBuilder->weld_button("replaceall"))
427 , m_xOptions(m_xBuilder->weld_button("options"))
428 , m_xSuggestions(new SuggestionDisplay(*m_xBuilder))
429 , m_xSimpleConversion(m_xBuilder->weld_radio_button("simpleconversion"))
430 , m_xHangulBracketed(m_xBuilder->weld_radio_button("hangulbracket"))
431 , m_xHanjaBracketed(m_xBuilder->weld_radio_button("hanjabracket"))
432 , m_xWordInput(m_xBuilder->weld_entry("wordinput"))
433 , m_xOriginalWord(m_xBuilder->weld_label("originalword"))
434 , m_xHanjaAbove(new RubyRadioButton(m_xBuilder->weld_radio_button("hanja_above")))
435 , m_xHanjaBelow(new RubyRadioButton(m_xBuilder->weld_radio_button("hanja_below")))
436 , m_xHangulAbove(new RubyRadioButton(m_xBuilder->weld_radio_button("hangul_above")))
437 , m_xHangulBelow(new RubyRadioButton(m_xBuilder->weld_radio_button("hangul_below")))
438 , m_xHangulOnly(m_xBuilder->weld_check_button("hangulonly"))
439 , m_xHanjaOnly(m_xBuilder->weld_check_button("hanjaonly"))
440 , m_xReplaceByChar(m_xBuilder->weld_check_button("replacebychar"))
441 {
442 m_xSuggestions->set_size_request(m_xOriginalWord->get_approximate_digit_width() * 42,
443 m_xOriginalWord->get_text_height() * 5);
444
445 const OUString sHangul(CuiResId(RID_SVXSTR_HANGUL));
446 const OUString sHanja(CuiResId(RID_SVXSTR_HANJA));
447 m_xHanjaAbove->init( sHangul, sHanja, PseudoRubyText::eAbove );
448 m_xHanjaBelow->init( sHangul, sHanja, PseudoRubyText::eBelow );
449 m_xHangulAbove->init( sHanja, sHangul, PseudoRubyText::eAbove );
450 m_xHangulBelow->init( sHanja, sHangul, PseudoRubyText::eBelow );
451
452 m_xWordInput->connect_changed( LINK( this, HangulHanjaConversionDialog, OnSuggestionModified ) );
453 m_xSuggestions->SetSelectHdl( LINK( this, HangulHanjaConversionDialog, OnSuggestionSelected ) );
454 m_xReplaceByChar->connect_toggled( LINK( this, HangulHanjaConversionDialog, ClickByCharacterHdl ) );
455 m_xHangulOnly->connect_toggled( LINK( this, HangulHanjaConversionDialog, OnConversionDirectionClicked ) );
456 m_xHanjaOnly->connect_toggled( LINK( this, HangulHanjaConversionDialog, OnConversionDirectionClicked ) );
457 m_xOptions->connect_clicked(LINK(this, HangulHanjaConversionDialog, OnOption));
458
459 // initial focus
460 FocusSuggestion( );
461
462 // initial control values
463 m_xSimpleConversion->set_active(true);
464
465 m_xSuggestions->SetHelpIds();
466 }
467
468 HangulHanjaConversionDialog::~HangulHanjaConversionDialog()
469 {
470 }
471
472 void HangulHanjaConversionDialog::FillSuggestions( const css::uno::Sequence< OUString >& _rSuggestions )
473 {
474 m_xSuggestions->Clear();
475 for ( auto const & suggestion : _rSuggestions )
476 m_xSuggestions->InsertEntry( suggestion );
477
478 // select the first suggestion, and fill in the suggestion edit field
479 OUString sFirstSuggestion;
480 if ( m_xSuggestions->GetEntryCount() )
481 {
482 sFirstSuggestion = m_xSuggestions->GetEntry( 0 );
483 m_xSuggestions->SelectEntryPos( 0 );
484 }
485 m_xWordInput->set_text( sFirstSuggestion );
486 m_xWordInput->save_value();
487 OnSuggestionModified( *m_xWordInput );
488 }
489
490 void HangulHanjaConversionDialog::SetOptionsChangedHdl(const Link<LinkParamNone*,void>& rHdl)
491 {
492 m_aOptionsChangedLink = rHdl;
493 }
494
495 void HangulHanjaConversionDialog::SetIgnoreHdl(const Link<weld::Button&,void>& rHdl)
496 {
497 m_xIgnore->connect_clicked(rHdl);
498 }
499
500 void HangulHanjaConversionDialog::SetIgnoreAllHdl(const Link<weld::Button&,void>& rHdl)
501 {
502 m_xIgnoreAll->connect_clicked(rHdl);
503 }
504
505 void HangulHanjaConversionDialog::SetChangeHdl(const Link<weld::Button&,void>& rHdl )
506 {
507 m_xReplace->connect_clicked(rHdl);
508 }
509
510 void HangulHanjaConversionDialog::SetChangeAllHdl(const Link<weld::Button&,void>& rHdl)
511 {
512 m_xReplaceAll->connect_clicked(rHdl);
513 }
514
515 void HangulHanjaConversionDialog::SetFindHdl(const Link<weld::Button&,void>& rHdl)
516 {
517 m_xFind->connect_clicked(rHdl);
518 }
519
520 void HangulHanjaConversionDialog::SetConversionFormatChangedHdl( const Link<weld::Button&,void>& rHdl )
521 {
522 m_xSimpleConversion->connect_clicked( rHdl );
523 m_xHangulBracketed->connect_clicked( rHdl );
524 m_xHanjaBracketed->connect_clicked( rHdl );
525 m_xHanjaAbove->connect_clicked( rHdl );
526 m_xHanjaBelow->connect_clicked( rHdl );
527 m_xHangulAbove->connect_clicked( rHdl );
528 m_xHangulBelow->connect_clicked( rHdl );
529 }
530
531 void HangulHanjaConversionDialog::SetClickByCharacterHdl( const Link<weld::ToggleButton&,void>& _rHdl )
532 {
533 m_aClickByCharacterLink = _rHdl;
534 }
535
536 IMPL_LINK_NOARG( HangulHanjaConversionDialog, OnSuggestionSelected, SuggestionDisplay&, void )
537 {
538 m_xWordInput->set_text(m_xSuggestions->GetSelectedEntry());
539 OnSuggestionModified( *m_xWordInput );
540 }
541
542 IMPL_LINK_NOARG( HangulHanjaConversionDialog, OnSuggestionModified, weld::Entry&, void )
543 {
544 m_xFind->set_sensitive(m_xWordInput->get_value_changed_from_saved());
545
546 bool bSameLen = m_xWordInput->get_text().getLength() == m_xOriginalWord->get_label().getLength();
547 m_xReplace->set_sensitive( m_bDocumentMode && bSameLen );
548 m_xReplaceAll->set_sensitive( m_bDocumentMode && bSameLen );
549 }
550
551 IMPL_LINK(HangulHanjaConversionDialog, ClickByCharacterHdl, weld::ToggleButton&, rBox, void)
552 {
553 m_aClickByCharacterLink.Call(rBox);
554 bool bByCharacter = rBox.get_active();
555 m_xSuggestions->DisplayListBox( !bByCharacter );
556 }
557
558 IMPL_LINK(HangulHanjaConversionDialog, OnConversionDirectionClicked, weld::ToggleButton&, rBox, void)
559 {
560 weld::CheckButton* pOtherBox = nullptr;
561 if (&rBox == m_xHangulOnly.get())
562 pOtherBox = m_xHanjaOnly.get();
563 else
564 pOtherBox = m_xHangulOnly.get();
565 bool bBoxChecked = rBox.get_active();
566 if (bBoxChecked)
567 pOtherBox->set_active(false);
568 pOtherBox->set_sensitive(!bBoxChecked);
569 }
570
571 IMPL_LINK_NOARG(HangulHanjaConversionDialog, OnOption, weld::Button&, void)
572 {
573 HangulHanjaOptionsDialog aOptDlg(m_xDialog.get());
574 aOptDlg.run();
575 m_aOptionsChangedLink.Call( nullptr );
576 }
577
578 OUString HangulHanjaConversionDialog::GetCurrentString( ) const
579 {
580 return m_xOriginalWord->get_label();
581 }
582
583 void HangulHanjaConversionDialog::FocusSuggestion( )
584 {
585 m_xWordInput->grab_focus();
586 }
587
588 void HangulHanjaConversionDialog::SetCurrentString( const OUString& _rNewString,
589 const Sequence< OUString >& _rSuggestions, bool _bOriginatesFromDocument )
590 {
591 m_xOriginalWord->set_label(_rNewString);
592
593 bool bOldDocumentMode = m_bDocumentMode;
594 m_bDocumentMode = _bOriginatesFromDocument; // before FillSuggestions!
595 FillSuggestions( _rSuggestions );
596
597 m_xIgnoreAll->set_sensitive( m_bDocumentMode );
598
599 // switch the def button depending if we're working for document text
600 if (bOldDocumentMode != m_bDocumentMode)
601 {
602 weld::Widget* pOldDefButton = nullptr;
603 weld::Widget* pNewDefButton = nullptr;
604 if (m_bDocumentMode)
605 {
606 pOldDefButton = m_xFind.get();
607 pNewDefButton = m_xReplace.get();
608 }
609 else
610 {
611 pOldDefButton = m_xReplace.get();
612 pNewDefButton = m_xFind.get();
613 }
614
615 pOldDefButton->set_has_default(false);
616 pNewDefButton->set_has_default(true);
617 }
618 }
619
620 OUString HangulHanjaConversionDialog::GetCurrentSuggestion( ) const
621 {
622 return m_xWordInput->get_text();
623 }
624
625 void HangulHanjaConversionDialog::SetByCharacter( bool _bByCharacter )
626 {
627 m_xReplaceByChar->set_active( _bByCharacter );
628 m_xSuggestions->DisplayListBox( !_bByCharacter );
629 }
630
631 void HangulHanjaConversionDialog::SetConversionDirectionState(
632 bool _bTryBothDirections,
633 HHC::ConversionDirection ePrimaryConversionDirection )
634 {
635 // default state: try both direction
636 m_xHangulOnly->set_active( false );
637 m_xHangulOnly->set_sensitive(true);
638 m_xHanjaOnly->set_active( false );
639 m_xHanjaOnly->set_sensitive(true);
640
641 if (!_bTryBothDirections)
642 {
643 weld::CheckButton* pBox = ePrimaryConversionDirection == HHC::eHangulToHanja ?
644 m_xHangulOnly.get() : m_xHanjaOnly.get();
645 pBox->set_active(true);
646 OnConversionDirectionClicked(*pBox);
647 }
648 }
649
650 bool HangulHanjaConversionDialog::GetUseBothDirections( ) const
651 {
652 return !m_xHangulOnly->get_active() && !m_xHanjaOnly->get_active();
653 }
654
655 HHC::ConversionDirection HangulHanjaConversionDialog::GetDirection(
656 HHC::ConversionDirection eDefaultDirection ) const
657 {
658 HHC::ConversionDirection eDirection = eDefaultDirection;
659 if (m_xHangulOnly->get_active() && !m_xHanjaOnly->get_active())
660 eDirection = HHC::eHangulToHanja;
661 else if (!m_xHangulOnly->get_active() && m_xHanjaOnly->get_active())
662 eDirection = HHC::eHanjaToHangul;
663 return eDirection;
664 }
665
666 void HangulHanjaConversionDialog::SetConversionFormat( HHC::ConversionFormat _eType )
667 {
668 switch ( _eType )
669 {
670 case HHC::eSimpleConversion: m_xSimpleConversion->set_active(true); break;
671 case HHC::eHangulBracketed: m_xHangulBracketed->set_active(true); break;
672 case HHC::eHanjaBracketed: m_xHanjaBracketed->set_active(true); break;
673 case HHC::eRubyHanjaAbove: m_xHanjaAbove->set_active(true); break;
674 case HHC::eRubyHanjaBelow: m_xHanjaBelow->set_active(true); break;
675 case HHC::eRubyHangulAbove: m_xHangulAbove->set_active(true); break;
676 case HHC::eRubyHangulBelow: m_xHangulBelow->set_active(true); break;
677 default:
678 OSL_FAIL( "HangulHanjaConversionDialog::SetConversionFormat: unknown type!" );
679 }
680 }
681
682 HHC::ConversionFormat HangulHanjaConversionDialog::GetConversionFormat( ) const
683 {
684 if ( m_xSimpleConversion->get_active() )
685 return HHC::eSimpleConversion;
686 if ( m_xHangulBracketed->get_active() )
687 return HHC::eHangulBracketed;
688 if ( m_xHanjaBracketed->get_active() )
689 return HHC::eHanjaBracketed;
690 if ( m_xHanjaAbove->get_active() )
691 return HHC::eRubyHanjaAbove;
692 if ( m_xHanjaBelow->get_active() )
693 return HHC::eRubyHanjaBelow;
694 if ( m_xHangulAbove->get_active() )
695 return HHC::eRubyHangulAbove;
696 if ( m_xHangulBelow->get_active() )
697 return HHC::eRubyHangulBelow;
698
699 OSL_FAIL( "HangulHanjaConversionDialog::GetConversionFormat: no radio checked?" );
700 return HHC::eSimpleConversion;
701 }
702
703 void HangulHanjaConversionDialog::EnableRubySupport( bool bVal )
704 {
705 m_xHanjaAbove->set_sensitive( bVal );
706 m_xHanjaBelow->set_sensitive( bVal );
707 m_xHangulAbove->set_sensitive( bVal );
708 m_xHangulBelow->set_sensitive( bVal );
709 }
710
711 void HangulHanjaOptionsDialog::Init()
712 {
713 if( !m_xConversionDictionaryList.is() )
714 {
715 m_xConversionDictionaryList = ConversionDictionaryList::create( ::comphelper::getProcessComponentContext() );
716 }
717
718 m_aDictList.clear();
719 m_xDictsLB->clear();
720
721 Reference< XNameContainer > xNameCont = m_xConversionDictionaryList->getDictionaryContainer();
722 if( xNameCont.is() )
723 {
724 Sequence< OUString > aDictNames( xNameCont->getElementNames() );
725
726 const OUString* pDic = aDictNames.getConstArray();
727 sal_Int32 nCount = aDictNames.getLength();
728
729 sal_Int32 i;
730 for( i = 0 ; i < nCount ; ++i )
731 {
732 Any aAny( xNameCont->getByName( pDic[ i ] ) );
733 Reference< XConversionDictionary > xDic;
734 if( ( aAny >>= xDic ) && xDic.is() )
735 {
736 if( LANGUAGE_KOREAN == LanguageTag( xDic->getLocale() ).getLanguageType() )
737 {
738 m_aDictList.push_back( xDic );
739 AddDict( xDic->getName(), xDic->isActive() );
740 }
741 }
742 }
743 }
744 if (m_xDictsLB->n_children())
745 m_xDictsLB->select(0);
746 }
747
748 IMPL_LINK_NOARG(HangulHanjaOptionsDialog, OkHdl, weld::Button&, void)
749 {
750 sal_uInt32 nCnt = m_aDictList.size();
751 sal_uInt32 n = 0;
752 sal_uInt32 nActiveDics = 0;
753 Sequence< OUString > aActiveDics;
754
755 aActiveDics.realloc( nCnt );
756 OUString* pActActiveDic = aActiveDics.getArray();
757
758 while( nCnt )
759 {
760 Reference< XConversionDictionary > xDict = m_aDictList[ n ];
761
762 DBG_ASSERT( xDict.is(), "-HangulHanjaOptionsDialog::OkHdl(): someone is evaporated..." );
763
764 bool bActive = m_xDictsLB->get_toggle(n, 0) == TRISTATE_TRUE;
765 xDict->setActive( bActive );
766 Reference< util::XFlushable > xFlush( xDict, uno::UNO_QUERY );
767 if( xFlush.is() )
768 xFlush->flush();
769
770 if( bActive )
771 {
772 pActActiveDic[ nActiveDics ] = xDict->getName();
773 ++nActiveDics;
774 }
775
776 ++n;
777 --nCnt;
778 }
779
780 // save configuration
781 aActiveDics.realloc( nActiveDics );
782 Any aTmp;
783 SvtLinguConfig aLngCfg;
784 aTmp <<= aActiveDics;
785 aLngCfg.SetProperty( UPH_ACTIVE_CONVERSION_DICTIONARIES, aTmp );
786
787 aTmp <<= m_xIgnorepostCB->get_active();
788 aLngCfg.SetProperty( UPH_IS_IGNORE_POST_POSITIONAL_WORD, aTmp );
789
790 aTmp <<= m_xShowrecentlyfirstCB->get_active();
791 aLngCfg.SetProperty( UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST, aTmp );
792
793 aTmp <<= m_xAutoreplaceuniqueCB->get_active();
794 aLngCfg.SetProperty( UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES, aTmp );
795
796 m_xDialog->response(RET_OK);
797 }
798
799 IMPL_LINK_NOARG(HangulHanjaOptionsDialog, DictsLB_SelectHdl, weld::TreeView&, void)
800 {
801 bool bSel = m_xDictsLB->get_selected_index() != -1;
802
803 m_xEditPB->set_sensitive(bSel);
804 m_xDeletePB->set_sensitive(bSel);
805 }
806
807 IMPL_LINK_NOARG(HangulHanjaOptionsDialog, NewDictHdl, weld::Button&, void)
808 {
809 OUString aName;
810 HangulHanjaNewDictDialog aNewDlg(m_xDialog.get());
811 aNewDlg.run();
812 if (aNewDlg.GetName(aName))
813 {
814 if( m_xConversionDictionaryList.is() )
815 {
816 try
817 {
818 Reference< XConversionDictionary > xDic =
819 m_xConversionDictionaryList->addNewDictionary( aName, LanguageTag::convertToLocale( LANGUAGE_KOREAN ), ConversionDictionaryType::HANGUL_HANJA );
820
821 if( xDic.is() )
822 {
823 //adapt local caches:
824 m_aDictList.push_back( xDic );
825 AddDict( xDic->getName(), xDic->isActive() );
826 }
827 }
828 catch( const ElementExistException& )
829 {
830 }
831 catch( const NoSupportException& )
832 {
833 }
834 }
835 }
836 }
837
838 IMPL_LINK_NOARG(HangulHanjaOptionsDialog, EditDictHdl, weld::Button&, void)
839 {
840 int nEntry = m_xDictsLB->get_selected_index();
841 DBG_ASSERT(nEntry != -1, "+HangulHanjaEditDictDialog::EditDictHdl(): call of edit should not be possible with no selection!");
842 if (nEntry != -1)
843 {
844 HangulHanjaEditDictDialog aEdDlg(m_xDialog.get(), m_aDictList, nEntry);
845 aEdDlg.run();
846 }
847 }
848
849 IMPL_LINK_NOARG(HangulHanjaOptionsDialog, DeleteDictHdl, weld::Button&, void)
850 {
851 int nSelPos = m_xDictsLB->get_selected_index();
852 if (nSelPos != -1)
853 {
854 Reference< XConversionDictionary > xDic( m_aDictList[ nSelPos ] );
855 if( m_xConversionDictionaryList.is() && xDic.is() )
856 {
857 Reference< XNameContainer > xNameCont = m_xConversionDictionaryList->getDictionaryContainer();
858 if( xNameCont.is() )
859 {
860 try
861 {
862 xNameCont->removeByName( xDic->getName() );
863
864 //adapt local caches:
865 m_aDictList.erase(m_aDictList.begin()+nSelPos );
866 m_xDictsLB->remove(nSelPos);
867 }
868 catch( const ElementExistException& )
869 {
870 }
871 catch( const NoSupportException& )
872 {
873 }
874 }
875 }
876 }
877 }
878
879 HangulHanjaOptionsDialog::HangulHanjaOptionsDialog(weld::Window* pParent)
880 : GenericDialogController(pParent, "cui/ui/hangulhanjaoptdialog.ui", "HangulHanjaOptDialog")
881 , m_xDictsLB(m_xBuilder->weld_tree_view("dicts"))
882 , m_xIgnorepostCB(m_xBuilder->weld_check_button("ignorepost"))
883 , m_xShowrecentlyfirstCB(m_xBuilder->weld_check_button("showrecentfirst"))
884 , m_xAutoreplaceuniqueCB(m_xBuilder->weld_check_button("autoreplaceunique"))
885 , m_xNewPB(m_xBuilder->weld_button("new"))
886 , m_xEditPB(m_xBuilder->weld_button("edit"))
887 , m_xDeletePB(m_xBuilder->weld_button("delete"))
888 , m_xOkPB(m_xBuilder->weld_button("ok"))
889 {
890 m_xDictsLB->set_size_request(m_xDictsLB->get_approximate_digit_width() * 32,
891 m_xDictsLB->get_height_rows(5));
892
893 std::vector<int> aWidths;
894 aWidths.push_back(m_xDictsLB->get_checkbox_column_width());
895 m_xDictsLB->set_column_fixed_widths(aWidths);
896
897 m_xDictsLB->connect_changed( LINK( this, HangulHanjaOptionsDialog, DictsLB_SelectHdl ) );
898
899 m_xOkPB->connect_clicked( LINK( this, HangulHanjaOptionsDialog, OkHdl ) );
900 m_xNewPB->connect_clicked( LINK( this, HangulHanjaOptionsDialog, NewDictHdl ) );
901 m_xEditPB->connect_clicked( LINK( this, HangulHanjaOptionsDialog, EditDictHdl ) );
902 m_xDeletePB->connect_clicked( LINK( this, HangulHanjaOptionsDialog, DeleteDictHdl ) );
903
904 SvtLinguConfig aLngCfg;
905 Any aTmp;
906 bool bVal = bool();
907 aTmp = aLngCfg.GetProperty( UPH_IS_IGNORE_POST_POSITIONAL_WORD );
908 if( aTmp >>= bVal )
909 m_xIgnorepostCB->set_active( bVal );
910
911 aTmp = aLngCfg.GetProperty( UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST );
912 if( aTmp >>= bVal )
913 m_xShowrecentlyfirstCB->set_active( bVal );
914
915 aTmp = aLngCfg.GetProperty( UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES );
916 if( aTmp >>= bVal )
917 m_xAutoreplaceuniqueCB->set_active( bVal );
918
919 Init();
920 }
921
922 HangulHanjaOptionsDialog::~HangulHanjaOptionsDialog()
923 {
924 }
925
926 void HangulHanjaOptionsDialog::AddDict(const OUString& rName, bool bChecked)
927 {
928 m_xDictsLB->append();
929 int nRow = m_xDictsLB->n_children() - 1;
930 m_xDictsLB->set_toggle(nRow, bChecked ? TRISTATE_TRUE : TRISTATE_FALSE, 0);
931 m_xDictsLB->set_text(nRow, rName, 1);
932 m_xDictsLB->set_id(nRow, rName);
933 }
934
935 IMPL_LINK_NOARG(HangulHanjaNewDictDialog, OKHdl, weld::Button&, void)
936 {
937 OUString aName(comphelper::string::stripEnd(m_xDictNameED->get_text(), ' '));
938
939 m_bEntered = !aName.isEmpty();
940 if (m_bEntered)
941 m_xDictNameED->set_text(aName); // do this in case of trailing chars have been deleted
942
943 m_xDialog->response(RET_OK);
944 }
945
946 IMPL_LINK_NOARG(HangulHanjaNewDictDialog, ModifyHdl, weld::Entry&, void)
947 {
948 OUString aName(comphelper::string::stripEnd(m_xDictNameED->get_text(), ' '));
949
950 m_xOkBtn->set_sensitive(!aName.isEmpty());
951 }
952
953 HangulHanjaNewDictDialog::HangulHanjaNewDictDialog(weld::Window* pParent)
954 : GenericDialogController(pParent, "cui/ui/hangulhanjaadddialog.ui", "HangulHanjaAddDialog")
955 , m_bEntered(false)
956 , m_xOkBtn(m_xBuilder->weld_button("ok"))
957 , m_xDictNameED(m_xBuilder->weld_entry("entry"))
958 {
959 m_xOkBtn->connect_clicked( LINK( this, HangulHanjaNewDictDialog, OKHdl ) );
960 m_xDictNameED->connect_changed( LINK( this, HangulHanjaNewDictDialog, ModifyHdl ) );
961 }
962
963 HangulHanjaNewDictDialog::~HangulHanjaNewDictDialog()
964 {
965 }
966
967 bool HangulHanjaNewDictDialog::GetName( OUString& _rRetName ) const
968 {
969 if( m_bEntered )
970 _rRetName = comphelper::string::stripEnd(m_xDictNameED->get_text(), ' ');
971
972 return m_bEntered;
973 }
974
975 class SuggestionList
976 {
977 private:
978 protected:
979 std::vector<OUString> m_vElements;
980 sal_uInt16 m_nNumOfEntries;
981 // index of the internal iterator, used for First() and Next() methods
982 sal_uInt16 m_nAct;
983
984 const OUString* Next_();
985 public:
986 SuggestionList();
987 ~SuggestionList();
988
989 void Set( const OUString& _rElement, sal_uInt16 _nNumOfElement );
990 void Reset( sal_uInt16 _nNumOfElement );
991 const OUString & Get( sal_uInt16 _nNumOfElement ) const;
992 void Clear();
993
994 const OUString* First();
995 const OUString* Next();
996
997 sal_uInt16 GetCount() const { return m_nNumOfEntries; }
998 };
999
1000 SuggestionList::SuggestionList() :
1001 m_vElements(MAXNUM_SUGGESTIONS)
1002 {
1003 m_nAct = m_nNumOfEntries = 0;
1004 }
1005
1006 SuggestionList::~SuggestionList()
1007 {
1008 Clear();
1009 }
1010
1011 void SuggestionList::Set( const OUString& _rElement, sal_uInt16 _nNumOfElement )
1012 {
1013 m_vElements[_nNumOfElement] = _rElement;
1014 ++m_nNumOfEntries;
1015 }
1016
1017 void SuggestionList::Reset( sal_uInt16 _nNumOfElement )
1018 {
1019 m_vElements[_nNumOfElement].clear();
1020 --m_nNumOfEntries;
1021 }
1022
1023 const OUString& SuggestionList::Get( sal_uInt16 _nNumOfElement ) const
1024 {
1025 return m_vElements[_nNumOfElement];
1026 }
1027
1028 void SuggestionList::Clear()
1029 {
1030 if( m_nNumOfEntries )
1031 {
1032 for (auto & vElement : m_vElements)
1033 vElement.clear();
1034 m_nNumOfEntries = m_nAct = 0;
1035 }
1036 }
1037
1038 const OUString* SuggestionList::Next_()
1039 {
1040 while( m_nAct < m_vElements.size() )
1041 {
1042 auto & s = m_vElements[ m_nAct ];
1043 if (!s.isEmpty())
1044 return &s;
1045 ++m_nAct;
1046 }
1047
1048 return nullptr;
1049 }
1050
1051 const OUString* SuggestionList::First()
1052 {
1053 m_nAct = 0;
1054 return Next_();
1055 }
1056
1057 const OUString* SuggestionList::Next()
1058 {
1059 const OUString* pRet;
1060
1061 if( m_nAct < m_nNumOfEntries )
1062 {
1063 ++m_nAct;
1064 pRet = Next_();
1065 }
1066 else
1067 pRet = nullptr;
1068
1069 return pRet;
1070 }
1071
1072
1073 bool SuggestionEdit::ShouldScroll( bool _bUp ) const
1074 {
1075 bool bRet = false;
1076
1077 if( _bUp )
1078 {
1079 if( !m_pPrev )
1080 bRet = m_pScrollBar->vadjustment_get_value() > m_pScrollBar->vadjustment_get_lower();
1081 }
1082 else
1083 {
1084 if( !m_pNext )
1085 bRet = m_pScrollBar->vadjustment_get_value() < ( m_pScrollBar->vadjustment_get_upper() - 4 );
1086 }
1087
1088 return bRet;
1089 }
1090
1091 void SuggestionEdit::DoJump( bool _bUp )
1092 {
1093 m_pScrollBar->vadjustment_set_value( m_pScrollBar->vadjustment_get_value() + ( _bUp? -1 : 1 ) );
1094 m_pParent->UpdateScrollbar();
1095 }
1096
1097 SuggestionEdit::SuggestionEdit(std::unique_ptr<weld::Entry> xEntry, HangulHanjaEditDictDialog* pParent)
1098 : m_pParent(pParent)
1099 , m_pPrev(nullptr)
1100 , m_pNext(nullptr)
1101 , m_pScrollBar(nullptr)
1102 , m_xEntry(std::move(xEntry))
1103 {
1104 m_xEntry->connect_key_press(LINK(this, SuggestionEdit, KeyInputHdl));
1105 }
1106
1107 IMPL_LINK(SuggestionEdit, KeyInputHdl, const KeyEvent&, rKEvt, bool)
1108 {
1109 bool bHandled = false;
1110
1111 const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode();
1112 sal_uInt16 nMod = rKeyCode.GetModifier();
1113 sal_uInt16 nCode = rKeyCode.GetCode();
1114 if( nCode == KEY_TAB && ( !nMod || KEY_SHIFT == nMod ) )
1115 {
1116 bool bUp = KEY_SHIFT == nMod;
1117 if( ShouldScroll( bUp ) )
1118 {
1119 DoJump( bUp );
1120 m_xEntry->select_region(0, -1);
1121 // Tab-travel doesn't really happen, so emulate it by setting a selection manually
1122 bHandled = true;
1123 }
1124 }
1125 else if( KEY_UP == nCode || KEY_DOWN == nCode )
1126 {
1127 bool bUp = KEY_UP == nCode;
1128 if( ShouldScroll( bUp ) )
1129 {
1130 DoJump( bUp );
1131 bHandled = true;
1132 }
1133 else if( bUp )
1134 {
1135 if( m_pPrev )
1136 {
1137 m_pPrev->grab_focus();
1138 bHandled = true;
1139 }
1140 }
1141 else if( m_pNext )
1142 {
1143 m_pNext->grab_focus();
1144 bHandled = true;
1145 }
1146 }
1147
1148 return bHandled;
1149 }
1150
1151 void SuggestionEdit::init(weld::ScrolledWindow* pScrollBar, SuggestionEdit* pPrev, SuggestionEdit* pNext)
1152 {
1153 m_pScrollBar = pScrollBar;
1154 m_pPrev = pPrev;
1155 m_pNext = pNext;
1156 }
1157
1158 namespace
1159 {
1160 bool GetConversions( const Reference< XConversionDictionary >& _xDict,
1161 const OUString& _rOrg,
1162 Sequence< OUString >& _rEntries )
1163 {
1164 bool bRet = false;
1165 if( _xDict.is() && !_rOrg.isEmpty() )
1166 {
1167 try
1168 {
1169 _rEntries = _xDict->getConversions( _rOrg,
1170 0,
1171 _rOrg.getLength(),
1172 ConversionDirection_FROM_LEFT,
1173 css::i18n::TextConversionOption::NONE );
1174 bRet = _rEntries.hasElements();
1175 }
1176 catch( const IllegalArgumentException& )
1177 {
1178 }
1179 }
1180
1181 return bRet;
1182 }
1183 }
1184
1185 IMPL_LINK_NOARG( HangulHanjaEditDictDialog, ScrollHdl, weld::ScrolledWindow&, void )
1186 {
1187 UpdateScrollbar();
1188 }
1189
1190 IMPL_LINK_NOARG( HangulHanjaEditDictDialog, OriginalModifyHdl, weld::ComboBox&, void )
1191 {
1192 m_bModifiedOriginal = true;
1193 m_aOriginal = comphelper::string::stripEnd( m_xOriginalLB->get_active_text(), ' ' );
1194
1195 UpdateSuggestions();
1196 UpdateButtonStates();
1197 }
1198
1199 IMPL_LINK( HangulHanjaEditDictDialog, EditModifyHdl1, weld::Entry&, rEdit, void )
1200 {
1201 EditModify( &rEdit, 0 );
1202 }
1203
1204 IMPL_LINK( HangulHanjaEditDictDialog, EditModifyHdl2, weld::Entry&, rEdit, void )
1205 {
1206 EditModify( &rEdit, 1 );
1207 }
1208
1209 IMPL_LINK( HangulHanjaEditDictDialog, EditModifyHdl3, weld::Entry&, rEdit, void )
1210 {
1211 EditModify( &rEdit, 2 );
1212 }
1213
1214 IMPL_LINK( HangulHanjaEditDictDialog, EditModifyHdl4, weld::Entry&, rEdit, void )
1215 {
1216 EditModify( &rEdit, 3 );
1217 }
1218
1219 IMPL_LINK_NOARG( HangulHanjaEditDictDialog, BookLBSelectHdl, weld::ComboBox&, void )
1220 {
1221 InitEditDictDialog( m_xBookLB->get_active() );
1222 }
1223
1224 IMPL_LINK_NOARG( HangulHanjaEditDictDialog, NewPBPushHdl, weld::Button&, void )
1225 {
1226 DBG_ASSERT( m_xSuggestions, "-HangulHanjaEditDictDialog::NewPBPushHdl(): no suggestions... search in hell..." );
1227 Reference< XConversionDictionary > xDict = m_rDictList[ m_nCurrentDict ];
1228 if( xDict.is() && m_xSuggestions )
1229 {
1230 //delete old entry
1231 bool bRemovedSomething = DeleteEntryFromDictionary( xDict );
1232
1233 OUString aLeft( m_aOriginal );
1234 const OUString* pRight = m_xSuggestions->First();
1235 bool bAddedSomething = false;
1236 while( pRight )
1237 {
1238 try
1239 {
1240 //add new entry
1241 xDict->addEntry( aLeft, *pRight );
1242 bAddedSomething = true;
1243 }
1244 catch( const IllegalArgumentException& )
1245 {
1246 }
1247 catch( const ElementExistException& )
1248 {
1249 }
1250
1251 pRight = m_xSuggestions->Next();
1252 }
1253
1254 if( bAddedSomething || bRemovedSomething )
1255 InitEditDictDialog( m_nCurrentDict );
1256 }
1257 else
1258 {
1259 SAL_INFO( "cui.dialogs", "dictionary faded away..." );
1260 }
1261 }
1262
1263 bool HangulHanjaEditDictDialog::DeleteEntryFromDictionary( const Reference< XConversionDictionary >& xDict )
1264 {
1265 bool bRemovedSomething = false;
1266 if( xDict.is() )
1267 {
1268 OUString aOrg( m_aOriginal );
1269 Sequence< OUString > aEntries;
1270 GetConversions( xDict, m_aOriginal, aEntries );
1271
1272 sal_uInt32 n = aEntries.getLength();
1273 OUString* pEntry = aEntries.getArray();
1274 while( n )
1275 {
1276 try
1277 {
1278 xDict->removeEntry( aOrg, *pEntry );
1279 bRemovedSomething = true;
1280 }
1281 catch( const NoSuchElementException& )
1282 { // can not be...
1283 }
1284
1285 ++pEntry;
1286 --n;
1287 }
1288 }
1289 return bRemovedSomething;
1290 }
1291
1292 IMPL_LINK_NOARG( HangulHanjaEditDictDialog, DeletePBPushHdl, weld::Button&, void )
1293 {
1294 if( DeleteEntryFromDictionary( m_rDictList[ m_nCurrentDict ] ) )
1295 {
1296 m_aOriginal.clear();
1297 m_bModifiedOriginal = true;
1298 InitEditDictDialog( m_nCurrentDict );
1299 }
1300 }
1301
1302 void HangulHanjaEditDictDialog::InitEditDictDialog( sal_uInt32 nSelDict )
1303 {
1304 if( m_xSuggestions )
1305 m_xSuggestions->Clear();
1306
1307 if( m_nCurrentDict != nSelDict )
1308 {
1309 m_nCurrentDict = nSelDict;
1310 m_aOriginal.clear();
1311 m_bModifiedOriginal = true;
1312 }
1313
1314 UpdateOriginalLB();
1315
1316 m_xOriginalLB->set_entry_text( !m_aOriginal.isEmpty() ? m_aOriginal : m_aEditHintText);
1317 m_xOriginalLB->select_entry_region(0, -1);
1318 m_xOriginalLB->grab_focus();
1319
1320 UpdateSuggestions();
1321 UpdateButtonStates();
1322 }
1323
1324 void HangulHanjaEditDictDialog::UpdateOriginalLB()
1325 {
1326 m_xOriginalLB->clear();
1327 Reference< XConversionDictionary > xDict = m_rDictList[ m_nCurrentDict ];
1328 if( xDict.is() )
1329 {
1330 Sequence< OUString > aEntries = xDict->getConversionEntries( ConversionDirection_FROM_LEFT );
1331 sal_uInt32 n = aEntries.getLength();
1332 OUString* pEntry = aEntries.getArray();
1333 while( n )
1334 {
1335 m_xOriginalLB->append_text( *pEntry );
1336
1337 ++pEntry;
1338 --n;
1339 }
1340 }
1341 else
1342 {
1343 SAL_INFO( "cui.dialogs", "dictionary faded away..." );
1344 }
1345 }
1346
1347 void HangulHanjaEditDictDialog::UpdateButtonStates()
1348 {
1349 bool bHaveValidOriginalString = !m_aOriginal.isEmpty() && m_aOriginal != m_aEditHintText;
1350 bool bNew = bHaveValidOriginalString && m_xSuggestions && m_xSuggestions->GetCount() > 0;
1351 bNew = bNew && ( m_bModifiedSuggestions || m_bModifiedOriginal );
1352
1353 m_xNewPB->set_sensitive( bNew );
1354 m_xDeletePB->set_sensitive(!m_bModifiedOriginal && bHaveValidOriginalString);
1355 }
1356
1357 void HangulHanjaEditDictDialog::UpdateSuggestions()
1358 {
1359 Sequence< OUString > aEntries;
1360 bool bFound = GetConversions( m_rDictList[ m_nCurrentDict ], m_aOriginal, aEntries );
1361 if( bFound )
1362 {
1363 m_bModifiedOriginal = false;
1364
1365 if( m_xSuggestions )
1366 m_xSuggestions->Clear();
1367
1368 //fill found entries into boxes
1369 sal_uInt32 nCnt = aEntries.getLength();
1370 if( nCnt )
1371 {
1372 if( !m_xSuggestions )
1373 m_xSuggestions.reset(new SuggestionList);
1374
1375 const OUString* pSugg = aEntries.getConstArray();
1376 sal_uInt32 n = 0;
1377 while( nCnt )
1378 {
1379 m_xSuggestions->Set( pSugg[ n ], sal_uInt16( n ) );
1380 ++n;
1381 --nCnt;
1382 }
1383 }
1384 m_bModifiedSuggestions = false;
1385 }
1386
1387 m_xScrollSB->vadjustment_set_value( 0 );
1388 UpdateScrollbar(); // will force edits to be filled new
1389 }
1390
1391 void HangulHanjaEditDictDialog::SetEditText(SuggestionEdit& rEdit, sal_uInt16 nEntryNum)
1392 {
1393 OUString aStr;
1394 if( m_xSuggestions )
1395 {
1396 aStr = m_xSuggestions->Get(nEntryNum);
1397 }
1398
1399 rEdit.set_text(aStr);
1400 }
1401
1402 void HangulHanjaEditDictDialog::EditModify(const weld::Entry* pEdit, sal_uInt8 _nEntryOffset)
1403 {
1404 m_bModifiedSuggestions = true;
1405
1406 OUString aTxt( pEdit->get_text() );
1407 sal_uInt16 nEntryNum = m_nTopPos + _nEntryOffset;
1408 if( aTxt.isEmpty() )
1409 {
1410 //reset suggestion
1411 if( m_xSuggestions )
1412 m_xSuggestions->Reset( nEntryNum );
1413 }
1414 else
1415 {
1416 //set suggestion
1417 if( !m_xSuggestions )
1418 m_xSuggestions.reset(new SuggestionList);
1419 m_xSuggestions->Set( aTxt, nEntryNum );
1420 }
1421
1422 UpdateButtonStates();
1423 }
1424
1425 HangulHanjaEditDictDialog::HangulHanjaEditDictDialog(weld::Window* pParent, HHDictList& _rDictList, sal_uInt32 nSelDict)
1426 : GenericDialogController(pParent, "cui/ui/hangulhanjaeditdictdialog.ui", "HangulHanjaEditDictDialog")
1427 , m_aEditHintText ( CuiResId(RID_SVXSTR_EDITHINT) )
1428 , m_rDictList ( _rDictList )
1429 , m_nCurrentDict ( 0xFFFFFFFF )
1430 , m_nTopPos ( 0 )
1431 , m_bModifiedSuggestions ( false )
1432 , m_bModifiedOriginal ( false )
1433 , m_xBookLB(m_xBuilder->weld_combo_box("book"))
1434 , m_xOriginalLB(m_xBuilder->weld_combo_box("original"))
1435 , m_xEdit1(new SuggestionEdit(m_xBuilder->weld_entry("edit1"), this))
1436 , m_xEdit2(new SuggestionEdit(m_xBuilder->weld_entry("edit2"), this))
1437 , m_xEdit3(new SuggestionEdit(m_xBuilder->weld_entry("edit3"), this))
1438 , m_xEdit4(new SuggestionEdit(m_xBuilder->weld_entry("edit4"), this))
1439 , m_xContents(m_xBuilder->weld_widget("box"))
1440 , m_xScrollSB(m_xBuilder->weld_scrolled_window("scrollbar"))
1441 , m_xNewPB(m_xBuilder->weld_button("new"))
1442 , m_xDeletePB(m_xBuilder->weld_button("delete"))
1443 {
1444 m_xScrollSB->set_user_managed_scrolling();
1445
1446 Size aSize(m_xContents->get_preferred_size());
1447 m_xScrollSB->set_size_request(-1, aSize.Height());
1448
1449 m_xEdit1->init( m_xScrollSB.get(), nullptr, m_xEdit2.get() );
1450 m_xEdit2->init( m_xScrollSB.get(), m_xEdit1.get(), m_xEdit3.get() );
1451 m_xEdit3->init( m_xScrollSB.get(), m_xEdit2.get(), m_xEdit4.get() );
1452 m_xEdit4->init( m_xScrollSB.get(), m_xEdit3.get(), nullptr );
1453
1454 m_xOriginalLB->connect_changed( LINK( this, HangulHanjaEditDictDialog, OriginalModifyHdl ) );
1455
1456 m_xNewPB->connect_clicked( LINK( this, HangulHanjaEditDictDialog, NewPBPushHdl ) );
1457 m_xNewPB->set_sensitive( false );
1458
1459 m_xDeletePB->connect_clicked( LINK( this, HangulHanjaEditDictDialog, DeletePBPushHdl ) );
1460 m_xDeletePB->set_sensitive( false );
1461
1462 static_assert(MAXNUM_SUGGESTIONS >= 5, "number of suggestions should not under-run the value of 5");
1463
1464 // 4 here, because we have 4 edits / page
1465 m_xScrollSB->vadjustment_configure(0, 0, MAXNUM_SUGGESTIONS, 1, 4, 4);
1466 m_xScrollSB->connect_vadjustment_changed(LINK(this, HangulHanjaEditDictDialog, ScrollHdl));
1467
1468 m_xEdit1->connect_changed( LINK( this, HangulHanjaEditDictDialog, EditModifyHdl1 ) );
1469 m_xEdit2->connect_changed( LINK( this, HangulHanjaEditDictDialog, EditModifyHdl2 ) );
1470 m_xEdit3->connect_changed( LINK( this, HangulHanjaEditDictDialog, EditModifyHdl3 ) );
1471 m_xEdit4->connect_changed( LINK( this, HangulHanjaEditDictDialog, EditModifyHdl4 ) );
1472
1473 m_xBookLB->connect_changed( LINK( this, HangulHanjaEditDictDialog, BookLBSelectHdl ) );
1474 sal_uInt32 nDictCnt = m_rDictList.size();
1475 for( sal_uInt32 n = 0 ; n < nDictCnt ; ++n )
1476 {
1477 Reference< XConversionDictionary > xDic( m_rDictList[n] );
1478 OUString aName;
1479 if( xDic.is() )
1480 aName = xDic->getName();
1481 m_xBookLB->append_text( aName );
1482 }
1483 m_xBookLB->set_active(nSelDict);
1484
1485 InitEditDictDialog(nSelDict);
1486 }
1487
1488 HangulHanjaEditDictDialog::~HangulHanjaEditDictDialog()
1489 {
1490 }
1491
1492 void HangulHanjaEditDictDialog::UpdateScrollbar()
1493 {
1494 sal_uInt16 nPos = m_xScrollSB->vadjustment_get_value();
1495 m_nTopPos = nPos;
1496
1497 SetEditText( *m_xEdit1, nPos++ );
1498 SetEditText( *m_xEdit2, nPos++ );
1499 SetEditText( *m_xEdit3, nPos++ );
1500 SetEditText( *m_xEdit4, nPos );
1501 }
1502 }
1503
1504 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE