From ed5640d8b587fbcfed7dd7967f3de04b37a76f26 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 11:06:44 +0200 Subject: Adding upstream version 4:7.4.7. Signed-off-by: Daniel Baumann --- .../chinese_dictionarydialog.cxx | 676 +++++++++++++++++++++ .../chinese_dictionarydialog.hxx | 168 +++++ .../chinese_translation_unodialog.cxx | 227 +++++++ .../chinese_translation_unodialog.hxx | 119 ++++ .../chinese_translationdialog.cxx | 97 +++ .../chinese_translationdialog.hxx | 51 ++ 6 files changed, 1338 insertions(+) create mode 100644 svx/source/unodialogs/textconversiondlgs/chinese_dictionarydialog.cxx create mode 100644 svx/source/unodialogs/textconversiondlgs/chinese_dictionarydialog.hxx create mode 100644 svx/source/unodialogs/textconversiondlgs/chinese_translation_unodialog.cxx create mode 100644 svx/source/unodialogs/textconversiondlgs/chinese_translation_unodialog.hxx create mode 100644 svx/source/unodialogs/textconversiondlgs/chinese_translationdialog.cxx create mode 100644 svx/source/unodialogs/textconversiondlgs/chinese_translationdialog.hxx (limited to 'svx/source/unodialogs/textconversiondlgs') diff --git a/svx/source/unodialogs/textconversiondlgs/chinese_dictionarydialog.cxx b/svx/source/unodialogs/textconversiondlgs/chinese_dictionarydialog.cxx new file mode 100644 index 000000000..ed81ba92f --- /dev/null +++ b/svx/source/unodialogs/textconversiondlgs/chinese_dictionarydialog.cxx @@ -0,0 +1,676 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + + +#include "chinese_dictionarydialog.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace textconversiondlgs +{ + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; + +DictionaryList::DictionaryList(std::unique_ptr xControl) + : m_xControl(std::move(xControl)) + , m_xIter(m_xControl->make_iterator()) + , m_pED_Term(nullptr) + , m_pED_Mapping(nullptr) + , m_pLB_Property(nullptr) +{ + m_xControl->make_sorted(); +} + +OUString DictionaryList::getPropertyTypeName( sal_Int16 nConversionPropertyType ) const +{ + if (!m_pLB_Property || !m_pLB_Property->get_count()) + return OUString(); + + sal_uInt16 nPos = static_cast( nConversionPropertyType )-1; + if (nPos < m_pLB_Property->get_count()) + return m_pLB_Property->get_text(nPos); + return m_pLB_Property->get_text(0); +} + +void DictionaryList::save() +{ + if (!m_xDictionary.is()) + return; + + Reference< linguistic2::XConversionPropertyType > xPropertyType( m_xDictionary, uno::UNO_QUERY ); + + sal_Int32 nN; + DictionaryEntry* pE; + + for( nN = m_aToBeDeleted.size(); nN--; ) + { + pE = m_aToBeDeleted[nN]; + m_xDictionary->removeEntry( pE->m_aTerm, pE->m_aMapping ); + } + int nRowCount = m_xControl->n_children(); + for( nN = nRowCount; nN--; ) + { + pE = getEntryOnPos( nN ); + if(pE->m_bNewEntry) + { + try + { + m_xDictionary->addEntry( pE->m_aTerm, pE->m_aMapping ); + xPropertyType->setPropertyType( pE->m_aTerm, pE->m_aMapping, pE->m_nConversionPropertyType ); + } + catch( uno::Exception& ) + { + + } + } + } + Reference< util::XFlushable > xFlush( m_xDictionary, uno::UNO_QUERY ); + if( xFlush.is() ) + xFlush->flush(); +} + +void DictionaryList::deleteAll() +{ + sal_Int32 nN; + int nRowCount = m_xControl->n_children(); + for( nN = nRowCount; nN--; ) + deleteEntryOnPos( nN ); + for( nN = m_aToBeDeleted.size(); nN--; ) + { + DictionaryEntry* pE = m_aToBeDeleted[nN]; + delete pE; + } + m_aToBeDeleted.clear(); +} + +void DictionaryList::refillFromDictionary( sal_Int32 nTextConversionOptions ) +{ + deleteAll(); + + if(!m_xDictionary.is()) + return; + + const Sequence< OUString > aLeftList( m_xDictionary->getConversionEntries( linguistic2::ConversionDirection_FROM_LEFT ) ); + + Reference< linguistic2::XConversionPropertyType > xPropertyType( m_xDictionary, uno::UNO_QUERY ); + + OUString aRight; + sal_Int16 nConversionPropertyType; + + for(const OUString& aLeft : aLeftList) + { + Sequence< OUString > aRightList( m_xDictionary->getConversions( + aLeft, 0, aLeft.getLength() + , linguistic2::ConversionDirection_FROM_LEFT, nTextConversionOptions ) ); + + if(aRightList.getLength()!=1) + { + OSL_FAIL("The Chinese Translation Dictionary should have exactly one Mapping for each term."); + continue; + } + + aRight = aRightList[0]; + nConversionPropertyType = linguistic2::ConversionPropertyType::OTHER; + if(xPropertyType.is()) + nConversionPropertyType = xPropertyType->getPropertyType(aLeft, aRight); + + DictionaryEntry* pEntry = new DictionaryEntry( aLeft, aRight, nConversionPropertyType ); + + m_xControl->append(m_xIter.get()); + m_xControl->set_text(*m_xIter, pEntry->m_aTerm, 0); + m_xControl->set_text(*m_xIter, pEntry->m_aMapping, 1); + m_xControl->set_text(*m_xIter, getPropertyTypeName(pEntry->m_nConversionPropertyType), 2); + m_xControl->set_id(*m_xIter, weld::toId(pEntry)); + } +} + +DictionaryEntry* DictionaryList::getFirstSelectedEntry() const +{ + DictionaryEntry* pRet=nullptr; + int nN = m_xControl->get_selected_index(); + if (nN != -1) + pRet = getEntryOnPos( nN ); + return pRet; +} + +DictionaryEntry* DictionaryList::getEntryOnPos(sal_Int32 nPos) const +{ + OUString sLBEntry = m_xControl->get_id(nPos); + return weld::fromId(sLBEntry); +} + +DictionaryEntry* DictionaryList::getTermEntry( std::u16string_view rTerm ) const +{ + int nRowCount = m_xControl->n_children(); + for( sal_Int32 nN = nRowCount; nN--; ) + { + DictionaryEntry* pE = getEntryOnPos( nN ); + if( pE && rTerm == pE->m_aTerm ) + return pE; + } + return nullptr; +} + +bool DictionaryList::hasTerm( std::u16string_view rTerm ) const +{ + return getTermEntry(rTerm) !=nullptr ; +} + +void DictionaryList::addEntry(const OUString& rTerm, const OUString& rMapping, + sal_Int16 nConversionPropertyType, int nPos) +{ + if( hasTerm( rTerm ) ) + return; + + DictionaryEntry* pEntry = new DictionaryEntry( rTerm, rMapping, nConversionPropertyType, true ); + m_xControl->insert(nPos, m_xIter.get()); + m_xControl->set_text(*m_xIter, pEntry->m_aTerm, 0); + m_xControl->set_text(*m_xIter, pEntry->m_aMapping, 1); + m_xControl->set_text(*m_xIter, getPropertyTypeName(pEntry->m_nConversionPropertyType), 2); + m_xControl->set_id(*m_xIter, weld::toId(pEntry)); + m_xControl->select(*m_xIter); +} + +void DictionaryList::deleteEntryOnPos( sal_Int32 nPos ) +{ + DictionaryEntry* pEntry = getEntryOnPos( nPos ); + m_xControl->remove(nPos); + if (pEntry) + { + if( pEntry->m_bNewEntry ) + delete pEntry; + else + m_aToBeDeleted.push_back( pEntry ); + } +} + +int DictionaryList::deleteEntries( std::u16string_view rTerm ) +{ + int nPos = -1; + int nRowCount = m_xControl->n_children(); + for (sal_Int32 nN = nRowCount; nN--;) + { + DictionaryEntry* pCurEntry = getEntryOnPos( nN ); + if( rTerm == pCurEntry->m_aTerm ) + { + nPos = nN; + m_xControl->remove(nN); + if( pCurEntry->m_bNewEntry ) + delete pCurEntry; + else + m_aToBeDeleted.push_back( pCurEntry ); + } + } + return nPos; +} + +DictionaryEntry::DictionaryEntry( const OUString& rTerm, const OUString& rMapping + , sal_Int16 nConversionPropertyType + , bool bNewEntry ) + : m_aTerm( rTerm ) + , m_aMapping( rMapping ) + , m_nConversionPropertyType( nConversionPropertyType ) + , m_bNewEntry( bNewEntry ) +{ + if( m_nConversionPropertyType == 0 ) + m_nConversionPropertyType = 1; +} + +DictionaryEntry::~DictionaryEntry() +{ +} + +IMPL_LINK_NOARG(ChineseDictionaryDialog, SizeAllocHdl, const Size&, void) +{ + DictionaryList* pControl = m_xCT_DictionaryToTraditional->get_visible() ? + m_xCT_DictionaryToTraditional.get() : + m_xCT_DictionaryToSimplified.get(); + std::vector aWidths; + int x1, x2, y, width, height; + if (!m_xED_Mapping->get_extents_relative_to(pControl->get_widget(), x1, y, width, height)) + return; + aWidths.push_back(x1); + if (!m_xLB_Property->get_extents_relative_to(pControl->get_widget(), x2, y, width, height)) + return; + aWidths.push_back(x2 - x1); + m_xCT_DictionaryToTraditional->get_widget().set_column_fixed_widths(aWidths); + m_xCT_DictionaryToSimplified->get_widget().set_column_fixed_widths(aWidths); +} + +void DictionaryList::init(const Reference< linguistic2::XConversionDictionary>& xDictionary, + weld::Entry *pED_Term, weld::Entry *pED_Mapping, weld::ComboBox *pLB_Property) +{ + if (m_xDictionary.is()) + return; + + m_xDictionary = xDictionary; + + m_pED_Term = pED_Term; + m_pED_Mapping = pED_Mapping; + m_pLB_Property = pLB_Property; + + m_xControl->set_sort_column(0); + m_xControl->set_sort_indicator(TRISTATE_TRUE, 0); + + std::vector aWidths + { + o3tl::narrowing(m_pED_Term->get_preferred_size().Width()), + o3tl::narrowing(m_pED_Mapping->get_preferred_size().Width()) + }; + m_xControl->set_column_fixed_widths(aWidths); +} + +void ChineseDictionaryDialog::initDictionaryControl(DictionaryList *pList, + const Reference< linguistic2::XConversionDictionary>& xDictionary) +{ + //set widgets to track the width of for columns + pList->init(xDictionary, + m_xED_Term.get(), m_xED_Mapping.get(), m_xLB_Property.get()); +} + +ChineseDictionaryDialog::ChineseDictionaryDialog(weld::Window* pParent) + : GenericDialogController(pParent, "svx/ui/chinesedictionary.ui", "ChineseDictionaryDialog") + , m_nTextConversionOptions(i18n::TextConversionOption::NONE) + , m_xRB_To_Simplified(m_xBuilder->weld_radio_button("tradtosimple")) + , m_xRB_To_Traditional(m_xBuilder->weld_radio_button("simpletotrad")) + , m_xCB_Reverse(m_xBuilder->weld_check_button("reverse")) + , m_xFT_Term(m_xBuilder->weld_label("termft")) + , m_xED_Term(m_xBuilder->weld_entry("term")) + , m_xFT_Mapping(m_xBuilder->weld_label("mappingft")) + , m_xED_Mapping(m_xBuilder->weld_entry("mapping")) + , m_xFT_Property(m_xBuilder->weld_label("propertyft")) + , m_xLB_Property(m_xBuilder->weld_combo_box("property")) + , m_xCT_DictionaryToSimplified(new DictionaryList(m_xBuilder->weld_tree_view("tradtosimpleview"))) + , m_xCT_DictionaryToTraditional(new DictionaryList(m_xBuilder->weld_tree_view("simpletotradview"))) + , m_xPB_Add(m_xBuilder->weld_button("add")) + , m_xPB_Modify(m_xBuilder->weld_button("modify")) + , m_xPB_Delete(m_xBuilder->weld_button("delete")) +{ + m_xCT_DictionaryToSimplified->set_size_request(-1, m_xCT_DictionaryToSimplified->get_height_rows(8)); + m_xCT_DictionaryToTraditional->set_size_request(-1, m_xCT_DictionaryToTraditional->get_height_rows(8)); + + SvtLinguConfig aLngCfg; + bool bValue; + Any aAny( aLngCfg.GetProperty( UPN_IS_REVERSE_MAPPING ) ); + if( aAny >>= bValue ) + m_xCB_Reverse->set_active( bValue ); + + m_xLB_Property->set_active(0); + + Reference< linguistic2::XConversionDictionary > xDictionary_To_Simplified; + Reference< linguistic2::XConversionDictionary > xDictionary_To_Traditional; + //get dictionaries + { + if(!m_xContext.is()) + m_xContext.set( ::cppu::defaultBootstrap_InitialComponentContext() ); + if(m_xContext.is()) + { + Reference< linguistic2::XConversionDictionaryList > xDictionaryList = linguistic2::ConversionDictionaryList::create(m_xContext); + Reference< container::XNameContainer > xContainer( xDictionaryList->getDictionaryContainer() ); + if(xContainer.is()) + { + try + { + OUString aNameTo_Simplified("ChineseT2S"); + OUString aNameTo_Traditional("ChineseS2T"); + lang::Locale aLocale; + aLocale.Language = "zh"; + + if( xContainer->hasByName( aNameTo_Simplified ) ) + xDictionary_To_Simplified.set( + xContainer->getByName( aNameTo_Simplified ), UNO_QUERY ); + else + { + aLocale.Country = "TW"; + xDictionary_To_Simplified = + xDictionaryList->addNewDictionary( aNameTo_Simplified + , aLocale, linguistic2::ConversionDictionaryType::SCHINESE_TCHINESE + ); + } + if (xDictionary_To_Simplified.is()) + xDictionary_To_Simplified->setActive( true ); + + + if( xContainer->hasByName( aNameTo_Traditional ) ) + xDictionary_To_Traditional.set( + xContainer->getByName( aNameTo_Traditional ), UNO_QUERY ); + else + { + aLocale.Country = "CN"; + xDictionary_To_Traditional = + xDictionaryList->addNewDictionary( aNameTo_Traditional + ,aLocale, linguistic2::ConversionDictionaryType::SCHINESE_TCHINESE); + } + if (xDictionary_To_Traditional.is()) + xDictionary_To_Traditional->setActive( true ); + + } + catch(const uno::Exception& ) + { + } + } + } + } + + //init dictionary controls + initDictionaryControl(m_xCT_DictionaryToSimplified.get(), xDictionary_To_Simplified); + initDictionaryControl(m_xCT_DictionaryToTraditional.get(), xDictionary_To_Traditional); + + //set hdl + m_xCT_DictionaryToSimplified->connect_column_clicked(LINK(this, ChineseDictionaryDialog, ToSimplifiedHeaderBarClick)); + m_xCT_DictionaryToTraditional->connect_column_clicked(LINK(this, ChineseDictionaryDialog, ToTraditionalHeaderBarClick)); + + updateAfterDirectionChange(); + + m_xED_Term->connect_changed( LINK( this, ChineseDictionaryDialog, EditFieldsHdl ) ); + m_xED_Mapping->connect_changed( LINK( this, ChineseDictionaryDialog, EditFieldsHdl ) ); + m_xLB_Property->connect_changed( LINK( this, ChineseDictionaryDialog, EditFieldsListBoxHdl ) ); + + m_xRB_To_Simplified->connect_toggled( LINK( this, ChineseDictionaryDialog, DirectionHdl ) ); + + m_xCT_DictionaryToSimplified->connect_changed( LINK( this, ChineseDictionaryDialog, MappingSelectHdl )); + m_xCT_DictionaryToTraditional->connect_changed( LINK( this, ChineseDictionaryDialog, MappingSelectHdl )); + + m_xPB_Add->connect_clicked( LINK( this, ChineseDictionaryDialog, AddHdl ) ); + m_xPB_Modify->connect_clicked( LINK( this, ChineseDictionaryDialog, ModifyHdl ) ); + m_xPB_Delete->connect_clicked( LINK( this, ChineseDictionaryDialog, DeleteHdl ) ); + + m_xED_Mapping->connect_size_allocate(LINK(this, ChineseDictionaryDialog, SizeAllocHdl)); + m_xLB_Property->connect_size_allocate(LINK(this, ChineseDictionaryDialog, SizeAllocHdl)); +} + +ChineseDictionaryDialog::~ChineseDictionaryDialog() +{ +} + +void ChineseDictionaryDialog::setDirectionAndTextConversionOptions( bool bDirectionToSimplified, sal_Int32 nTextConversionOptions /*i18n::TextConversionOption*/ ) +{ + if( bDirectionToSimplified == m_xRB_To_Simplified->get_active() + && nTextConversionOptions == m_nTextConversionOptions ) + return; + + m_nTextConversionOptions = nTextConversionOptions; + + if (bDirectionToSimplified) + m_xRB_To_Simplified->set_active(true); + else + m_xRB_To_Traditional->set_active(true); + updateAfterDirectionChange(); +} + +IMPL_LINK_NOARG(ChineseDictionaryDialog, DirectionHdl, weld::Toggleable&, void) +{ + updateAfterDirectionChange(); +} + +void ChineseDictionaryDialog::updateAfterDirectionChange() +{ + Reference< linguistic2::XConversionDictionary > xDictionary; + + if (m_xRB_To_Simplified->get_active()) + { + m_xCT_DictionaryToTraditional->hide(); + m_xCT_DictionaryToSimplified->show(); + xDictionary = m_xCT_DictionaryToSimplified->m_xDictionary; + } + else + { + m_xCT_DictionaryToSimplified->hide(); + m_xCT_DictionaryToTraditional->show(); + xDictionary = m_xCT_DictionaryToTraditional->m_xDictionary; + } + + updateButtons(); +} + +IMPL_LINK_NOARG(ChineseDictionaryDialog, EditFieldsListBoxHdl, weld::ComboBox&, void) +{ + updateButtons(); +} + +IMPL_LINK_NOARG(ChineseDictionaryDialog, EditFieldsHdl, weld::Entry&, void) +{ + updateButtons(); +} + +IMPL_LINK_NOARG(ChineseDictionaryDialog, MappingSelectHdl, weld::TreeView&, void) +{ + DictionaryEntry* pE = getActiveDictionary().getFirstSelectedEntry(); + if (pE) + { + m_xED_Term->set_text( pE->m_aTerm ); + m_xED_Mapping->set_text( pE->m_aMapping ); + sal_Int16 nPos = pE->m_nConversionPropertyType-1; + if (nPos<0 || nPos>=m_xLB_Property->get_count()) + nPos=0; + if (m_xLB_Property->get_count()) + m_xLB_Property->set_active(nPos); + } + + updateButtons(); +} + +bool ChineseDictionaryDialog::isEditFieldsHaveContent() const +{ + return !m_xED_Term->get_text().isEmpty() && !m_xED_Mapping->get_text().isEmpty(); +} + +bool ChineseDictionaryDialog::isEditFieldsContentEqualsSelectedListContent() const +{ + DictionaryEntry* pE = getActiveDictionary().getFirstSelectedEntry(); + if( pE ) + { + if (pE->m_aTerm != m_xED_Term->get_text()) + return false; + if (pE->m_aMapping != m_xED_Mapping->get_text()) + return false; + if (pE->m_nConversionPropertyType != m_xLB_Property->get_active() + 1) + return false; + return true; + } + return false; +} + +const DictionaryList& ChineseDictionaryDialog::getActiveDictionary() const +{ + if( m_xRB_To_Traditional->get_active() ) + return *m_xCT_DictionaryToTraditional; + return *m_xCT_DictionaryToSimplified; +} + +DictionaryList& ChineseDictionaryDialog::getActiveDictionary() +{ + if( m_xRB_To_Traditional->get_active() ) + return *m_xCT_DictionaryToTraditional; + return *m_xCT_DictionaryToSimplified; +} + +const DictionaryList& ChineseDictionaryDialog::getReverseDictionary() const +{ + if( m_xRB_To_Traditional->get_active() ) + return *m_xCT_DictionaryToSimplified; + return *m_xCT_DictionaryToTraditional; +} + +DictionaryList& ChineseDictionaryDialog::getReverseDictionary() +{ + if( m_xRB_To_Traditional->get_active() ) + return *m_xCT_DictionaryToSimplified; + return *m_xCT_DictionaryToTraditional; +} + +void ChineseDictionaryDialog::updateButtons() +{ + bool bAdd = isEditFieldsHaveContent() && !getActiveDictionary().hasTerm(m_xED_Term->get_text()); + m_xPB_Add->set_sensitive( bAdd ); + + m_xPB_Delete->set_sensitive(!bAdd && getActiveDictionary().get_selected_index() != -1); + + bool bModify = false; + { + DictionaryEntry* pFirstSelectedEntry = getActiveDictionary().getFirstSelectedEntry(); + bModify = !bAdd && pFirstSelectedEntry && pFirstSelectedEntry->m_aTerm == m_xED_Term->get_text(); + if( bModify && isEditFieldsContentEqualsSelectedListContent() ) + bModify = false; + } + m_xPB_Modify->set_sensitive( bModify ); +} + +IMPL_LINK_NOARG(ChineseDictionaryDialog, AddHdl, weld::Button&, void) +{ + if( !isEditFieldsHaveContent() ) + return; + + sal_Int16 nConversionPropertyType = m_xLB_Property->get_active() + 1; + + getActiveDictionary().addEntry( m_xED_Term->get_text(), m_xED_Mapping->get_text(), nConversionPropertyType ); + + if( m_xCB_Reverse->get_active() ) + { + getReverseDictionary().deleteEntries( m_xED_Mapping->get_text() ); + getReverseDictionary().addEntry( m_xED_Mapping->get_text(), m_xED_Term->get_text(), nConversionPropertyType ); + } + + updateButtons(); +} + +IMPL_LINK_NOARG(ChineseDictionaryDialog, ModifyHdl, weld::Button&, void) +{ + OUString aTerm( m_xED_Term->get_text() ); + OUString aMapping( m_xED_Mapping->get_text() ); + sal_Int16 nConversionPropertyType = m_xLB_Property->get_active() + 1; + + DictionaryList& rActive = getActiveDictionary(); + DictionaryList& rReverse = getReverseDictionary(); + + DictionaryEntry* pE = rActive.getFirstSelectedEntry(); + if( pE && pE->m_aTerm != aTerm ) + return; + + if( pE ) + { + if( pE->m_aMapping != aMapping || pE->m_nConversionPropertyType != nConversionPropertyType ) + { + if( m_xCB_Reverse->get_active() ) + { + rReverse.deleteEntries( pE->m_aMapping ); + int nPos = rReverse.deleteEntries( aMapping ); + rReverse.addEntry( aMapping, aTerm, nConversionPropertyType, nPos ); + } + + int nPos = rActive.deleteEntries( aTerm ); + rActive.addEntry( aTerm, aMapping, nConversionPropertyType, nPos ); + } + } + + updateButtons(); +} + +IMPL_LINK_NOARG(ChineseDictionaryDialog, DeleteHdl, weld::Button&, void) +{ + DictionaryList& rActive = getActiveDictionary(); + DictionaryList& rReverse = getReverseDictionary(); + + int nEntry = rActive.get_selected_index(); + if (nEntry != -1) + { + DictionaryEntry* pEntry = rActive.getEntryOnPos(nEntry); + if (pEntry) + { + OUString aMapping = pEntry->m_aMapping; + rActive.deleteEntryOnPos(nEntry); + if (m_xCB_Reverse->get_active()) + rReverse.deleteEntries(aMapping); + } + } + + updateButtons(); +} + +short ChineseDictionaryDialog::run() +{ + sal_Int32 nTextConversionOptions = m_nTextConversionOptions; + if(m_nTextConversionOptions & i18n::TextConversionOption::USE_CHARACTER_VARIANTS ) + nTextConversionOptions = nTextConversionOptions^i18n::TextConversionOption::USE_CHARACTER_VARIANTS ; + + m_xCT_DictionaryToSimplified->refillFromDictionary( nTextConversionOptions ); + m_xCT_DictionaryToTraditional->refillFromDictionary( m_nTextConversionOptions ); + + short nRet = GenericDialogController::run(); + + if( nRet == RET_OK ) + { + //save settings to configuration + SvtLinguConfig aLngCfg; + aLngCfg.SetProperty( UPN_IS_REVERSE_MAPPING, uno::Any(m_xCB_Reverse->get_active()) ); + + m_xCT_DictionaryToSimplified->save(); + m_xCT_DictionaryToTraditional->save(); + } + + m_xCT_DictionaryToSimplified->deleteAll(); + m_xCT_DictionaryToTraditional->deleteAll(); + + return nRet; +} + +void ChineseDictionaryDialog::HeaderBarClick(DictionaryList& rList, int nColumn) +{ + bool bSortAtoZ = rList.get_sort_order(); + + //set new arrow positions in headerbar + if (nColumn == rList.get_sort_column()) + { + bSortAtoZ = !bSortAtoZ; + rList.set_sort_order(bSortAtoZ); + } + else + { + rList.set_sort_indicator(TRISTATE_INDET, rList.get_sort_column()); + rList.set_sort_column(nColumn); + } + + //sort lists + rList.set_sort_indicator(bSortAtoZ ? TRISTATE_TRUE : TRISTATE_FALSE, nColumn); +} + +IMPL_LINK(ChineseDictionaryDialog, ToSimplifiedHeaderBarClick, int, nColumn, void) +{ + HeaderBarClick(*m_xCT_DictionaryToSimplified, nColumn); +} + +IMPL_LINK(ChineseDictionaryDialog, ToTraditionalHeaderBarClick, int, nColumn, void) +{ + HeaderBarClick(*m_xCT_DictionaryToTraditional, nColumn); +} + +} //end namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/unodialogs/textconversiondlgs/chinese_dictionarydialog.hxx b/svx/source/unodialogs/textconversiondlgs/chinese_dictionarydialog.hxx new file mode 100644 index 000000000..0213c53da --- /dev/null +++ b/svx/source/unodialogs/textconversiondlgs/chinese_dictionarydialog.hxx @@ -0,0 +1,168 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#pragma once + +#include +#include +#include + +#include + +namespace textconversiondlgs +{ + +struct DictionaryEntry final +{ + DictionaryEntry( const OUString& rTerm, const OUString& rMapping + , sal_Int16 nConversionPropertyType //linguistic2::ConversionPropertyType + , bool bNewEntry = false ); + + ~DictionaryEntry(); + + OUString m_aTerm; + OUString m_aMapping; + sal_Int16 m_nConversionPropertyType; //linguistic2::ConversionPropertyType + + bool m_bNewEntry; +}; + +class DictionaryList +{ +public: + DictionaryList(std::unique_ptr xTreeView); + + void init(const css::uno::Reference< css::linguistic2::XConversionDictionary>& xDictionary, + weld::Entry *pED_Term, weld::Entry *pED_Mapping, weld::ComboBox *pLB_Property); + + void deleteAll(); + void refillFromDictionary( sal_Int32 nTextConversionOptions /*i18n::TextConversionOption*/ ); + void save(); + + DictionaryEntry* getTermEntry( std::u16string_view rTerm ) const; + bool hasTerm( std::u16string_view rTerm ) const; + + void addEntry( const OUString& rTerm, const OUString& rMapping + , sal_Int16 nConversionPropertyType /*linguistic2::ConversionPropertyType*/, int nPos = -1); + int deleteEntries( std::u16string_view rTerm ); //return lowest position of deleted entries or -1 if no entry was deleted + void deleteEntryOnPos( sal_Int32 nPos ); + DictionaryEntry* getEntryOnPos( sal_Int32 nPos ) const; + DictionaryEntry* getFirstSelectedEntry() const; + + void set_size_request(int nWidth, int nHeight) { m_xControl->set_size_request(nWidth, nHeight); } + void hide() { m_xControl->hide(); } + void show() { m_xControl->show(); } + void connect_changed(const Link& rLink) { m_xControl->connect_changed(rLink); } + void connect_column_clicked(const Link& rLink) { m_xControl->connect_column_clicked(rLink); } + bool get_sort_order() const { return m_xControl->get_sort_order(); } + void set_sort_order(bool bAscending) { return m_xControl->set_sort_order(bAscending); } + void set_sort_column(int nColumn) { return m_xControl->set_sort_column(nColumn); } + int get_sort_column() const { return m_xControl->get_sort_column(); } + int get_selected_index() const { return m_xControl->get_selected_index(); } + int get_height_rows(int nRows) const { return m_xControl->get_height_rows(nRows); } + bool get_visible() const { return m_xControl->get_visible(); } + void set_sort_indicator(TriState eState, int nColumn) { m_xControl->set_sort_indicator(eState, nColumn); } + weld::TreeView& get_widget() const { return *m_xControl; } + +private: + OUString getPropertyTypeName( sal_Int16 nConversionPropertyType /*linguistic2::ConversionPropertyType*/ ) const; + +public: + css::uno::Reference m_xDictionary; + +private: + std::unique_ptr m_xControl; + std::unique_ptr m_xIter; + weld::Entry* m_pED_Term; + weld::Entry* m_pED_Mapping; + weld::ComboBox* m_pLB_Property; + + std::vector< DictionaryEntry* > m_aToBeDeleted; +}; + +class ChineseDictionaryDialog : public weld::GenericDialogController +{ +public: + explicit ChineseDictionaryDialog(weld::Window* pParent); + virtual ~ChineseDictionaryDialog() override; + + //this method should be called once before calling execute + void setDirectionAndTextConversionOptions( bool bDirectionToSimplified, sal_Int32 nTextConversionOptions /*i18n::TextConversionOption*/ ); + + virtual short run() override; + +private: + DECL_LINK( DirectionHdl, weld::Toggleable&, void ); + DECL_LINK( EditFieldsHdl, weld::Entry&, void ); + DECL_LINK( EditFieldsListBoxHdl, weld::ComboBox&, void ); + DECL_LINK( MappingSelectHdl, weld::TreeView&, void ); + DECL_LINK( AddHdl, weld::Button&, void ); + DECL_LINK( ModifyHdl, weld::Button&, void ); + DECL_LINK( DeleteHdl, weld::Button&, void ); + static void HeaderBarClick(DictionaryList& rList, int nColumn); + DECL_LINK(ToSimplifiedHeaderBarClick, int, void); + DECL_LINK(ToTraditionalHeaderBarClick, int, void); + DECL_LINK(SizeAllocHdl, const Size&, void); + + void initDictionaryControl(DictionaryList *pList, + const css::uno::Reference< css::linguistic2::XConversionDictionary>& xDictionary); + + void updateAfterDirectionChange(); + void updateButtons(); + + bool isEditFieldsHaveContent() const; + bool isEditFieldsContentEqualsSelectedListContent() const; + + DictionaryList& getActiveDictionary(); + DictionaryList& getReverseDictionary(); + + const DictionaryList& getActiveDictionary() const; + const DictionaryList& getReverseDictionary() const; + +private: + sal_Int32 m_nTextConversionOptions; //i18n::TextConversionOption + + css::uno::Reference m_xContext; + + std::unique_ptr m_xRB_To_Simplified; + std::unique_ptr m_xRB_To_Traditional; + + std::unique_ptr m_xCB_Reverse; + + std::unique_ptr m_xFT_Term; + std::unique_ptr m_xED_Term; + + std::unique_ptr m_xFT_Mapping; + std::unique_ptr m_xED_Mapping; + + std::unique_ptr m_xFT_Property; + std::unique_ptr m_xLB_Property; + + std::unique_ptr m_xCT_DictionaryToSimplified; + std::unique_ptr m_xCT_DictionaryToTraditional; + + std::unique_ptr m_xPB_Add; + std::unique_ptr m_xPB_Modify; + std::unique_ptr m_xPB_Delete; +}; + + +} //end namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/unodialogs/textconversiondlgs/chinese_translation_unodialog.cxx b/svx/source/unodialogs/textconversiondlgs/chinese_translation_unodialog.cxx new file mode 100644 index 000000000..466a4efca --- /dev/null +++ b/svx/source/unodialogs/textconversiondlgs/chinese_translation_unodialog.cxx @@ -0,0 +1,227 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + + +#include "chinese_translation_unodialog.hxx" +#include "chinese_translationdialog.hxx" +#include +#include +#include +#include + +namespace textconversiondlgs +{ +using namespace ::com::sun::star; + +ChineseTranslation_UnoDialog::ChineseTranslation_UnoDialog() + : m_bDisposed(false) + , m_bInDispose(false) +{ +} + +ChineseTranslation_UnoDialog::~ChineseTranslation_UnoDialog() +{ + SolarMutexGuard aSolarGuard; + impl_DeleteDialog(); +} + +void ChineseTranslation_UnoDialog::impl_DeleteDialog() +{ + if (m_xDialog) + { + m_xDialog->response(RET_CANCEL); + m_xDialog.reset(); + } +} + +// lang::XServiceInfo +OUString SAL_CALL ChineseTranslation_UnoDialog::getImplementationName() +{ + return "com.sun.star.comp.linguistic2.ChineseTranslationDialog"; +} + +sal_Bool SAL_CALL ChineseTranslation_UnoDialog::supportsService( const OUString& ServiceName ) +{ + return cppu::supportsService(this, ServiceName); +} + +uno::Sequence< OUString > SAL_CALL ChineseTranslation_UnoDialog::getSupportedServiceNames() +{ + return { "com.sun.star.linguistic2.ChineseTranslationDialog" }; +} + +// ui::dialogs::XExecutableDialog +void SAL_CALL ChineseTranslation_UnoDialog::setTitle( const OUString& ) +{ + //not implemented - fell free to do so, if you do need this +} + + +void SAL_CALL ChineseTranslation_UnoDialog::initialize( const uno::Sequence< uno::Any >& aArguments ) +{ + SolarMutexGuard aSolarGuard; + if( m_bDisposed || m_bInDispose ) + return; + + for(const uno::Any& rArgument : aArguments) + { + beans::PropertyValue aProperty; + if(rArgument >>= aProperty) + { + if( aProperty.Name == "ParentWindow" ) + { + aProperty.Value >>= m_xParentWindow; + } + } + } +} + +sal_Int16 SAL_CALL ChineseTranslation_UnoDialog::execute() +{ + sal_Int16 nRet = ui::dialogs::ExecutableDialogResults::CANCEL; + { + SolarMutexGuard aSolarGuard; + if (m_bDisposed || m_bInDispose) + return nRet; + if (!m_xDialog) + m_xDialog.reset(new ChineseTranslationDialog(Application::GetFrameWeld(m_xParentWindow))); + nRet = m_xDialog->run(); + if (nRet == RET_OK) + nRet=ui::dialogs::ExecutableDialogResults::OK; + } + return nRet; +} + +// lang::XComponent +void SAL_CALL ChineseTranslation_UnoDialog::dispose() +{ + lang::EventObject aEvt; + { + SolarMutexGuard aSolarGuard; + if( m_bDisposed || m_bInDispose ) + return; + m_bInDispose = true; + + impl_DeleteDialog(); + m_xParentWindow = nullptr; + m_bDisposed = true; + + aEvt.Source = static_cast< XComponent * >( this ); + } + std::unique_lock aGuard(m_aContainerMutex); + m_aDisposeEventListeners.disposeAndClear( aGuard, aEvt ); +} + +void SAL_CALL ChineseTranslation_UnoDialog::addEventListener( const uno::Reference< lang::XEventListener > & xListener ) +{ + SolarMutexGuard aSolarGuard; + if( m_bDisposed || m_bInDispose ) + return; + std::unique_lock aGuard(m_aContainerMutex); + m_aDisposeEventListeners.addInterface( aGuard, xListener ); +} + +void SAL_CALL ChineseTranslation_UnoDialog::removeEventListener( const uno::Reference< lang::XEventListener > & xListener ) +{ + SolarMutexGuard aSolarGuard; + if( m_bDisposed || m_bInDispose ) + return; + std::unique_lock aGuard(m_aContainerMutex); + m_aDisposeEventListeners.removeInterface( aGuard, xListener ); +} + + +// XPropertySet + +uno::Reference< beans::XPropertySetInfo > SAL_CALL ChineseTranslation_UnoDialog::getPropertySetInfo( ) +{ + return nullptr; +} + +void SAL_CALL ChineseTranslation_UnoDialog::setPropertyValue( const OUString&, const uno::Any& ) +{ + //only read only properties + throw beans::PropertyVetoException(); +} + +uno::Any SAL_CALL ChineseTranslation_UnoDialog::getPropertyValue( const OUString& rPropertyName ) +{ + uno::Any aRet; + + bool bDirectionToSimplified = true; + bool bTranslateCommonTerms = false; + + { + SolarMutexGuard aSolarGuard; + if (m_bDisposed || m_bInDispose || !m_xDialog) + return aRet; + m_xDialog->getSettings(bDirectionToSimplified, bTranslateCommonTerms); + } + + if( rPropertyName == "IsDirectionToSimplified" ) + { + aRet <<= bDirectionToSimplified; + } + else if( rPropertyName == "IsUseCharacterVariants" ) + { + aRet <<= false; + } + else if( rPropertyName == "IsTranslateCommonTerms" ) + { + aRet <<= bTranslateCommonTerms; + } + else + { + throw beans::UnknownPropertyException( rPropertyName, static_cast(this)); + } + return aRet; + +} + +void SAL_CALL ChineseTranslation_UnoDialog::addPropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) +{ + //only not bound properties -> ignore listener +} + +void SAL_CALL ChineseTranslation_UnoDialog::removePropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) +{ + //only not bound properties -> ignore listener +} + +void SAL_CALL ChineseTranslation_UnoDialog::addVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) +{ + //only not bound properties -> ignore listener +} + +void SAL_CALL ChineseTranslation_UnoDialog::removeVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) +{ + //only not bound properties -> ignore listener +} + +} //end namespace + + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* +svx_ChineseTranslation_UnoDialog_get_implementation( + css::uno::XComponentContext* , css::uno::Sequence const&) +{ + return cppu::acquire(new textconversiondlgs::ChineseTranslation_UnoDialog()); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/unodialogs/textconversiondlgs/chinese_translation_unodialog.hxx b/svx/source/unodialogs/textconversiondlgs/chinese_translation_unodialog.hxx new file mode 100644 index 000000000..0d40e1227 --- /dev/null +++ b/svx/source/unodialogs/textconversiondlgs/chinese_translation_unodialog.hxx @@ -0,0 +1,119 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#pragma once + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace textconversiondlgs +{ + + +/** This class provides the chinese translation dialog as a uno component. + +It can be created via lang::XMultiComponentFactory::createInstanceWithContext +with servicename "com.sun.star.linguistic2.ChineseTranslationDialog" +or implementation name "com.sun.star.comp.linguistic2.ChineseTranslationDialog" + +It can be initialized via the XInitialization interface with the following single parameter: +PropertyValue-Parameter: Name="ParentWindow" Type="awt::XWindow". + +It can be executed via the ui::dialogs::XExecutableDialog interface. + +Made settings can be retrieved via beans::XPropertySet interface. +Following properties are available (read only and not bound): +1) Name="IsDirectionToSimplified" Type="sal_Bool" +2) Name="IsUseCharacterVariants" Type="sal_Bool" +3) Name="IsTranslateCommonTerms" Type="sal_Bool" + +The dialog gets this information from the registry on execute and writes it back to the registry if ended with OK. +*/ + +class ChineseTranslationDialog; + +class ChineseTranslation_UnoDialog : public ::cppu::WeakImplHelper < + css::ui::dialogs::XExecutableDialog + , css::lang::XInitialization + , css::beans::XPropertySet + , css::lang::XComponent + , css::lang::XServiceInfo + > +{ +public: + ChineseTranslation_UnoDialog(); + virtual ~ChineseTranslation_UnoDialog() override; + + // lang::XServiceInfo + virtual OUString SAL_CALL getImplementationName() override; + virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override; + virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override; + + // lang::XInitialization + virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) override; + + // ui::dialogs::XExecutableDialog + virtual void SAL_CALL setTitle( const OUString& aTitle ) override; + virtual sal_Int16 SAL_CALL execute( ) override; + + // beans::XPropertySet + virtual css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL getPropertySetInfo( ) override; + virtual void SAL_CALL setPropertyValue( const OUString& aPropertyName, const css::uno::Any& aValue ) override; + virtual css::uno::Any SAL_CALL getPropertyValue( const OUString& PropertyName ) override; + virtual void SAL_CALL addPropertyChangeListener( const OUString& aPropertyName, const css::uno::Reference< css::beans::XPropertyChangeListener >& xListener ) override; + virtual void SAL_CALL removePropertyChangeListener( const OUString& aPropertyName, const css::uno::Reference< css::beans::XPropertyChangeListener >& aListener ) override; + virtual void SAL_CALL addVetoableChangeListener( const OUString& PropertyName, const css::uno::Reference< css::beans::XVetoableChangeListener >& aListener ) override; + virtual void SAL_CALL removeVetoableChangeListener( const OUString& PropertyName, const css::uno::Reference< css::beans::XVetoableChangeListener >& aListener ) override; + + // lang::XComponent + virtual void SAL_CALL dispose() override; + virtual void SAL_CALL addEventListener( const css::uno::Reference< css::lang::XEventListener > & xListener ) override; + virtual void SAL_CALL removeEventListener( const css::uno::Reference< css::lang::XEventListener > & xListener ) override; + +private: + + void impl_DeleteDialog(); + +private: + css::uno::Reference< + css::awt::XWindow > m_xParentWindow; + + std::unique_ptr m_xDialog; + + bool m_bDisposed; ///Dispose call ready. + bool m_bInDispose;///In dispose call + std::mutex m_aContainerMutex; + comphelper::OInterfaceContainerHelper4 m_aDisposeEventListeners; +}; + + +} //end namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/unodialogs/textconversiondlgs/chinese_translationdialog.cxx b/svx/source/unodialogs/textconversiondlgs/chinese_translationdialog.cxx new file mode 100644 index 000000000..9bef507b7 --- /dev/null +++ b/svx/source/unodialogs/textconversiondlgs/chinese_translationdialog.cxx @@ -0,0 +1,97 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + + +#include "chinese_translationdialog.hxx" +#include "chinese_dictionarydialog.hxx" +#include +#include +#include + +namespace textconversiondlgs +{ + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; + +ChineseTranslationDialog::ChineseTranslationDialog(weld::Window* pParent) + : GenericDialogController(pParent, "svx/ui/chineseconversiondialog.ui", "ChineseConversionDialog") + , m_xBP_OK(m_xBuilder->weld_button("ok")) + , m_xPB_Editterms(m_xBuilder->weld_button("editterms")) + , m_xRB_To_Simplified(m_xBuilder->weld_radio_button("tosimplified")) + , m_xRB_To_Traditional(m_xBuilder->weld_radio_button("totraditional")) + , m_xCB_Translate_Commonterms(m_xBuilder->weld_check_button("commonterms")) +{ + SvtLinguConfig aLngCfg; + bool bValue = false; + Any aAny( aLngCfg.GetProperty( UPN_IS_DIRECTION_TO_SIMPLIFIED ) ); + aAny >>= bValue; + if( bValue ) + m_xRB_To_Simplified->set_active(true); + else + m_xRB_To_Traditional->set_active(true); + + aAny = aLngCfg.GetProperty( UPN_IS_TRANSLATE_COMMON_TERMS ); + if( aAny >>= bValue ) + m_xCB_Translate_Commonterms->set_active( bValue ); + + m_xPB_Editterms->connect_clicked( LINK( this, ChineseTranslationDialog, DictionaryHdl ) ); + m_xBP_OK->connect_clicked( LINK( this, ChineseTranslationDialog, OkHdl ) ); +} + +ChineseTranslationDialog::~ChineseTranslationDialog() +{ +} + +void ChineseTranslationDialog::getSettings( bool& rbDirectionToSimplified + , bool& rbTranslateCommonTerms ) const +{ + rbDirectionToSimplified = m_xRB_To_Simplified->get_active(); + rbTranslateCommonTerms = m_xCB_Translate_Commonterms->get_active(); +} + +IMPL_LINK_NOARG(ChineseTranslationDialog, OkHdl, weld::Button&, void) +{ + //save settings to configuration + SvtLinguConfig aLngCfg; + Any aAny; + aAny <<= m_xRB_To_Simplified->get_active(); + aLngCfg.SetProperty( UPN_IS_DIRECTION_TO_SIMPLIFIED, aAny ); + aAny <<= m_xCB_Translate_Commonterms->get_active(); + aLngCfg.SetProperty( UPN_IS_TRANSLATE_COMMON_TERMS, aAny ); + + m_xDialog->response(RET_OK); +} + +IMPL_LINK_NOARG(ChineseTranslationDialog, DictionaryHdl, weld::Button&, void) +{ + if( !m_xDictionaryDialog ) + m_xDictionaryDialog.reset(new ChineseDictionaryDialog(m_xDialog.get())); + sal_Int32 nTextConversionOptions = i18n::TextConversionOption::NONE; + if (!m_xCB_Translate_Commonterms->get_active()) + nTextConversionOptions = nTextConversionOptions | i18n::TextConversionOption::CHARACTER_BY_CHARACTER; + m_xDictionaryDialog->setDirectionAndTextConversionOptions(m_xRB_To_Simplified->get_active(), nTextConversionOptions); + m_xDictionaryDialog->run(); +} + + +} //end namespace + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/unodialogs/textconversiondlgs/chinese_translationdialog.hxx b/svx/source/unodialogs/textconversiondlgs/chinese_translationdialog.hxx new file mode 100644 index 000000000..d6a9c312d --- /dev/null +++ b/svx/source/unodialogs/textconversiondlgs/chinese_translationdialog.hxx @@ -0,0 +1,51 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#pragma once + +#include + +namespace textconversiondlgs +{ +class ChineseDictionaryDialog; + +class ChineseTranslationDialog : public weld::GenericDialogController +{ +public: + explicit ChineseTranslationDialog(weld::Window* pParent); + virtual ~ChineseTranslationDialog() override; + + void getSettings(bool& rbDirectionToSimplified, bool& rbTranslateCommonTerms) const; + +private: + DECL_LINK(DictionaryHdl, weld::Button&, void); + DECL_LINK(OkHdl, weld::Button&, void); + +private: + std::unique_ptr m_xBP_OK; + std::unique_ptr m_xPB_Editterms; + std::unique_ptr m_xRB_To_Simplified; + std::unique_ptr m_xRB_To_Traditional; + std::unique_ptr m_xCB_Translate_Commonterms; + std::unique_ptr m_xDictionaryDialog; +}; + +} //end namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit v1.2.3