Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

6 files changed, 1338 insertions, 0 deletions

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 <cppuhelper/bootstrap.hxx>
+#include <com/sun/star/i18n/TextConversionOption.hpp>
+#include <com/sun/star/linguistic2/ConversionDictionaryType.hpp>
+#include <com/sun/star/linguistic2/ConversionPropertyType.hpp>
+#include <com/sun/star/linguistic2/ConversionDictionaryList.hpp>
+#include <com/sun/star/linguistic2/XConversionPropertyType.hpp>
+#include <com/sun/star/util/XFlushable.hpp>
+#include <com/sun/star/lang/Locale.hpp>
+#include <o3tl/safeint.hxx>
+#include <unotools/lingucfg.hxx>
+#include <unotools/linguprops.hxx>
+#include <osl/diagnose.h>
+
+namespace textconversiondlgs
+{
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+
+DictionaryList::DictionaryList(std::unique_ptr<weld::TreeView> 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<sal_uInt16>( 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<DictionaryEntry*>(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<int> 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<int> aWidths
+    {
+        o3tl::narrowing<int>(m_pED_Term->get_preferred_size().Width()),
+        o3tl::narrowing<int>(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 <vcl/weld.hxx>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <com/sun/star/linguistic2/XConversionDictionary.hpp>
+
+#include <vector>
+
+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<weld::TreeView> 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<weld::TreeView&, void>& rLink) { m_xControl->connect_changed(rLink); }
+    void connect_column_clicked(const Link<int, void>& 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<css::linguistic2::XConversionDictionary>  m_xDictionary;
+
+private:
+    std::unique_ptr<weld::TreeView> m_xControl;
+    std::unique_ptr<weld::TreeIter> 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<css::uno::XComponentContext> m_xContext;
+
+    std::unique_ptr<weld::RadioButton> m_xRB_To_Simplified;
+    std::unique_ptr<weld::RadioButton> m_xRB_To_Traditional;
+
+    std::unique_ptr<weld::CheckButton> m_xCB_Reverse;
+
+    std::unique_ptr<weld::Label> m_xFT_Term;
+    std::unique_ptr<weld::Entry> m_xED_Term;
+
+    std::unique_ptr<weld::Label> m_xFT_Mapping;
+    std::unique_ptr<weld::Entry> m_xED_Mapping;
+
+    std::unique_ptr<weld::Label> m_xFT_Property;
+    std::unique_ptr<weld::ComboBox> m_xLB_Property;
+
+    std::unique_ptr<DictionaryList> m_xCT_DictionaryToSimplified;
+    std::unique_ptr<DictionaryList> m_xCT_DictionaryToTraditional;
+
+    std::unique_ptr<weld::Button>  m_xPB_Add;
+    std::unique_ptr<weld::Button>  m_xPB_Modify;
+    std::unique_ptr<weld::Button>  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 <vcl/svapp.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp>
+
+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<cppu::OWeakObject*>(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<css::uno::Any> 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 <sal/config.h>
+
+#include <memory>
+
+#include <com/sun/star/awt/XWindow.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
+#include <cppuhelper/implbase.hxx>
+#include <comphelper/interfacecontainer4.hxx>
+#include <mutex>
+
+
+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<ChineseTranslationDialog> m_xDialog;
+
+    bool m_bDisposed; ///Dispose call ready.
+    bool m_bInDispose;///In dispose call
+    std::mutex                      m_aContainerMutex;
+    comphelper::OInterfaceContainerHelper4<css::lang::XEventListener> 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 <com/sun/star/i18n/TextConversionOption.hpp>
+#include <unotools/lingucfg.hxx>
+#include <unotools/linguprops.hxx>
+
+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 <vcl/weld.hxx>
+
+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<weld::Button> m_xBP_OK;
+    std::unique_ptr<weld::Button> m_xPB_Editterms;
+    std::unique_ptr<weld::RadioButton> m_xRB_To_Simplified;
+    std::unique_ptr<weld::RadioButton> m_xRB_To_Traditional;
+    std::unique_ptr<weld::CheckButton> m_xCB_Translate_Commonterms;
+    std::unique_ptr<ChineseDictionaryDialog> m_xDictionaryDialog;
+};
+
+} //end namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */