starmath/source/ElementsDockingWindow.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <ElementsDockingWindow.hxx>
  21
  22 #include <starmath.hrc>
  23 #include <smmod.hxx>
  24 #include <view.hxx>
  25 #include <visitors.hxx>
  26 #include "document.hxx"
  27 #include "node.hxx"
  28 #include "uiobject.hxx"
  29
  30 #include <o3tl/make_unique.hxx>
  31 #include <svl/stritem.hxx>
  32 #include <sfx2/dispatch.hxx>
  33 #include <sfx2/sfxmodelfactory.hxx>
  34 #include <vcl/help.hxx>
  35 #include <vcl/settings.hxx>
  36
  37 SmElement::SmElement(std::unique_ptr<SmNode>&& pNode, const OUString& aText, const OUString& aHelpText) :
  38     mpNode(std::move(pNode)),
  39     maText(aText),
  40     maHelpText(aHelpText)
  41 {}
  42
  43 SmElement::~SmElement()
  44 {}
  45
  46 const std::unique_ptr<SmNode>& SmElement::getNode()
  47 {
  48     return mpNode;
  49 }
  50
  51 SmElementSeparator::SmElementSeparator() :
  52     SmElement(std::unique_ptr<SmNode>(), OUString(), OUString())
  53 {}
  54
  55 const sal_uInt16 SmElementsControl::aUnaryBinaryOperatorsList[][2] =
  56 {
  57     {RID_PLUSX, RID_PLUSX_HELP}, {RID_MINUSX, RID_MINUSX_HELP},
  58     {RID_PLUSMINUSX, RID_PLUSMINUSX_HELP}, {RID_MINUSPLUSX, RID_MINUSPLUSX_HELP},
  59     {0xFFFF, 0},
  60     {RID_XPLUSY, RID_XPLUSY_HELP}, {RID_XMINUSY, RID_XMINUSY_HELP},
  61     {RID_XCDOTY, RID_XCDOTY_HELP}, {RID_XTIMESY, RID_XTIMESY_HELP},
  62     {RID_XSYMTIMESY, RID_XSYMTIMESY_HELP}, {RID_XOTIMESY, RID_XOTIMESY_HELP},
  63     {RID_XOVERY, RID_XOVERY_HELP},
  64     {RID_XDIVY, RID_XDIVY_HELP}, {RID_XSYMDIVIDEY, RID_XSYMDIVIDEY_HELP},
  65     {RID_XCIRCY, RID_XCIRCY_HELP}, {RID_XWIDESLASHY, RID_XWIDESLASHY_HELP},
  66     {RID_XWIDEBSLASHY, RID_XWIDEBSLASHY_HELP},
  67     {0xFFFF, 0},
  68     {RID_NEGX, RID_NEGX_HELP}, {RID_XANDY, RID_XANDY_HELP}, {RID_XORY, RID_XORY_HELP},
  69 };
  70
  71 const sal_uInt16 SmElementsControl::aRelationsList[][2] =
  72 {
  73     {RID_XEQY, RID_XEQY_HELP}, {RID_XNEQY, RID_XNEQY_HELP}, {RID_XLTY, RID_XLTY_HELP},
  74     {RID_XLEY, RID_XLEY_HELP}, {RID_XLESLANTY, RID_XLESLANTY_HELP}, {RID_XGTY, RID_XGTY_HELP},
  75     {RID_XGEY, RID_XGEY_HELP}, {RID_XGESLANTY, RID_XGESLANTY_HELP},
  76     {RID_XLLY, RID_XLLY_HELP}, {RID_XGGY, RID_XGGY_HELP},
  77     {0xFFFF, 0},
  78     {RID_XAPPROXY, RID_XAPPROXY_HELP}, {RID_XSIMY, RID_XSIMY_HELP}, {RID_XSIMEQY, RID_XSIMEQY_HELP},
  79     {RID_XEQUIVY, RID_XEQUIVY_HELP}, {RID_XPROPY, RID_XPROPY_HELP}, {RID_XPARALLELY, RID_XPARALLELY_HELP},
  80     {RID_XORTHOY, RID_XORTHOY_HELP}, {RID_XDIVIDESY, RID_XDIVIDESY_HELP}, {RID_XNDIVIDESY, RID_XNDIVIDESY_HELP},
  81     {RID_XTOWARDY, RID_XTOWARDY_HELP},
  82     {0xFFFF, 0},
  83     {RID_DLARROW, RID_DLARROW_HELP}, {RID_DLRARROW, RID_DLRARROW_HELP}, {RID_DRARROW, RID_DRARROW_HELP},
  84     {0xFFFF, 0},
  85     {RID_XPRECEDESY, RID_XPRECEDESY_HELP}, {RID_XSUCCEEDSY, RID_XSUCCEEDSY_HELP},
  86     {RID_XPRECEDESEQUALY, RID_XPRECEDESEQUALY_HELP}, {RID_XSUCCEEDSEQUALY, RID_XSUCCEEDSEQUALY_HELP},
  87     {RID_XPRECEDESEQUIVY, RID_XPRECEDESEQUIVY_HELP}, {RID_XSUCCEEDSEQUIVY, RID_XSUCCEEDSEQUIVY_HELP},
  88     {RID_XNOTPRECEDESY, RID_XNOTPRECEDESY_HELP}, {RID_XNOTSUCCEEDSY, RID_XNOTSUCCEEDSY_HELP},
  89 };
  90
  91 const sal_uInt16 SmElementsControl::aSetOperations[][2] =
  92 {
  93     {RID_XINY, RID_XINY_HELP}, {RID_XNOTINY, RID_XNOTINY_HELP}, {RID_XOWNSY, RID_XOWNSY_HELP},
  94     {0xFFFF, 0},
  95     {RID_XINTERSECTIONY, RID_XINTERSECTIONY_HELP}, {RID_XUNIONY, RID_XUNIONY_HELP},
  96     {RID_XSETMINUSY, RID_XSETMINUSY_HELP}, {RID_XSLASHY, RID_XSLASHY_HELP},
  97     {RID_XSUBSETY, RID_XSUBSETY_HELP}, {RID_XSUBSETEQY, RID_XSUBSETEQY_HELP},
  98     {RID_XSUPSETY, RID_XSUPSETY_HELP}, {RID_XSUPSETEQY, RID_XSUPSETEQY_HELP},
  99     {RID_XNSUBSETY, RID_XNSUBSETY_HELP}, {RID_XNSUBSETEQY, RID_XNSUBSETEQY_HELP},
 100     {RID_XNSUPSETY, RID_XNSUPSETY_HELP}, {RID_XNSUPSETEQY, RID_XNSUPSETEQY_HELP},
 101     {0xFFFF, 0},
 102     {RID_EMPTYSET, RID_EMPTYSET_HELP}, {RID_ALEPH, RID_ALEPH_HELP}, {RID_SETN, RID_SETN_HELP},
 103     {RID_SETZ, RID_SETZ_HELP}, {RID_SETQ, RID_SETQ_HELP}, {RID_SETR, RID_SETR_HELP}, {RID_SETC, RID_SETC_HELP}
 104 };
 105
 106 const sal_uInt16 SmElementsControl::aFunctions[][2] =
 107 {
 108     {RID_ABSX, RID_ABSX_HELP}, {RID_FACTX, RID_FACTX_HELP}, {RID_SQRTX, RID_SQRTX_HELP},
 109     {RID_NROOTXY, RID_NROOTXY_HELP}, {RID_RSUPX, RID_RSUPX_HELP}, {RID_EX, RID_EX_HELP},
 110     {RID_LNX, RID_LNX_HELP}, {RID_EXPX, RID_EXPX_HELP}, {RID_LOGX, RID_LOGX_HELP},
 111     {0xFFFF, 0},
 112     {RID_SINX, RID_SINX_HELP}, {RID_COSX, RID_COSX_HELP}, {RID_TANX, RID_TANX_HELP}, {RID_COTX, RID_COTX_HELP},
 113     {RID_SINHX, RID_SINHX_HELP}, {RID_COSHX, RID_COSHX_HELP}, {RID_TANHX, RID_TANHX_HELP},
 114     {RID_COTHX, RID_COTHX_HELP},
 115     {0xFFFF, 0},
 116     {RID_ARCSINX, RID_ARCSINX_HELP}, {RID_ARCCOSX, RID_ARCCOSX_HELP}, {RID_ARCTANX, RID_ARCTANX_HELP},
 117     {RID_ARCCOTX, RID_ARCCOTX_HELP}, {RID_ARSINHX, RID_ARSINHX_HELP}, {RID_ARCOSHX, RID_ARCOSHX_HELP},
 118     {RID_ARTANHX, RID_ARTANHX_HELP}, {RID_ARCOTHX, RID_ARCOTHX_HELP}
 119 };
 120
 121 const sal_uInt16 SmElementsControl::aOperators[][2] =
 122 {
 123     {RID_LIMX, RID_LIMX_HELP}, {RID_LIM_FROMX, RID_LIM_FROMX_HELP},
 124     {RID_LIM_TOX, RID_LIM_TOX_HELP}, {RID_LIM_FROMTOX, RID_LIM_FROMTOX_HELP},
 125     {0xFFFF, 0},
 126     {RID_SUMX, RID_SUMX_HELP}, {RID_SUM_FROMX, RID_SUM_FROMX_HELP},
 127     {RID_SUM_TOX, RID_SUM_TOX_HELP}, {RID_SUM_FROMTOX, RID_SUM_FROMTOX_HELP},
 128     {0xFFFF, 0},
 129     {RID_PRODX, RID_PRODX_HELP}, {RID_PROD_FROMX, RID_PROD_FROMX_HELP},
 130     {RID_PROD_TOX, RID_PROD_TOX_HELP}, {RID_PROD_FROMTOX, RID_PROD_FROMTOX_HELP},
 131     {0xFFFF, 0},
 132     {RID_COPRODX, RID_COPRODX_HELP}, {RID_COPROD_FROMX, RID_COPROD_FROMX_HELP},
 133     {RID_COPROD_TOX, RID_COPROD_TOX_HELP}, {RID_COPROD_FROMTOX, RID_COPROD_FROMTOX_HELP},
 134     {0xFFFF, 0},
 135     {RID_INTX, RID_INTX_HELP}, {RID_INT_FROMX, RID_INT_FROMX_HELP},
 136     {RID_INT_TOX, RID_INT_TOX_HELP}, {RID_INT_FROMTOX, RID_INT_FROMTOX_HELP},
 137     {0xFFFF, 0},
 138     {RID_IINTX, RID_IINTX_HELP}, {RID_IINT_FROMX, RID_IINT_FROMX_HELP},
 139     {RID_IINT_TOX, RID_IINT_TOX_HELP}, {RID_IINT_FROMTOX, RID_IINT_FROMTOX_HELP},
 140     {0xFFFF, 0},
 141     {RID_IIINTX, RID_IIINTX_HELP}, {RID_IIINT_FROMX, RID_IIINT_FROMX_HELP},
 142     {RID_IIINT_TOX, RID_IIINT_TOX_HELP}, {RID_IIINT_FROMTOX, RID_IIINT_FROMTOX_HELP},
 143     {0xFFFF, 0},
 144     {RID_LINTX, RID_LINTX_HELP}, {RID_LINT_FROMX, RID_LINT_FROMX_HELP},
 145     {RID_LINT_TOX, RID_LINT_TOX_HELP}, {RID_LINT_FROMTOX, RID_LINT_FROMTOX_HELP},
 146     {0xFFFF, 0},
 147     {RID_LLINTX, RID_LINTX_HELP}, {RID_LLINT_FROMX, RID_LLINT_FROMX_HELP},
 148     {RID_LLINT_TOX, RID_LINT_TOX_HELP}, {RID_LLINT_FROMTOX, RID_LLINT_FROMTOX_HELP},
 149     {0xFFFF, 0},
 150     {RID_LLLINTX, RID_LINTX_HELP}, {RID_LLLINT_FROMX, RID_LLLINT_FROMX_HELP},
 151     {RID_LLLINT_TOX, RID_LINT_TOX_HELP}, {RID_LLLINT_FROMTOX, RID_LLLINT_FROMTOX_HELP},
 152 };
 153
 154 const sal_uInt16 SmElementsControl::aAttributes[][2] =
 155 {
 156     {RID_ACUTEX, RID_ACUTEX_HELP}, {RID_GRAVEX, RID_GRAVEX_HELP}, {RID_BREVEX, RID_BREVEX_HELP},
 157     {RID_CIRCLEX, RID_CIRCLEX_HELP}, {RID_DOTX, RID_DOTX_HELP}, {RID_DDOTX, RID_DDOTX_HELP},
 158     {RID_DDDOTX, RID_DDDOTX_HELP}, {RID_BARX, RID_BARX_HELP}, {RID_VECX, RID_VECX_HELP},
 159     {RID_TILDEX, RID_TILDEX_HELP}, {RID_HATX, RID_HATX_HELP}, {RID_CHECKX, RID_CHECKX_HELP},
 160     {0xFFFF, 0},
 161     {RID_WIDEVECX, RID_WIDEVECX_HELP}, {RID_WIDETILDEX, RID_WIDETILDEX_HELP}, {RID_WIDEHATX, RID_WIDEHATX_HELP},
 162     {RID_OVERLINEX, RID_OVERLINEX_HELP}, {RID_UNDERLINEX, RID_UNDERLINEX_HELP}, {RID_OVERSTRIKEX, RID_OVERSTRIKEX_HELP},
 163     {0xFFFF, 0},
 164     {RID_PHANTOMX, RID_PHANTOMX_HELP}, {RID_BOLDX, RID_BOLDX_HELP}, {RID_ITALX, RID_ITALX_HELP},
 165     {RID_SIZEXY, RID_SIZEXY_HELP}, {RID_FONTXY, RID_FONTXY_HELP},
 166     {0xFFFF, 0},
 167     {RID_COLORX_BLACK, RID_COLORX_BLACK_HELP}, {RID_COLORX_BLUE, RID_COLORX_BLUE_HELP},
 168     {RID_COLORX_GREEN, RID_COLORX_GREEN_HELP}, {RID_COLORX_RED, RID_COLORX_RED_HELP},
 169     {RID_COLORX_CYAN, RID_COLORX_CYAN_HELP}, {RID_COLORX_MAGENTA, RID_COLORX_MAGENTA_HELP},
 170     {RID_COLORX_YELLOW, RID_COLORX_YELLOW_HELP}, {RID_COLORX_GRAY, RID_COLORX_GRAY_HELP},
 171     {RID_COLORX_LIME, RID_COLORX_LIME_HELP}, {RID_COLORX_MAROON, RID_COLORX_MAROON_HELP},
 172     {RID_COLORX_NAVY, RID_COLORX_NAVY_HELP}, {RID_COLORX_OLIVE, RID_COLORX_OLIVE_HELP},
 173     {RID_COLORX_PURPLE, RID_COLORX_PURPLE_HELP}, {RID_COLORX_SILVER, RID_COLORX_SILVER_HELP},
 174     {RID_COLORX_TEAL, RID_COLORX_TEAL_HELP}
 175 };
 176
 177 const sal_uInt16 SmElementsControl::aBrackets[][2] =
 178 {
 179     {RID_LRGROUPX, RID_LRGROUPX_HELP},
 180     {0xFFFF, 0},
 181     {RID_LRPARENTX, RID_LRPARENTX_HELP}, {RID_LRBRACKETX, RID_LRBRACKETX_HELP},
 182     {RID_LRDBRACKETX, RID_LRDBRACKETX_HELP}, {RID_LRBRACEX, RID_LRBRACEX_HELP},
 183     {RID_LRANGLEX, RID_LRANGLEX_HELP}, {RID_LMRANGLEXY, RID_LMRANGLEXY_HELP},
 184     {RID_LRCEILX, RID_LRCEILX_HELP}, {RID_LRFLOORX, RID_LRFLOORX_HELP},
 185     {RID_LRLINEX, RID_LRLINEX_HELP}, {RID_LRDLINEX, RID_LRDLINEX_HELP},
 186     {0xFFFF, 0},
 187     {RID_SLRPARENTX, RID_SLRPARENTX_HELP}, {RID_SLRBRACKETX, RID_SLRBRACKETX_HELP},
 188     {RID_SLRDBRACKETX, RID_SLRDBRACKETX_HELP}, {RID_SLRBRACEX, RID_SLRBRACEX_HELP},
 189     {RID_SLRANGLEX, RID_SLRANGLEX_HELP}, {RID_SLMRANGLEXY, RID_SLMRANGLEXY_HELP},
 190     {RID_SLRCEILX, RID_SLRCEILX_HELP}, {RID_SLRFLOORX, RID_SLRFLOORX_HELP},
 191     {RID_SLRLINEX, RID_SLRLINEX_HELP}, {RID_SLRDLINEX, RID_SLRDLINEX_HELP},
 192     {RID_XEVALUATEDATY, RID_XEVALUATEDATY_HELP},
 193     {0XFFFF, 0},
 194     {RID_XOVERBRACEY, RID_XOVERBRACEY_HELP}, {RID_XUNDERBRACEY, RID_XUNDERBRACEY_HELP},
 195 };
 196
 197 const sal_uInt16 SmElementsControl::aFormats[][2] =
 198 {
 199     {RID_RSUPX, RID_RSUPX_HELP}, {RID_RSUBX, RID_RSUBX_HELP}, {RID_LSUPX, RID_LSUPX_HELP},
 200     {RID_LSUBX, RID_LSUBX_HELP}, {RID_CSUPX, RID_CSUPX_HELP}, {RID_CSUBX, RID_CSUBX_HELP},
 201     {0xFFFF, 0},
 202     {RID_NEWLINE, RID_NEWLINE_HELP}, {RID_SBLANK, RID_SBLANK_HELP}, {RID_BLANK, RID_BLANK_HELP},
 203     {RID_NOSPACE, RID_NOSPACE_HELP},
 204     {RID_ALIGNLX, RID_ALIGNLX_HELP}, {RID_ALIGNCX, RID_ALIGNCX_HELP}, {RID_ALIGNRX, RID_ALIGNRX_HELP},
 205     {0xFFFF, 0},
 206     {RID_BINOMXY, RID_BINOMXY_HELP}, {RID_STACK, RID_STACK_HELP},
 207     {RID_MATRIX, RID_MATRIX_HELP},
 208 };
 209
 210 const sal_uInt16 SmElementsControl::aOthers[][2] =
 211 {
 212     {RID_INFINITY, RID_INFINITY_HELP}, {RID_PARTIAL, RID_PARTIAL_HELP}, {RID_NABLA, RID_NABLA_HELP},
 213     {RID_EXISTS, RID_EXISTS_HELP}, {RID_NOTEXISTS, RID_NOTEXISTS_HELP}, {RID_FORALL, RID_FORALL_HELP},
 214     {RID_HBAR, RID_HBAR_HELP}, {RID_LAMBDABAR, RID_LAMBDABAR_HELP}, {RID_RE, RID_RE_HELP},
 215     {RID_IM, RID_IM_HELP}, {RID_WP, RID_WP_HELP},
 216     {0xFFFF, 0},
 217     {RID_LEFTARROW, RID_LEFTARROW_HELP}, {RID_RIGHTARROW, RID_RIGHTARROW_HELP}, {RID_UPARROW, RID_UPARROW_HELP},
 218     {RID_DOWNARROW, RID_DOWNARROW_HELP},
 219     {0xFFFF, 0},
 220     {RID_DOTSLOW, RID_DOTSLOW_HELP}, {RID_DOTSAXIS, RID_DOTSAXIS_HELP}, {RID_DOTSVERT, RID_DOTSVERT_HELP},
 221     {RID_DOTSUP, RID_DOTSUP_HELP}, {RID_DOTSDOWN, RID_DOTSDOWN_HELP}
 222 };
 223
 224 SmElementsControl::SmElementsControl(vcl::Window *pParent)
 225     : Control(pParent, WB_TABSTOP)
 226     , mpDocShell(new SmDocShell(SfxModelFlags::EMBEDDED_OBJECT))
 227     , maCurrentSetId(0)
 228     , mpCurrentElement(nullptr)
 229     , mbVerticalMode(true)
 230     , mxScroll(VclPtr<ScrollBar>::Create(this, WB_VERT))
 231 {
 232     set_id("element_selector");
 233     SetMapMode( MapMode(MapUnit::Map100thMM) );
 234     SetDrawMode( DrawModeFlags::Default );
 235     SetLayoutMode( ComplexTextLayoutFlags::Default );
 236     SetDigitLanguage( LANGUAGE_ENGLISH );
 237
 238     maFormat.SetBaseSize(PixelToLogic(Size(0, SmPtsTo100th_mm(12))));
 239
 240     mxScroll->SetScrollHdl( LINK(this, SmElementsControl, ScrollHdl) );
 241     mxScroll->Show();
 242 }
 243
 244 SmElementsControl::~SmElementsControl()
 245 {
 246     disposeOnce();
 247 }
 248
 249 void SmElementsControl::dispose()
 250 {
 251     mpDocShell->DoClose();
 252     mxScroll.disposeAndClear();
 253     Control::dispose();
 254 }
 255
 256 void SmElementsControl::setVerticalMode(bool bVerticalMode)
 257 {
 258     mbVerticalMode = bVerticalMode;
 259 }
 260
 261 void SmElementsControl::LayoutOrPaintContents(vcl::RenderContext *pContext)
 262 {
 263     bool bOldVisibleState = mxScroll->IsVisible();
 264
 265     sal_Int32 nScrollbarWidth = bOldVisibleState ? GetSettings().GetStyleSettings().GetScrollBarSize() : 0;
 266
 267     sal_Int32 nControlWidth = GetOutputSizePixel().Width() - nScrollbarWidth;
 268     sal_Int32 nControlHeight = GetOutputSizePixel().Height();
 269
 270     sal_Int32 boxX = maMaxElementDimensions.Width()  + 10;
 271     sal_Int32 boxY = maMaxElementDimensions.Height() + 10;
 272
 273     sal_Int32 x = 0;
 274     sal_Int32 y = -mxScroll->GetThumbPos();
 275
 276     sal_Int32 perLine = 0;
 277
 278     if (mbVerticalMode)
 279         perLine = nControlHeight / boxY;
 280     else
 281         perLine = nControlWidth / boxX;
 282
 283     if (perLine <= 0)
 284     {
 285         perLine = 1;
 286     }
 287
 288     if (mbVerticalMode)
 289         boxY = nControlHeight / perLine;
 290     else
 291         boxX = nControlWidth / perLine;
 292
 293     for (std::unique_ptr<SmElement> & i : maElementList)
 294     {
 295         SmElement* element = i.get();
 296         if (element->isSeparator())
 297         {
 298             if (mbVerticalMode)
 299             {
 300                 x += boxX;
 301                 y = 0;
 302
 303                 Rectangle aSelectionRectangle(x + 5 - 1, y + 5,
 304                                               x + 5 + 1, nControlHeight - 5);
 305
 306                 if (pContext)
 307                     pContext->DrawRect(PixelToLogic(aSelectionRectangle));
 308                 x += 10;
 309             }
 310             else
 311             {
 312                 x = 0;
 313                 y += boxY;
 314
 315                 Rectangle aSelectionRectangle(x + 5, y + 5 - 1,
 316                                               nControlWidth - 5, y + 5 + 1);
 317
 318                 if (pContext)
 319                     pContext->DrawRect(PixelToLogic(aSelectionRectangle));
 320                 y += 10;
 321             }
 322         }
 323         else
 324         {
 325             Size aSizePixel = LogicToPixel(Size(element->getNode()->GetWidth(),
 326                                                 element->getNode()->GetHeight()));
 327             if (mbVerticalMode)
 328             {
 329                 if (y + boxY > nControlHeight)
 330                 {
 331                     x += boxX;
 332                     y = 0;
 333                 }
 334             }
 335             else
 336             {
 337                 if ( x + boxX > nControlWidth)
 338                 {
 339                     x = 0;
 340                     y += boxY;
 341                 }
 342             }
 343
 344             if (mpCurrentElement == element && pContext)
 345             {
 346                 pContext->Push(PushFlags::FILLCOLOR | PushFlags::LINECOLOR);
 347                 pContext->SetFillColor(Color(230, 230, 230));
 348                 pContext->SetLineColor(Color(230, 230, 230));
 349
 350                 pContext->DrawRect(PixelToLogic(Rectangle(x + 2, y + 2, x + boxX - 2, y + boxY - 2)));
 351                 pContext->Pop();
 352             }
 353
 354             Point location(x + ((boxX - aSizePixel.Width()) / 2),
 355                            y + ((boxY - aSizePixel.Height()) / 2));
 356
 357             if (pContext)
 358                 SmDrawingVisitor(*pContext, PixelToLogic(location), element->getNode().get());
 359
 360             element->mBoxLocation = Point(x,y);
 361             element->mBoxSize = Size(boxX, boxY);
 362
 363             if (mbVerticalMode)
 364                 y += boxY;
 365             else
 366                 x += boxX;
 367         }
 368     }
 369
 370     if (!pContext)
 371     {
 372         sal_Int32 nTotalControlHeight = y + boxY + mxScroll->GetThumbPos();
 373
 374         if (nTotalControlHeight > GetOutputSizePixel().Height())
 375         {
 376             mxScroll->SetRangeMax(nTotalControlHeight);
 377             mxScroll->SetPosSizePixel(Point(nControlWidth, 0), Size(nScrollbarWidth, nControlHeight));
 378             mxScroll->SetVisibleSize(nControlHeight);
 379             mxScroll->Show();
 380         }
 381         else
 382         {
 383             mxScroll->SetThumbPos(0);
 384             mxScroll->Hide();
 385         }
 386     }
 387 }
 388
 389 void SmElementsControl::Paint(vcl::RenderContext& rRenderContext, const Rectangle&)
 390 {
 391     rRenderContext.Push();
 392     LayoutOrPaintContents(&rRenderContext);
 393     rRenderContext.Pop();
 394 }
 395
 396 void SmElementsControl::RequestHelp(const HelpEvent& rHEvt)
 397 {
 398     if (rHEvt.GetMode() & (HelpEventMode::BALLOON | HelpEventMode::QUICK))
 399     {
 400         SmElement* pHelpElement = mpCurrentElement;
 401
 402         if (!rHEvt.KeyboardActivated())
 403         {
 404             Point aHelpEventPos(ScreenToOutputPixel(rHEvt.GetMousePosPixel()));
 405             for (std::unique_ptr<SmElement> & i : maElementList)
 406             {
 407                 SmElement* pElement = i.get();
 408                 Rectangle aRect(pElement->mBoxLocation, pElement->mBoxSize);
 409                 if (aRect.IsInside(aHelpEventPos))
 410                 {
 411                     pHelpElement = pElement;
 412                     break;
 413                 }
 414             }
 415         }
 416
 417         if (!pHelpElement)
 418             return;
 419
 420         Rectangle aHelpRect(pHelpElement->mBoxLocation, pHelpElement->mBoxSize);
 421         Point aPt = OutputToScreenPixel( aHelpRect.TopLeft() );
 422         aHelpRect.Left() = aPt.X();
 423         aHelpRect.Top()= aPt.Y();
 424         aPt = OutputToScreenPixel( aHelpRect.BottomRight() );
 425         aHelpRect.Right() = aPt.X();
 426         aHelpRect.Bottom() = aPt.Y();
 427
 428         // get text and display it
 429         OUString aStr = pHelpElement->getHelpText();
 430         if (rHEvt.GetMode() & HelpEventMode::BALLOON)
 431         {
 432             Help::ShowBalloon(this, aHelpRect.Center(), aHelpRect, aStr);
 433         }
 434         else
 435             Help::ShowQuickHelp(this, aHelpRect, aStr, aStr, QuickHelpFlags::CtrlText);
 436         return;
 437     }
 438
 439     Control::RequestHelp(rHEvt);
 440 }
 441
 442 void SmElementsControl::MouseMove( const MouseEvent& rMouseEvent )
 443 {
 444     SmElement* pPrevElement = mpCurrentElement;
 445     mpCurrentElement = nullptr;
 446     if (rMouseEvent.IsLeaveWindow())
 447     {
 448         LayoutOrPaintContents();
 449         Invalidate();
 450         return;
 451     }
 452     if (Rectangle(Point(0, 0), GetOutputSizePixel()).IsInside(rMouseEvent.GetPosPixel()))
 453     {
 454         for (std::unique_ptr<SmElement> & i : maElementList)
 455         {
 456             SmElement* element = i.get();
 457             Rectangle rect(element->mBoxLocation, element->mBoxSize);
 458             if (rect.IsInside(rMouseEvent.GetPosPixel()))
 459             {
 460                 if (pPrevElement != element)
 461                 {
 462                     mpCurrentElement = element;
 463                     LayoutOrPaintContents();
 464                     Invalidate();
 465                     return;
 466                 }
 467             }
 468         }
 469         return;
 470     }
 471
 472     Control::MouseMove(rMouseEvent);
 473 }
 474
 475 void SmElementsControl::MouseButtonDown(const MouseEvent& rMouseEvent)
 476 {
 477     GrabFocus();
 478
 479     if (rMouseEvent.IsLeft() && Rectangle(Point(0, 0), GetOutputSizePixel()).IsInside(rMouseEvent.GetPosPixel()) && maSelectHdlLink.IsSet())
 480     {
 481         for (std::unique_ptr<SmElement> & i : maElementList)
 482         {
 483             SmElement* element = i.get();
 484             Rectangle rect(element->mBoxLocation, element->mBoxSize);
 485             if (rect.IsInside(rMouseEvent.GetPosPixel()))
 486             {
 487                 maSelectHdlLink.Call(*element);
 488                 return;
 489             }
 490         }
 491     }
 492     else
 493     {
 494         Control::MouseButtonDown (rMouseEvent);
 495     }
 496 }
 497
 498 IMPL_LINK_NOARG( SmElementsControl, ScrollHdl, ScrollBar*, void )
 499 {
 500     DoScroll(mxScroll->GetDelta());
 501 }
 502
 503 void SmElementsControl::DoScroll(long nDelta)
 504 {
 505     Point aNewPoint = mxScroll->GetPosPixel();
 506     Rectangle aRect(Point(), GetOutputSize());
 507     aRect.Right() -= mxScroll->GetSizePixel().Width();
 508     Scroll( 0, -nDelta, aRect );
 509     mxScroll->SetPosPixel(aNewPoint);
 510     LayoutOrPaintContents();
 511     Invalidate();
 512 }
 513
 514 void SmElementsControl::addElement(const OUString& aElementVisual, const OUString& aElementSource, const OUString& aHelpText)
 515 {
 516     std::unique_ptr<SmNode> pNode(SmParser().ParseExpression(aElementVisual));
 517
 518     pNode->Prepare(maFormat, *mpDocShell);
 519     pNode->SetSize(Fraction(10,8));
 520     pNode->Arrange(*this, maFormat);
 521
 522     Size aSizePixel = LogicToPixel(Size(pNode->GetWidth(), pNode->GetHeight()), MapUnit::Map100thMM);
 523     if (aSizePixel.Width() > maMaxElementDimensions.Width()) {
 524         maMaxElementDimensions.Width() = aSizePixel.Width();
 525     }
 526
 527     if (aSizePixel.Height() > maMaxElementDimensions.Height()) {
 528         maMaxElementDimensions.Height() = aSizePixel.Height();
 529     }
 530
 531     maElementList.push_back(o3tl::make_unique<SmElement>(std::move(pNode), aElementSource, aHelpText));
 532 }
 533
 534 void SmElementsControl::setElementSetId(sal_uInt16 aSetId)
 535 {
 536     maCurrentSetId = aSetId;
 537     maMaxElementDimensions = Size();
 538     build();
 539 }
 540
 541 void SmElementsControl::addElements(const sal_uInt16 aElementsArray[][2], sal_uInt16 aElementsArraySize)
 542 {
 543     for (sal_uInt16 i = 0; i < aElementsArraySize ; i++)
 544     {
 545         sal_uInt16 aElementId = aElementsArray[i][0];
 546         sal_uInt16 aElementIdHelp = aElementsArray[i][1];
 547         if (aElementId == 0xFFFF) {
 548             maElementList.push_back(o3tl::make_unique<SmElementSeparator>());
 549         } else {
 550             if (aElementId == RID_NEWLINE)
 551                 addElement(OUString( "\xe2\x86\xb5", 3, RTL_TEXTENCODING_UTF8 ), SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 552             else if (aElementId == RID_SBLANK)
 553                 addElement("\"`\"", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 554             else if (aElementId == RID_BLANK)
 555                 addElement("\"~\"", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 556             else if (aElementId == RID_PHANTOMX)
 557                 addElement("\"" + SM_RESSTR(STR_HIDE) +"\"", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 558             else if (aElementId == RID_BOLDX)
 559                 addElement("bold B", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 560             else if (aElementId == RID_ITALX)
 561                 addElement("ital I", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 562             else if (aElementId == RID_SIZEXY)
 563                 addElement("\"" + SM_RESSTR(STR_SIZE) + "\"", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 564             else if (aElementId == RID_FONTXY)
 565                 addElement("\"" + SM_RESSTR(STR_FONT) + "\"", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 566             else if (aElementId == RID_COLORX_BLACK)
 567                 addElement("color black { \"" + SM_RESSTR(STR_BLACK) + "\" }", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 568             else if (aElementId == RID_COLORX_BLUE)
 569                 addElement("color blue { \"" + SM_RESSTR(STR_BLUE) + "\" }", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 570             else if (aElementId == RID_COLORX_GREEN)
 571                 addElement("color green { \"" + SM_RESSTR(STR_GREEN) + "\" }", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 572             else if (aElementId == RID_COLORX_RED)
 573                 addElement("color red { \"" + SM_RESSTR(STR_RED) + "\" }", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 574             else if (aElementId == RID_COLORX_CYAN)
 575                 addElement("color cyan { \"" + SM_RESSTR(STR_CYAN) + "\" }", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 576             else if (aElementId == RID_COLORX_MAGENTA)
 577                 addElement("color magenta { \"" + SM_RESSTR(STR_MAGENTA) + "\" }", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 578             else if (aElementId == RID_COLORX_YELLOW)
 579                 addElement("color yellow { \"" + SM_RESSTR(STR_YELLOW) + "\" }", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 580             else if (aElementId == RID_COLORX_GRAY)
 581                 addElement("color gray { \"" + SM_RESSTR(STR_GRAY) + "\" }", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 582             else if (aElementId == RID_COLORX_LIME)
 583                 addElement("color lime { \"" + SM_RESSTR(STR_LIME) + "\" }", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 584             else if (aElementId == RID_COLORX_MAROON)
 585                 addElement("color maroon { \"" + SM_RESSTR(STR_MAROON) + "\" }", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 586             else if (aElementId == RID_COLORX_NAVY)
 587                 addElement("color navy { \"" + SM_RESSTR(STR_NAVY) + "\" }", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 588             else if (aElementId == RID_COLORX_OLIVE)
 589                 addElement("color olive { \"" + SM_RESSTR(STR_OLIVE) + "\" }", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 590             else if (aElementId == RID_COLORX_PURPLE)
 591                 addElement("color purple { \"" + SM_RESSTR(STR_PURPLE) + "\" }", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 592             else if (aElementId == RID_COLORX_SILVER)
 593                 addElement("color silver { \"" + SM_RESSTR(STR_SILVER) + "\" }", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 594             else if (aElementId == RID_COLORX_TEAL)
 595                 addElement("color teal { \"" + SM_RESSTR(STR_TEAL) + "\" }", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 596             else if (aElementId == RID_ALIGNLX)
 597                 addElement("\"" + SM_RESSTR(STR_ALIGN_LEFT) + "\"", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 598             else if (aElementId == RID_ALIGNCX)
 599                 addElement("\"" + SM_RESSTR(STR_ALIGN_CENTER) + "\"", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 600             else if (aElementId == RID_ALIGNRX)
 601                 addElement("\"" + SM_RESSTR(STR_ALIGN_RIGHT) + "\"", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 602
 603             else if (aElementId == RID_SLRPARENTX)
 604                 addElement("left ( binom{<?>}{<?>} right ) ", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 605             else if (aElementId == RID_SLRBRACKETX)
 606                 addElement("left [ binom{<?>}{<?>} right ] ", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 607             else if (aElementId == RID_SLRDBRACKETX)
 608                 addElement("left ldbracket binom{<?>}{<?>} right rdbracket ", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 609             else if (aElementId == RID_SLRBRACEX)
 610                 addElement("left lbrace binom{<?>}{<?>} right rbrace ", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 611             else if (aElementId == RID_SLRANGLEX)
 612                 addElement("left langle binom{<?>}{<?>} right rangle ", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 613             else if (aElementId == RID_SLRCEILX)
 614                 addElement("left lceil binom{<?>}{<?>} right rceil ", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 615             else if (aElementId == RID_SLRFLOORX)
 616                 addElement("left lfloor binom{<?>}{<?>} right rfloor ", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 617
 618             else if (aElementId == RID_SLRLINEX)
 619                 addElement("left lline binom{<?>}{<?>} right rline ", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 620             else if (aElementId == RID_SLRDLINEX)
 621                 addElement("left ldline binom{<?>}{<?>} right rdline ", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 622             else if (aElementId == RID_SLMRANGLEXY)
 623                 addElement("left langle binom{<?>}{<?>} mline binom{<?>}{<?>} right rangle ", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 624
 625             else if (aElementId == RID_XOVERBRACEY)
 626                 addElement("{<?><?><?>} overbrace {<?>} ", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 627             else if (aElementId == RID_XUNDERBRACEY)
 628                 addElement("{<?><?><?>} underbrace {<?>} ", SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 629             else
 630                 addElement(SM_RESSTR(aElementId), SM_RESSTR(aElementId), SM_RESSTR(aElementIdHelp));
 631         }
 632     }
 633 }
 634
 635 void SmElementsControl::build()
 636 {
 637     maElementList.clear();
 638
 639     switch(maCurrentSetId)
 640     {
 641         case RID_CATEGORY_UNARY_BINARY_OPERATORS:
 642             addElements(aUnaryBinaryOperatorsList, SAL_N_ELEMENTS(aUnaryBinaryOperatorsList));
 643         break;
 644         case RID_CATEGORY_RELATIONS:
 645             addElements(aRelationsList, SAL_N_ELEMENTS(aRelationsList));
 646         break;
 647         case RID_CATEGORY_SET_OPERATIONS:
 648             addElements(aSetOperations, SAL_N_ELEMENTS(aSetOperations));
 649         break;
 650         case RID_CATEGORY_FUNCTIONS:
 651             addElements(aFunctions, SAL_N_ELEMENTS(aFunctions));
 652         break;
 653         case RID_CATEGORY_OPERATORS:
 654             addElements(aOperators, SAL_N_ELEMENTS(aOperators));
 655         break;
 656         case RID_CATEGORY_ATTRIBUTES:
 657             addElements(aAttributes, SAL_N_ELEMENTS(aAttributes));
 658         break;
 659         case RID_CATEGORY_BRACKETS:
 660             addElements(aBrackets, SAL_N_ELEMENTS(aBrackets));
 661         break;
 662         case RID_CATEGORY_FORMATS:
 663             addElements(aFormats, SAL_N_ELEMENTS(aFormats));
 664         break;
 665         case RID_CATEGORY_OTHERS:
 666             addElements(aOthers, SAL_N_ELEMENTS(aOthers));
 667         break;
 668         case RID_CATEGORY_EXAMPLES:
 669         {
 670             OUString aEquation = "C=%pi cdot d = 2 cdot %pi cdot r";
 671             addElement(aEquation, aEquation, "");
 672             aEquation = "E=mc^2";
 673             addElement(aEquation, aEquation, "");
 674             aEquation = "a^2 + b^2 = c^2";
 675             addElement(aEquation, aEquation, "");
 676             aEquation = "f ( x ) = sum from { { i = 0 } } to { infinity } { {f^{(i)}(0)} over {i!} x^i}";
 677             addElement(aEquation, aEquation, "");
 678             aEquation = "f ( x ) = {1} over {%sigma sqrt{2%pi} }func e^-{{(x-%mu)^2} over {2%sigma^2}}";
 679             addElement(aEquation, aEquation, "");
 680         }
 681         break;
 682     }
 683     LayoutOrPaintContents();
 684     Invalidate();
 685 }
 686
 687 Size SmElementsControl::GetOptimalSize() const
 688 {
 689     return LogicToPixel(Size(100, 100), MapMode(MapUnit::MapAppFont));
 690 }
 691
 692 FactoryFunction SmElementsControl::GetUITestFactory() const
 693 {
 694     return ElementSelectorUIObject::create;
 695 }
 696
 697 const sal_uInt16 SmElementsDockingWindow::aCategories[] = {
 698     RID_CATEGORY_UNARY_BINARY_OPERATORS,
 699     RID_CATEGORY_RELATIONS,
 700     RID_CATEGORY_SET_OPERATIONS,
 701     RID_CATEGORY_FUNCTIONS,
 702     RID_CATEGORY_OPERATORS,
 703     RID_CATEGORY_ATTRIBUTES,
 704     RID_CATEGORY_BRACKETS,
 705     RID_CATEGORY_FORMATS,
 706     RID_CATEGORY_OTHERS,
 707     RID_CATEGORY_EXAMPLES
 708 };
 709
 710 SmElementsDockingWindow::SmElementsDockingWindow(SfxBindings* pInputBindings, SfxChildWindow* pChildWindow, vcl::Window* pParent) :
 711     SfxDockingWindow(pInputBindings, pChildWindow, pParent, "DockingElements",
 712         "modules/smath/ui/dockingelements.ui")
 713 {
 714     mpElementsControl = VclPtr<SmElementsControl>::Create(get<vcl::Window>("box"));
 715     mpElementsControl->set_hexpand(true);
 716     mpElementsControl->set_vexpand(true);
 717     mpElementsControl->Show();
 718     get(mpElementListBox, "listbox");
 719
 720     mpElementsControl->SetBorderStyle( WindowBorderStyle::MONO );
 721
 722     mpElementListBox->SetDropDownLineCount( SAL_N_ELEMENTS(aCategories) );
 723
 724     for (sal_uInt16 nCategory : aCategories)
 725     {
 726         mpElementListBox->InsertEntry(SM_RESSTR(nCategory));
 727     }
 728
 729     mpElementListBox->SetSelectHdl(LINK(this, SmElementsDockingWindow, ElementSelectedHandle));
 730     mpElementListBox->SelectEntry(SM_RESSTR(RID_CATEGORY_UNARY_BINARY_OPERATORS));
 731
 732     mpElementsControl->SetBackground( Color( COL_WHITE ) );
 733     mpElementsControl->SetTextColor( Color( COL_BLACK ) );
 734     mpElementsControl->setElementSetId(RID_CATEGORY_UNARY_BINARY_OPERATORS);
 735     mpElementsControl->SetSelectHdl(LINK(this, SmElementsDockingWindow, SelectClickHandler));
 736 }
 737
 738 SmElementsDockingWindow::~SmElementsDockingWindow ()
 739 {
 740     disposeOnce();
 741 }
 742
 743 void SmElementsDockingWindow::dispose()
 744 {
 745     mpElementsControl.disposeAndClear();
 746     mpElementListBox.clear();
 747     SfxDockingWindow::dispose();
 748 }
 749
 750 void SmElementsDockingWindow::ToggleFloatingMode()
 751 {
 752     SfxDockingWindow::ToggleFloatingMode();
 753
 754     if (GetFloatingWindow())
 755         GetFloatingWindow()->SetMinOutputSizePixel( Size(100, 100) );
 756
 757     Invalidate();
 758 }
 759
 760 void SmElementsDockingWindow::EndDocking( const Rectangle& rReactangle, bool bFloatMode)
 761 {
 762     SfxDockingWindow::EndDocking(rReactangle, bFloatMode);
 763     bool bVertical = ( GetAlignment() == SfxChildAlignment::TOP || GetAlignment() == SfxChildAlignment::BOTTOM );
 764     mpElementsControl->setVerticalMode(bVertical);
 765 }
 766
 767 IMPL_LINK(SmElementsDockingWindow, SelectClickHandler, SmElement&, rElement, void)
 768 {
 769     SmViewShell* pViewSh = GetView();
 770
 771     if (pViewSh)
 772     {
 773         pViewSh->GetViewFrame()->GetDispatcher()->ExecuteList(
 774             SID_INSERTCOMMANDTEXT, SfxCallMode::RECORD,
 775             { new SfxStringItem(SID_INSERTCOMMANDTEXT, rElement.getText()) });
 776     }
 777 }
 778
 779 IMPL_LINK( SmElementsDockingWindow, ElementSelectedHandle, ListBox&, rList, void)
 780 {
 781     for (sal_uInt16 aCurrentCategory : aCategories)
 782     {
 783         OUString aCurrentCategoryString = SM_RESSTR(aCurrentCategory);
 784         if (aCurrentCategoryString == rList.GetSelectEntry())
 785         {
 786             mpElementsControl->setElementSetId(aCurrentCategory);
 787             return;
 788         }
 789     }
 790 }
 791
 792 SmViewShell* SmElementsDockingWindow::GetView()
 793 {
 794     SfxViewShell* pView = GetBindings().GetDispatcher()->GetFrame()->GetViewShell();
 795     return  dynamic_cast<SmViewShell*>( pView);
 796 }
 797
 798 void SmElementsDockingWindow::Resize()
 799 {
 800     bool bVertical = ( GetAlignment() == SfxChildAlignment::TOP || GetAlignment() == SfxChildAlignment::BOTTOM );
 801     mpElementsControl->setVerticalMode(bVertical);
 802
 803     SfxDockingWindow::Resize();
 804     Invalidate();
 805 }
 806
 807 SFX_IMPL_DOCKINGWINDOW_WITHID(SmElementsDockingWindowWrapper, SID_ELEMENTSDOCKINGWINDOW);
 808
 809 SmElementsDockingWindowWrapper::SmElementsDockingWindowWrapper(
 810                             vcl::Window *pParentWindow, sal_uInt16 nId,
 811                             SfxBindings *pBindings, SfxChildWinInfo *pInfo) :
 812     SfxChildWindow(pParentWindow, nId)
 813 {
 814     VclPtrInstance<SmElementsDockingWindow> pDialog(pBindings, this, pParentWindow);
 815     SetWindow(pDialog);
 816     pDialog->setDeferredProperties();
 817     pDialog->SetPosSizePixel(Point(0, 0), Size(300, 0));
 818     pDialog->Show();
 819
 820     SetAlignment(SfxChildAlignment::LEFT);
 821
 822     pDialog->Initialize( pInfo );
 823 }
 824
 825 SmElementsDockingWindowWrapper::~SmElementsDockingWindowWrapper()
 826 {
 827 }
 828
 829 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */