/* -*- 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 <config_wasm_strip.h>

#include <utility>

#include <vcl/commandevent.hxx>

#include <vcl/event.hxx>

#include <vcl/fontcharmap.hxx>

#include <vcl/svapp.hxx>

#include <vcl/settings.hxx>

#include <vcl/virdev.hxx>

#include <svx/ucsubset.hxx>

#include <svx/strings.hrc>

#include <svx/charmap.hxx>

#include <svx/dialmgr.hxx>

#include <charmapacc.hxx>

#include <uiobject.hxx>

#include <com/sun/star/accessibility/AccessibleEventId.hpp>

#include <com/sun/star/accessibility/AccessibleStateType.hpp>

#include <com/sun/star/datatransfer/clipboard/XFlushableClipboard.hpp>

#include <com/sun/star/datatransfer/clipboard/SystemClipboard.hpp>

#include <officecfg/Office/Common.hxx>

#include <comphelper/processfactory.hxx>

#include <comphelper/sequence.hxx>

#include <unicode/uchar.h>

#include <vcl/textview.hxx>

#include <rtl/ustrbuf.hxx>

using namespace ::com::sun::star::accessibility;

using namespace ::com::sun::star::uno;

using namespace ::com::sun::star;

sal_uInt32& SvxShowCharSet::getSelectedChar()

{

    static sal_uInt32 cSelectedChar = ' '; // keeps selected character over app lifetime

    return cSelectedChar;

}

FactoryFunction SvxShowCharSet::GetUITestFactory() const

{

    return SvxShowCharSetUIObject::create;

}

SvxShowCharSet::SvxShowCharSet(std::unique_ptr<weld::ScrolledWindow> pScrolledWindow, const VclPtr<VirtualDevice>& rVirDev)

    : mxVirDev(rVirDev)

    , mxScrollArea(std::move(pScrolledWindow))

    , mnX(0)

    , mnY(0)

    , maFontSize(0, 0)

    , mbRecalculateFont(true)

    , mbUpdateForeground(true)

    , mbUpdateBackground(true)

{

    init();

}

void SvxShowCharSet::SetDrawingArea(weld::DrawingArea* pDrawingArea)

{

    CustomWidgetController::SetDrawingArea(pDrawingArea);

    Size aSize(COLUMN_COUNT * pDrawingArea->get_approximate_digit_width() * 5.25,

               ROW_COUNT * pDrawingArea->get_text_height() * 2);

    mnX = aSize.Width() / COLUMN_COUNT;

    mnY = aSize.Height() / ROW_COUNT;

    // tdf#121232 set a size request that will result in a 0 m_nXGap by default

    mxScrollArea->set_size_request(COLUMN_COUNT * mnX + mxScrollArea->get_scroll_thickness() + 2,

                                   ROW_COUNT * mnY);

}

void SvxShowCharSet::init()

{

    mnSelectedIndex = -1;    // TODO: move into init list when it is no longer static

    m_nXGap = 0;

    m_nYGap = 0;

    mxScrollArea->connect_vadjustment_value_changed(LINK(this, SvxShowCharSet, VscrollHdl));

    getFavCharacterList();

    // other settings depend on selected font => see RecalculateFont

    mbDrag = false;

}

void SvxShowCharSet::Resize()

{

    mbRecalculateFont = true;

}

void SvxShowCharSet::GetFocus()

{

    SelectIndex(mnSelectedIndex, true);

}

void SvxShowCharSet::LoseFocus()

{

    SelectIndex(mnSelectedIndex);

}

bool SvxShowCharSet::MouseButtonDown(const MouseEvent& rMEvt)

{

    if ( rMEvt.IsLeft() )

    {

        if ( rMEvt.GetClicks() == 1 )

        {

            GrabFocus();

            mbDrag = true;

            CaptureMouse();

            int nIndex = PixelToMapIndex( rMEvt.GetPosPixel() );

            // Fire the focus event

            SelectIndex( nIndex, true);

        }

        if ( !(rMEvt.GetClicks() % 2) )

            maDoubleClkHdl.Call( this );

        return true;

    }

    return CustomWidgetController::MouseButtonDown(rMEvt);

}

bool SvxShowCharSet::MouseButtonUp(const MouseEvent& rMEvt)

{

    if ( mbDrag && rMEvt.IsLeft() )

    {

        // released mouse over character map

        if ( tools::Rectangle(Point(), GetOutputSizePixel()).Contains(rMEvt.GetPosPixel()))

            maSelectHdl.Call( this );

        ReleaseMouse();

        mbDrag = false;

    }

    return true;

}

bool SvxShowCharSet::MouseMove(const MouseEvent& rMEvt)

{

    if ( rMEvt.IsLeft() && mbDrag )

    {

        Point aPos  = rMEvt.GetPosPixel();

        Size  aSize = GetOutputSizePixel();

        if ( aPos.X() < 0 )

            aPos.setX( 0 );

        else if ( aPos.X() > aSize.Width()-5 )

            aPos.setX( aSize.Width()-5 );

        if ( aPos.Y() < 0 )

            aPos.setY( 0 );

        else if ( aPos.Y() > aSize.Height()-5 )

            aPos.setY( aSize.Height()-5 );

        int nIndex = PixelToMapIndex( aPos );

    // Fire the focus event.

        SelectIndex( nIndex, true );

    }

    return true;

}

bool SvxShowCharSet::Command(const CommandEvent& rCEvt)

{

    if (rCEvt.GetCommand() == CommandEventId::ContextMenu)

    {

        Point aPosition;

        if (rCEvt.IsMouseEvent())

        {

            aPosition = rCEvt.GetMousePosPixel();

            int nIndex = PixelToMapIndex(aPosition);

            // Fire the focus event

            SelectIndex(nIndex, true);

        }

        else

        {

            svx::SvxShowCharSetItem* pItem = ImplGetItem(mnSelectedIndex);

            if (!pItem)

                return true;

            // position context menu at centre of currently selected item

            aPosition = MapIndexToPixel(mnSelectedIndex);

            aPosition.AdjustX(pItem->maRect.GetWidth() / 2);

            aPosition.AdjustY(pItem->maRect.GetHeight() / 2);

        }

        createContextMenu(aPosition);

        return true;

    }

    return weld::CustomWidgetController::Command(rCEvt);

}

sal_uInt16 SvxShowCharSet::GetRowPos(sal_uInt16 _nPos)

{

    return _nPos / COLUMN_COUNT ;

}

void SvxShowCharSet::getFavCharacterList()

{

    maFavCharList.clear();

    maFavCharFontList.clear();

    //retrieve recent character list

    css::uno::Sequence< OUString > rFavCharList( officecfg::Office::Common::FavoriteCharacters::FavoriteCharacterList::get() );

    comphelper::sequenceToContainer(maFavCharList, rFavCharList);

    //retrieve recent character font list

    css::uno::Sequence< OUString > rFavCharFontList( officecfg::Office::Common::FavoriteCharacters::FavoriteCharacterFontList::get() );

    comphelper::sequenceToContainer(maFavCharFontList, rFavCharFontList);

}

bool SvxShowCharSet::isFavChar(std::u16string_view sTitle, std::u16string_view rFont)

{

    assert(maFavCharList.size() == maFavCharFontList.size());

    for (size_t i = 0; i < maFavCharList.size(); i++)

    {

        if (maFavCharList[i] == sTitle && maFavCharFontList[i] == rFont)

            return true;

    }

    return false;

}

void SvxShowCharSet::createContextMenu(const Point& rPosition)

{

    std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetDrawingArea(), u"svx/ui/charsetmenu.ui"_ustr));

    std::unique_ptr<weld::Menu> xItemMenu(xBuilder->weld_menu(u"charsetmenu"_ustr));

    sal_UCS4 cChar = GetSelectCharacter();

    OUString aOUStr( &cChar, 1 );

    if (isFavChar(aOUStr, mxVirDev->GetFont().GetFamilyName()) || maFavCharList.size() >= 16)

        xItemMenu->set_visible(u"add"_ustr, false);

    else

        xItemMenu->set_visible(u"remove"_ustr, false);

    ContextMenuSelect(xItemMenu->popup_at_rect(GetDrawingArea(), tools::Rectangle(rPosition, Size(1,1))));

    GrabFocus();

    Invalidate();

}

void SvxShowCharSet::ContextMenuSelect(std::u16string_view rIdent)

{

    sal_UCS4 cChar = GetSelectCharacter();

    OUString aOUStr(&cChar, 1);

    if (rIdent == u"insert")

        maDoubleClkHdl.Call(this);

    else if (rIdent == u"add" || rIdent == u"remove")

    {

        updateFavCharacterList(aOUStr, mxVirDev->GetFont().GetFamilyName());

        maFavClickHdl.Call(this);

    }

    else if (rIdent == u"copy")

        CopyToClipboard(aOUStr);

}

void SvxShowCharSet::CopyToClipboard(const OUString& rOUStr)

{

    css::uno::Reference<css::datatransfer::clipboard::XClipboard> xClipboard =

        css::datatransfer::clipboard::SystemClipboard::create(comphelper::getProcessComponentContext());

    if (!xClipboard.is())

        return;

    rtl::Reference<TETextDataObject> pDataObj = new TETextDataObject(rOUStr);

    try

    {

        xClipboard->setContents( pDataObj, nullptr );

        css::uno::Reference<css::datatransfer::clipboard::XFlushableClipboard> xFlushableClipboard(xClipboard, css::uno::UNO_QUERY);

        if( xFlushableClipboard.is() )

            xFlushableClipboard->flushClipboard();

    }

    catch( const css::uno::Exception& )

    {

    }

}

void SvxShowCharSet::updateFavCharacterList(const OUString& sTitle, const OUString& rFont)

{

    if (isFavChar(sTitle, rFont))

    {

        assert(maFavCharList.size() == maFavCharFontList.size());

        auto fontIt = maFavCharFontList.begin();

        for (auto charIt = maFavCharList.begin(); charIt != maFavCharList.end(); charIt++)

        {

            if (*charIt == sTitle && *fontIt == rFont)

            {

                maFavCharList.erase(charIt);

                maFavCharFontList.erase(fontIt);

                break;

            }

            fontIt++;

        }

    }

    else

    {

        if (maFavCharList.size() == 16)

        {

            maFavCharList.pop_back();

            maFavCharFontList.pop_back();

        }

        maFavCharList.push_back(sTitle);

        maFavCharFontList.push_back(rFont);

    }

    css::uno::Sequence< OUString > aFavCharList(maFavCharList.size());

    auto aFavCharListRange = asNonConstRange(aFavCharList);

    css::uno::Sequence< OUString > aFavCharFontList(maFavCharFontList.size());

    auto aFavCharFontListRange = asNonConstRange(aFavCharFontList);

    for (size_t i = 0; i < maFavCharList.size(); ++i)

    {

        aFavCharListRange[i] = maFavCharList[i];

        aFavCharFontListRange[i] = maFavCharFontList[i];

    }

    std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create());

    officecfg::Office::Common::FavoriteCharacters::FavoriteCharacterList::set(aFavCharList, batch);

    officecfg::Office::Common::FavoriteCharacters::FavoriteCharacterFontList::set(aFavCharFontList, batch);

    batch->commit();

}

sal_uInt16 SvxShowCharSet::GetColumnPos(sal_uInt16 _nPos)

{

    return _nPos % COLUMN_COUNT ;

}

int SvxShowCharSet::FirstInView() const

{

    return mxScrollArea->vadjustment_get_value() * COLUMN_COUNT;

}

int SvxShowCharSet::LastInView() const

{

    sal_uInt32 nIndex = FirstInView();

    nIndex += ROW_COUNT * COLUMN_COUNT - 1;

    sal_uInt32 nCompare = mxFontCharMap->GetCharCount() - 1;

    if (nIndex > nCompare)

        nIndex = nCompare;

    return nIndex;

}

Point SvxShowCharSet::MapIndexToPixel( int nIndex ) const

{

    const int nBase = FirstInView();

    int x = ((nIndex - nBase) % COLUMN_COUNT) * mnX;

    int y = ((nIndex - nBase) / COLUMN_COUNT) * mnY;

    return Point( x + m_nXGap, y + m_nYGap );

}

int SvxShowCharSet::PixelToMapIndex( const Point& point) const

{

    int nBase = FirstInView();

    assert(mnX != 0);

    int x = mnX == 0 ? 0 : (point.X() - m_nXGap)/mnX;

    assert(mnY != 0);

    int y = mnY == 0 ? 0 : (point.Y() - m_nYGap)/mnY;

    return (nBase + x + y * COLUMN_COUNT);

}

bool SvxShowCharSet::KeyInput(const KeyEvent& rKEvt)

{

    vcl::KeyCode aCode = rKEvt.GetKeyCode();

    if (aCode.GetModifier())

        return false;

    bool bRet = true;

    int tmpSelected = mnSelectedIndex;

    switch (aCode.GetCode())

    {

        case KEY_RETURN:

            m_aReturnKeypressHdl.Call(this);

            return true;

        case KEY_SPACE:

            maDoubleClkHdl.Call(this);

            return true;

        case KEY_LEFT:

            --tmpSelected;

            break;

        case KEY_RIGHT:

            ++tmpSelected;

            break;

        case KEY_UP:

            tmpSelected -= COLUMN_COUNT;

            break;

        case KEY_DOWN:

            tmpSelected += COLUMN_COUNT;

            break;

        case KEY_PAGEUP:

            tmpSelected -= ROW_COUNT * COLUMN_COUNT;

            break;

        case KEY_PAGEDOWN:

            tmpSelected += ROW_COUNT * COLUMN_COUNT;

            break;

        case KEY_HOME:

            tmpSelected = 0;

            break;

        case KEY_END:

            tmpSelected = mxFontCharMap->GetCharCount() - 1;

            break;

        case KEY_TAB:   // some fonts have a character at these unicode control codes

        case KEY_ESCAPE:

            tmpSelected = - 1;  // mark as invalid

            bRet = false;

            break;

        default:

        {

            sal_UCS4 cChar = rKEvt.GetCharCode();

            sal_UCS4 cNext = mxFontCharMap->GetNextChar(cChar - 1);

            tmpSelected = mxFontCharMap->GetIndexFromChar(cNext);

            if (tmpSelected < 0 || (cChar != cNext))

            {

                tmpSelected = - 1;  // mark as invalid

                bRet = false;

            }

            break;

        }

    }

    if ( tmpSelected >= 0 )

    {

        SelectIndex( tmpSelected, true );

        maPreSelectHdl.Call( this );

    }

    return bRet;

}

void SvxShowCharSet::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)

{

    InitSettings(rRenderContext);

    RecalculateFont(rRenderContext);

    DrawChars_Impl(rRenderContext, FirstInView(), LastInView());

}

void SvxShowCharSet::SetFont( const vcl::Font& rFont )

{

    maFont = rFont;

    mbRecalculateFont = true;

    Invalidate();

}

void SvxShowCharSet::DeSelect()

{

    Invalidate();

}

// stretch a grid rectangle if it's at the edge to fill unused space

tools::Rectangle SvxShowCharSet::getGridRectangle(const Point &rPointUL, const Size &rOutputSize) const

{

    tools::Long x = rPointUL.X() - 1;

    tools::Long y = rPointUL.Y() - 1;

    Point aPointUL(x+1, y+1);

    Size aGridSize(mnX-1, mnY-1);

    tools::Long nXDistFromLeft = x - m_nXGap;

    if (nXDistFromLeft <= 1)

    {

        aPointUL.setX( 1 );

        aGridSize.AdjustWidth(m_nXGap + nXDistFromLeft );

    }

    tools::Long nXDistFromRight = rOutputSize.Width() - m_nXGap - mnX - x;

    if (nXDistFromRight <= 1)

        aGridSize.AdjustWidth(m_nXGap + nXDistFromRight );

    tools::Long nXDistFromTop = y - m_nYGap;

    if (nXDistFromTop <= 1)

    {

        aPointUL.setY( 1 );

        aGridSize.AdjustHeight(m_nYGap + nXDistFromTop );

    }

    tools::Long nXDistFromBottom = rOutputSize.Height() - m_nYGap - mnY - y;

    if (nXDistFromBottom <= 1)

        aGridSize.AdjustHeight(m_nYGap + nXDistFromBottom );

    return tools::Rectangle(aPointUL, aGridSize);

}

void SvxShowCharSet::DrawChars_Impl(vcl::RenderContext& rRenderContext, int n1, int n2)

{

    if (n1 > LastInView() || n2 < FirstInView())

        return;

    Size aOutputSize(GetOutputSizePixel());

    const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();

    const Color aWindowTextColor(rStyleSettings.GetFieldTextColor());

    Color aHighlightColor(rStyleSettings.GetHighlightColor());

    Color aHighlightTextColor(rStyleSettings.GetHighlightTextColor());

    Color aFaceColor(rStyleSettings.GetFaceColor());

    Color aLightColor(rStyleSettings.GetLightColor());

    Color aShadowColor(rStyleSettings.GetShadowColor());

    int i;

    rRenderContext.SetLineColor(aShadowColor);

    for (i = 1; i < COLUMN_COUNT; ++i)

    {

        rRenderContext.DrawLine(Point(mnX * i + m_nXGap, 0),

                          Point(mnX * i + m_nXGap, aOutputSize.Height()));

    }

    for (i = 1; i < ROW_COUNT; ++i)

    {

        rRenderContext.DrawLine(Point(0, mnY * i + m_nYGap),

                                Point(aOutputSize.Width(), mnY * i + m_nYGap));

    }

    int nTextHeight = rRenderContext.GetTextHeight();

    tools::Rectangle aBoundRect;

    for (i = n1; i <= n2; ++i)

    {

        sal_UCS4 charValue = GetCharFromIndex(i);

        if (charValue == 0)

            continue;

        OUString aCharStr(&charValue, 1);

        Point pix = MapIndexToPixel(i);

        int x = pix.X();

        int y = pix.Y();

        int nTextWidth = rRenderContext.GetTextWidth(aCharStr);

        int tx = x + (mnX - nTextWidth + 1) / 2;

        int ty = y + (mnY - nTextHeight + 1) / 2;

        Point aPointTxTy(tx, ty);

        // adjust position before it gets out of bounds

        if (rRenderContext.GetTextBoundRect(aBoundRect, aCharStr) && !aBoundRect.IsEmpty())

        {

            // zero advance width => use ink width to center glyph

            if (!nTextWidth)

            {

                aPointTxTy.setX( x - aBoundRect.Left() + (mnX - aBoundRect.GetWidth() + 1) / 2 );

            }

            aBoundRect += aPointTxTy;

            // shift back vertically if needed

            int nYLDelta = aBoundRect.Top() - y;

            int nYHDelta = (y + mnY) - aBoundRect.Bottom();

            if (nYLDelta <= 0)

                aPointTxTy.AdjustY( -(nYLDelta - 1) );

            else if (nYHDelta <= 0)

                aPointTxTy.AdjustY(nYHDelta - 1 );

            // shift back horizontally if needed

            int nXLDelta = aBoundRect.Left() - x;

            int nXHDelta = (x + mnX) - aBoundRect.Right();

            if (nXLDelta <= 0)

                aPointTxTy.AdjustX( -(nXLDelta - 1) );

            else if (nXHDelta <= 0)

                aPointTxTy.AdjustX(nXHDelta - 1 );

        }

        // tdf#109214 - highlight the favorite characters

        if (isFavChar(aCharStr, mxVirDev->GetFont().GetFamilyName()))

        {

            const Color aLineCol = rRenderContext.GetLineColor();

            rRenderContext.SetLineColor(aHighlightColor);

            rRenderContext.SetFillColor();

            // Outer border

            rRenderContext.DrawRect(tools::Rectangle(Point(x - 1, y - 1), Size(mnX + 3, mnY + 3)), 1, 1);

            // Inner border

            rRenderContext.DrawRect(tools::Rectangle(Point(x, y), Size(mnX + 1, mnY + 1)), 1, 1);

            rRenderContext.SetLineColor(aLineCol);

        }

        Color aTextCol = rRenderContext.GetTextColor();

        if (i != mnSelectedIndex)

        {

            rRenderContext.SetTextColor(aWindowTextColor);

            rRenderContext.DrawText(aPointTxTy, aCharStr);

        }

        else

        {

            Color aLineCol = rRenderContext.GetLineColor();

            rRenderContext.SetLineColor();

            Point aPointUL(x + 1, y + 1);

            if (HasFocus())

            {

                rRenderContext.SetFillColor(aHighlightColor);

                rRenderContext.DrawRect(getGridRectangle(aPointUL, aOutputSize));

                rRenderContext.SetTextColor(aHighlightTextColor);

                rRenderContext.DrawText(aPointTxTy, aCharStr);

            }

            else

            {

                rRenderContext.SetFillColor(aFaceColor);

                rRenderContext.DrawRect(getGridRectangle(aPointUL, aOutputSize));

                rRenderContext.SetLineColor(aLightColor);

                rRenderContext.DrawLine(aPointUL, Point(x + mnX - 1, y + 1));

                rRenderContext.DrawLine(aPointUL, Point(x + 1, y + mnY - 1));

                rRenderContext.SetLineColor(aShadowColor);

                rRenderContext.DrawLine(Point(x + 1, y + mnY - 1), Point(x + mnX - 1, y + mnY - 1));

                rRenderContext.DrawLine(Point(x + mnX - 1, y + mnY - 1), Point(x + mnX - 1, y + 1));

                rRenderContext.DrawText(aPointTxTy, aCharStr);

            }

            rRenderContext.SetLineColor(aLineCol);

        }

        rRenderContext.SetTextColor(aTextCol);

    }

    // tdf#141319 - mark empty/unused cells

    if (n2 - n1 < ROW_COUNT * COLUMN_COUNT)

    {

        rRenderContext.SetFillColor(rStyleSettings.GetDisableColor());

        for (i = n2 - n1 + 1; i < ROW_COUNT * COLUMN_COUNT; i++)

        {

            rRenderContext.DrawRect(

                tools::Rectangle(MapIndexToPixel(i + n1), Size(mnX + 2, mnY + 2)));

        }

    }

}

void SvxShowCharSet::InitSettings(vcl::RenderContext& rRenderContext)

{

    const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();

    if (mbUpdateForeground)

    {

        rRenderContext.SetTextColor(rStyleSettings.GetDialogTextColor());

        mbUpdateForeground = false;

    }

    if (mbUpdateBackground)

    {

        rRenderContext.SetBackground(rStyleSettings.GetWindowColor());

        rRenderContext.Erase();

        mbUpdateBackground = false;

    }

    vcl::Font aFont(maFont);

    aFont.SetWeight(WEIGHT_LIGHT);

    aFont.SetAlignment(ALIGN_TOP);

    aFont.SetFontSize(maFontSize);

    aFont.SetTransparent(true);

    rRenderContext.SetFont(aFont);

}

sal_UCS4 SvxShowCharSet::GetSelectCharacter() const

{

    if( mnSelectedIndex >= 0 )

        getSelectedChar() = mxFontCharMap->GetCharFromIndex( mnSelectedIndex );

    return getSelectedChar();

}

sal_UCS4 SvxShowCharSet::GetCharFromIndex(int index) const

{

    return mxFontCharMap->GetCharFromIndex(index);

}

void SvxShowCharSet::RecalculateFont(vcl::RenderContext& rRenderContext)

{

    if (!mbRecalculateFont)

        return;

    // save last selected unicode

    if (mnSelectedIndex >= 0)

        getSelectedChar() = mxFontCharMap->GetCharFromIndex(mnSelectedIndex);

    Size aSize(GetOutputSizePixel());

    vcl::Font aFont = maFont;

    aFont.SetWeight(WEIGHT_LIGHT);

    aFont.SetAlignment(ALIGN_TOP);

    int nFontHeight = (aSize.Height() - 5) * 2 / (3 * ROW_COUNT);

    maFontSize = rRenderContext.PixelToLogic(Size(0, nFontHeight));

    aFont.SetFontSize(maFontSize);

    aFont.SetTransparent(true);

    rRenderContext.SetFont(aFont);

    rRenderContext.GetFontCharMap(mxFontCharMap);

    m_aItems.clear();

    getFavCharacterList();

    mnX = aSize.Width() / COLUMN_COUNT;

    mnY = aSize.Height() / ROW_COUNT;

    const int nLastRow = (mxFontCharMap->GetCharCount() - 1 + COLUMN_COUNT) / COLUMN_COUNT;

    mxScrollArea->vadjustment_configure(mxScrollArea->vadjustment_get_value(), nLastRow, 1,

                                        ROW_COUNT - 1, ROW_COUNT);

    // restore last selected unicode

    int nMapIndex = mxFontCharMap->GetIndexFromChar(getSelectedChar());

    if (nMapIndex != mnSelectedIndex)

        SelectIndex(nMapIndex);

    // rearrange CharSet element in sync with nX- and nY-multiples

    Size aDrawSize(mnX * COLUMN_COUNT, mnY * ROW_COUNT);

    m_nXGap = (aSize.Width() - aDrawSize.Width()) / 2;

    m_nYGap = (aSize.Height() - aDrawSize.Height()) / 2;

    mbRecalculateFont = false;

}

void SvxShowCharSet::SelectIndex(int nNewIndex, bool bFocus)

{

    if (!mxFontCharMap.is())

        RecalculateFont(*mxVirDev);

    if( nNewIndex < 0 )

    {

        // need to scroll see closest unicode

        sal_UCS4 cPrev = mxFontCharMap->GetPrevChar( getSelectedChar() );

        int nMapIndex = mxFontCharMap->GetIndexFromChar( cPrev );

        int nNewPos = nMapIndex / COLUMN_COUNT;

        mxScrollArea->vadjustment_set_value(nNewPos);

        mnSelectedIndex = bFocus ? nMapIndex+1 : -1;

        Invalidate();

    }

    else if( nNewIndex < FirstInView() )

    {

        // need to scroll up to see selected item

        int nOldPos = mxScrollArea->vadjustment_get_value();

        int nDelta = (FirstInView() - nNewIndex + COLUMN_COUNT-1) / COLUMN_COUNT;

        mxScrollArea->vadjustment_set_value(nOldPos - nDelta);

        mnSelectedIndex = nNewIndex;

        Invalidate();

    }

    else if( nNewIndex > LastInView() )

    {

        // need to scroll down to see selected item

        int nOldPos = mxScrollArea->vadjustment_get_value();

        int nDelta = (nNewIndex - LastInView() + COLUMN_COUNT) / COLUMN_COUNT;

        mxScrollArea->vadjustment_set_value(nOldPos + nDelta);

        if( nNewIndex < mxFontCharMap->GetCharCount() )

        {

            mnSelectedIndex = nNewIndex;

            Invalidate();

        }

        else if (nOldPos != mxScrollArea->vadjustment_get_value())

        {

            Invalidate();

        }

    }

    else

    {

        mnSelectedIndex = nNewIndex;

        Invalidate();

    }

    if( mnSelectedIndex >= 0 )

    {

        getSelectedChar() = mxFontCharMap->GetCharFromIndex( mnSelectedIndex );

#if !ENABLE_WASM_STRIP_ACCESSIBILITY

        if( m_xAccessible.is() )

        {

            svx::SvxShowCharSetItem* pItem = ImplGetItem(mnSelectedIndex);

            rtl::Reference<svx::SvxShowCharSetItemAcc> xItemAcc = pItem->GetAccessible();

            // Don't fire the focus event.

            if ( bFocus )

                m_xAccessible->fireEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, Any(),

                                Any(uno::Reference<XAccessible>(xItemAcc)) ); // this call assures that m_pItem is set

            else

                m_xAccessible->fireEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED_NOFOCUS, Any(),

                                Any(uno::Reference<XAccessible>(xItemAcc)) ); // this call assures that m_pItem is set

            assert(pItem->m_xItem.is() && "No accessible created!");

            Any aOldAny, aNewAny;

            aNewAny <<= AccessibleStateType::FOCUSED;

            // Don't fire the focus event.

            if ( bFocus )

                pItem->m_xItem->fireEvent( AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny );

            aNewAny <<= AccessibleStateType::SELECTED;

            pItem->m_xItem->fireEvent( AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny );

        }

        maSelectHdl.Call(this);

#endif

    }

    maHighHdl.Call( this );

}

void SvxShowCharSet::OutputIndex( int nNewIndex )

{

    SelectIndex( nNewIndex, true );

    maSelectHdl.Call( this );

}

void SvxShowCharSet::SelectCharacter( sal_UCS4 cNew )

{

    if ( !mxFontCharMap.is() )

        RecalculateFont(*mxVirDev);

    // get next available char of current font

    sal_UCS4 cNext = mxFontCharMap->GetNextChar( (cNew > 0) ? cNew - 1 : cNew );

    int nMapIndex = mxFontCharMap->GetIndexFromChar( cNext );

    SelectIndex( nMapIndex );

    // move selected item to top row if not in focus

    mxScrollArea->vadjustment_set_value(nMapIndex / COLUMN_COUNT);

    Invalidate();

}

IMPL_LINK_NOARG(SvxShowCharSet, VscrollHdl, weld::ScrolledWindow&, void)

{

    if( mnSelectedIndex < FirstInView() )

    {

        SelectIndex( FirstInView() + (mnSelectedIndex % COLUMN_COUNT) );

    }

    else if( mnSelectedIndex > LastInView() )

    {

#if !ENABLE_WASM_STRIP_ACCESSIBILITY

        if( m_xAccessible.is() )

        {

            css::uno::Any aOldAny, aNewAny;

            int nLast = LastInView();

            for ( ; nLast != mnSelectedIndex; ++nLast)

            {

                aOldAny <<= uno::Reference<XAccessible>(ImplGetItem(nLast)->GetAccessible());

                m_xAccessible ->fireEvent( AccessibleEventId::CHILD, aOldAny, aNewAny );

            }

        }

#endif

        SelectIndex( (LastInView() - COLUMN_COUNT + 1) + (mnSelectedIndex % COLUMN_COUNT) );

    }

    Invalidate();

}

SvxShowCharSet::~SvxShowCharSet()

{

#if !ENABLE_WASM_STRIP_ACCESSIBILITY

    if (m_xAccessible.is())

    {

        m_aItems.clear();

        m_xAccessible->clearCharSetControl();

        m_xAccessible.clear();

    }

#endif

}

rtl::Reference<comphelper::OAccessible> SvxShowCharSet::CreateAccessible()

{

#if !ENABLE_WASM_STRIP_ACCESSIBILITY

    OSL_ENSURE(!m_xAccessible.is(),"Accessible already created!");

    m_xAccessible = new svx::SvxShowCharSetAcc(this);

#endif

    return m_xAccessible;

}

svx::SvxShowCharSetItem* SvxShowCharSet::ImplGetItem( int _nPos )

{

    ItemsMap::iterator aFind = m_aItems.find(_nPos);

    if ( aFind == m_aItems.end() )

    {

#if !ENABLE_WASM_STRIP_ACCESSIBILITY

        OSL_ENSURE(m_xAccessible.is(), "Who wants to create a child of my table without a parent?");