vcl/source/window/builder.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
  10 #include <osl/module.hxx>
  11 #include <sal/log.hxx>
  12 #include <unotools/configmgr.hxx>
  13 #include <vcl/builder.hxx>
  14 #include <vcl/button.hxx>
  15 #include <vcl/dialog.hxx>
  16 #include <vcl/edit.hxx>
  17 #include <vcl/field.hxx>
  18 #include <vcl/fixed.hxx>
  19 #include <vcl/fixedhyper.hxx>
  20 #include <vcl/layout.hxx>
  21 #include <vcl/lstbox.hxx>
  22 #include <vcl/menubtn.hxx>
  23 #include <vcl/mnemonic.hxx>
  24 #include <vcl/prgsbar.hxx>
  25 #include <vcl/scrbar.hxx>
  26 #include <vcl/svapp.hxx>
  27 #include <vcl/tabctrl.hxx>
  28 #include <vcl/tabpage.hxx>
  29 #include <vcl/toolbox.hxx>
  30 #include <vcl/vclmedit.hxx>
  31 #include <svdata.hxx>
  32 #include <svids.hrc>
  33 #include <window.h>
  34
  35 using namespace com::sun::star;
  36
  37 #ifdef DISABLE_DYNLOADING
  38 #include <dlfcn.h>              //  For RTLD_DEFAULT
  39 #endif
  40
  41 namespace
  42 {
  43     sal_uInt16 mapStockToImageResource(OString sType)
  44     {
  45         sal_uInt16 nRet = 0;
  46         if (sType == "gtk-index")
  47             nRet = SV_RESID_BITMAP_INDEX;
  48         else if (sType == "gtk-refresh")
  49             nRet = SV_RESID_BITMAP_REFRESH;
  50         return nRet;
  51     }
  52
  53     SymbolType mapStockToSymbol(OString sType)
  54     {
  55         SymbolType eRet = SYMBOL_NOSYMBOL;
  56         if (sType == "gtk-media-next")
  57             eRet = SYMBOL_NEXT;
  58         else if (sType == "gtk-media-previous")
  59             eRet = SYMBOL_PREV;
  60         else if (sType == "gtk-goto-first")
  61             eRet = SYMBOL_FIRST;
  62         else if (sType == "gtk-goto-last")
  63             eRet = SYMBOL_LAST;
  64         else if (sType == "gtk-go-back")
  65             eRet = SYMBOL_ARROW_LEFT;
  66         else if (sType == "gtk-go-forward")
  67             eRet = SYMBOL_ARROW_RIGHT;
  68         else if (sType == "gtk-go-up")
  69             eRet = SYMBOL_ARROW_UP;
  70         else if (sType == "gtk-go-down")
  71             eRet = SYMBOL_ARROW_DOWN;
  72         else if (sType == "gtk-missing-image")
  73             eRet = SYMBOL_IMAGE;
  74         else if (sType == "gtk-help")
  75             eRet = SYMBOL_HELP;
  76         else if (sType == "gtk-close")
  77             eRet = SYMBOL_CLOSE;
  78         else if (mapStockToImageResource(sType))
  79             eRet = SYMBOL_IMAGE;
  80         return eRet;
  81     }
  82 }
  83
  84 void VclBuilder::loadTranslations(const com::sun::star::lang::Locale &rLocale, const OUString& rUri)
  85 {
  86     for (int i = rLocale.Country.isEmpty() ? 1 : 0; i < 2; ++i)
  87     {
  88         OUStringBuffer aTransBuf;
  89         sal_Int32 nLastSlash = rUri.lastIndexOf('/');
  90         if (nLastSlash != -1)
  91             aTransBuf.append(rUri.copy(0, nLastSlash));
  92         else
  93         {
  94             aTransBuf.append('.');
  95             nLastSlash = 0;
  96         }
  97         aTransBuf.append("/res/").append(rLocale.Language);
  98         switch (i)
  99         {
 100             case 0:
 101                 aTransBuf.append('-').append(rLocale.Country);
 102                 break;
 103             default:
 104                 break;
 105         }
 106         sal_Int32 nEndName = rUri.lastIndexOf('.');
 107         if (nEndName == -1)
 108             nEndName = rUri.getLength();
 109         aTransBuf.append(rUri.copy(nLastSlash, nEndName-nLastSlash));
 110
 111         OUString sTransUri = aTransBuf.makeStringAndClear();
 112         try
 113         {
 114             xmlreader::XmlReader reader(sTransUri);
 115             handleTranslations(reader);
 116             break;
 117         }
 118         catch (const ::com::sun::star::uno::Exception &)
 119         {
 120         }
 121     }
 122 }
 123
 124 #if defined SAL_LOG_WARN
 125 namespace
 126 {
 127     bool isButtonType(WindowType nType)
 128     {
 129         return nType == WINDOW_PUSHBUTTON ||
 130                nType == WINDOW_OKBUTTON ||
 131                nType == WINDOW_CANCELBUTTON ||
 132                nType == WINDOW_HELPBUTTON ||
 133                nType == WINDOW_IMAGEBUTTON ||
 134                nType == WINDOW_MENUBUTTON ||
 135                nType == WINDOW_MOREBUTTON ||
 136                nType == WINDOW_SPINBUTTON;
 137     }
 138 }
 139 #endif
 140
 141 VclBuilder::VclBuilder(Window *pParent, OUString sUIDir, OUString sUIFile, OString sID, const uno::Reference<frame::XFrame>& rFrame)
 142     : m_sID(sID)
 143     , m_sHelpRoot(OUStringToOString(sUIFile, RTL_TEXTENCODING_UTF8))
 144     , m_pStringReplace(ResMgr::GetReadStringHook())
 145     , m_pParent(pParent)
 146     , m_bToplevelParentFound(false)
 147     , m_pParserState(new ParserState)
 148     , m_xFrame(rFrame)
 149 {
 150     m_bToplevelHasDeferredInit = (pParent && pParent->IsDialog()) ? ((Dialog*)pParent)->isDeferredInit() : false;
 151     m_bToplevelHasDeferredProperties = m_bToplevelHasDeferredInit;
 152
 153     sal_Int32 nIdx = m_sHelpRoot.lastIndexOf('.');
 154     if (nIdx != -1)
 155         m_sHelpRoot = m_sHelpRoot.copy(0, nIdx);
 156     m_sHelpRoot = m_sHelpRoot + OString('/');
 157
 158     OUString sUri = sUIDir + sUIFile;
 159
 160     com::sun::star::lang::Locale aLocale = Application::GetSettings().GetUILanguageTag().getLocale();
 161     bool bEN_US = aLocale.Language == "en" && aLocale.Country == "US" && aLocale.Variant.isEmpty();
 162     if (!bEN_US)
 163         loadTranslations(aLocale, sUri);
 164
 165     xmlreader::XmlReader reader(sUri);
 166
 167     handleChild(pParent, reader);
 168
 169     //Set Mnemonic widgets when everything has been imported
 170     for (std::vector<MnemonicWidgetMap>::iterator aI = m_pParserState->m_aMnemonicWidgetMaps.begin(),
 171         aEnd = m_pParserState->m_aMnemonicWidgetMaps.end(); aI != aEnd; ++aI)
 172     {
 173         FixedText *pOne = get<FixedText>(aI->m_sID);
 174         Window *pOther = get<Window>(aI->m_sValue);
 175         SAL_WARN_IF(!pOne || !pOther, "vcl", "missing member of Mnemonic Widget Mapping");
 176         if (pOne && pOther)
 177             pOne->set_mnemonic_widget(pOther);
 178     }
 179
 180     //Set a11y relations when everything has been imported
 181     for (AtkMap::iterator aI = m_pParserState->m_aAtkInfo.begin(),
 182          aEnd = m_pParserState->m_aAtkInfo.end(); aI != aEnd; ++aI)
 183     {
 184         Window *pSource = aI->first;
 185         const stringmap &rMap = aI->second;
 186
 187         for (stringmap::const_iterator aP = rMap.begin(),
 188             aEndP = rMap.end(); aP != aEndP; ++aP)
 189         {
 190             const OString &rTarget = aP->second;
 191             Window *pTarget = get<Window>(rTarget);
 192             SAL_WARN_IF(!pTarget, "vcl", "missing member of a11y relation: "
 193                 << rTarget.getStr());
 194             if (!pTarget)
 195                 continue;
 196             const OString &rType = aP->first;
 197             if (rType == "labelled-by")
 198                 pSource->SetAccessibleRelationLabeledBy(pTarget);
 199             else if (rType == "label-for")
 200                 pSource->SetAccessibleRelationLabelFor(pTarget);
 201             else if (rType == "member-of")
 202                 pSource->SetAccessibleRelationMemberOf(pTarget);
 203             else
 204             {
 205                 SAL_INFO("vcl.layout", "unhandled a11y relation :" << rType.getStr());
 206             }
 207         }
 208     }
 209
 210     //Set radiobutton groups when everything has been imported
 211     for (std::vector<RadioButtonGroupMap>::iterator aI = m_pParserState->m_aGroupMaps.begin(),
 212          aEnd = m_pParserState->m_aGroupMaps.end(); aI != aEnd; ++aI)
 213     {
 214         RadioButton *pOne = get<RadioButton>(aI->m_sID);
 215         RadioButton *pOther = get<RadioButton>(aI->m_sValue);
 216         SAL_WARN_IF(!pOne || !pOther, "vcl", "missing member of radiobutton group");
 217         if (pOne && pOther)
 218             pOne->group(*pOther);
 219     }
 220
 221     //Set ComboBox models when everything has been imported
 222     for (std::vector<ComboBoxModelMap>::iterator aI = m_pParserState->m_aModelMaps.begin(),
 223          aEnd = m_pParserState->m_aModelMaps.end(); aI != aEnd; ++aI)
 224     {
 225         ListBox *pTarget = get<ListBox>(aI->m_sID);
 226         const ListStore *pStore = get_model_by_name(aI->m_sValue);
 227         SAL_WARN_IF(!pTarget || !pStore, "vcl", "missing elements of combobox/liststore");
 228         if (pTarget && pStore)
 229             mungeModel(*pTarget, *pStore, aI->m_nActiveId);
 230     }
 231
 232     //Set TextView buffers when everything has been imported
 233     for (std::vector<TextBufferMap>::iterator aI = m_pParserState->m_aTextBufferMaps.begin(),
 234          aEnd = m_pParserState->m_aTextBufferMaps.end(); aI != aEnd; ++aI)
 235     {
 236         VclMultiLineEdit *pTarget = get<VclMultiLineEdit>(aI->m_sID);
 237         const TextBuffer *pBuffer = get_buffer_by_name(aI->m_sValue);
 238         SAL_WARN_IF(!pTarget || !pBuffer, "vcl", "missing elements of textview/textbuffer");
 239         if (pTarget && pBuffer)
 240             mungeTextBuffer(*pTarget, *pBuffer);
 241     }
 242
 243     //Set SpinButton adjustments when everything has been imported
 244     for (std::vector<WidgetAdjustmentMap>::iterator aI = m_pParserState->m_aNumericFormatterAdjustmentMaps.begin(),
 245          aEnd = m_pParserState->m_aNumericFormatterAdjustmentMaps.end(); aI != aEnd; ++aI)
 246     {
 247         NumericFormatter *pTarget = dynamic_cast<NumericFormatter*>(get<Window>(aI->m_sID));
 248         const Adjustment *pAdjustment = get_adjustment_by_name(aI->m_sValue);
 249         SAL_WARN_IF(!pTarget || !pAdjustment, "vcl", "missing elements of spinbutton/adjustment");
 250         if (pTarget && pAdjustment)
 251             mungeAdjustment(*pTarget, *pAdjustment);
 252     }
 253
 254     for (std::vector<WidgetAdjustmentMap>::iterator aI = m_pParserState->m_aTimeFormatterAdjustmentMaps.begin(),
 255          aEnd = m_pParserState->m_aTimeFormatterAdjustmentMaps.end(); aI != aEnd; ++aI)
 256     {
 257         TimeField *pTarget = dynamic_cast<TimeField*>(get<Window>(aI->m_sID));
 258         const Adjustment *pAdjustment = get_adjustment_by_name(aI->m_sValue);
 259         SAL_WARN_IF(!pTarget || !pAdjustment, "vcl", "missing elements of spinbutton/adjustment");
 260         if (pTarget && pAdjustment)
 261             mungeAdjustment(*pTarget, *pAdjustment);
 262     }
 263
 264     for (std::vector<WidgetAdjustmentMap>::iterator aI = m_pParserState->m_aDateFormatterAdjustmentMaps.begin(),
 265          aEnd = m_pParserState->m_aDateFormatterAdjustmentMaps.end(); aI != aEnd; ++aI)
 266     {
 267         DateField *pTarget = dynamic_cast<DateField*>(get<Window>(aI->m_sID));
 268         const Adjustment *pAdjustment = get_adjustment_by_name(aI->m_sValue);
 269         SAL_WARN_IF(!pTarget || !pAdjustment, "vcl", "missing elements of spinbutton/adjustment");
 270         if (pTarget && pAdjustment)
 271             mungeAdjustment(*pTarget, *pAdjustment);
 272     }
 273
 274     //Set ScrollBar adjustments when everything has been imported
 275     for (std::vector<WidgetAdjustmentMap>::iterator aI = m_pParserState->m_aScrollAdjustmentMaps.begin(),
 276          aEnd = m_pParserState->m_aScrollAdjustmentMaps.end(); aI != aEnd; ++aI)
 277     {
 278         ScrollBar *pTarget = get<ScrollBar>(aI->m_sID);
 279         const Adjustment *pAdjustment = get_adjustment_by_name(aI->m_sValue);
 280         SAL_WARN_IF(!pTarget || !pAdjustment, "vcl", "missing elements of scrollbar/adjustment");
 281         if (pTarget && pAdjustment)
 282             mungeAdjustment(*pTarget, *pAdjustment);
 283     }
 284
 285     //Set size-groups when all widgets have been imported
 286     for (std::vector<SizeGroup>::iterator aI = m_pParserState->m_aSizeGroups.begin(),
 287         aEnd = m_pParserState->m_aSizeGroups.end(); aI != aEnd; ++aI)
 288     {
 289         boost::shared_ptr< VclSizeGroup > xGroup(new VclSizeGroup);
 290
 291         for (stringmap::iterator aP = aI->m_aProperties.begin(),
 292             aEndP = aI->m_aProperties.end(); aP != aEndP; ++aP)
 293         {
 294             const OString &rKey = aP->first;
 295             const OString &rValue = aP->second;
 296             xGroup->set_property(rKey, rValue);
 297         }
 298
 299         for (std::vector<OString>::iterator aW = aI->m_aWidgets.begin(),
 300             aEndW = aI->m_aWidgets.end(); aW != aEndW; ++aW)
 301         {
 302             Window* pWindow = get<Window>(aW->getStr());
 303             pWindow->add_to_size_group(xGroup);
 304         }
 305     }
 306
 307     //Set button images when everything has been imported
 308     std::set<OString> aImagesToBeRemoved;
 309     for (std::vector<ButtonImageWidgetMap>::iterator aI = m_pParserState->m_aButtonImageWidgetMaps.begin(),
 310          aEnd = m_pParserState->m_aButtonImageWidgetMaps.end(); aI != aEnd; ++aI)
 311     {
 312         PushButton *pTargetButton = NULL;
 313         RadioButton *pTargetRadio = NULL;
 314         Button *pTarget = NULL;
 315
 316         if (!aI->m_bRadio)
 317         {
 318             pTargetButton = get<PushButton>(aI->m_sID);
 319             pTarget = pTargetButton;
 320         }
 321         else
 322         {
 323             pTargetRadio = get<RadioButton>(aI->m_sID);
 324             pTarget = pTargetRadio;
 325         }
 326
 327         FixedImage *pImage = get<FixedImage>(aI->m_sValue);
 328         SAL_WARN_IF(!pTarget || !pImage,
 329             "vcl", "missing elements of button/image/stock");
 330         if (!pTarget || !pImage)
 331             continue;
 332         aImagesToBeRemoved.insert(aI->m_sValue);
 333
 334         VclBuilder::StockMap::iterator aFind = m_pParserState->m_aStockMap.find(aI->m_sValue);
 335         if (aFind == m_pParserState->m_aStockMap.end())
 336         {
 337             if (!aI->m_bRadio)
 338                 pTargetButton->SetModeImage(pImage->GetImage());
 339             else
 340                 pTargetRadio->SetModeRadioImage(pImage->GetImage());
 341         }
 342         else
 343         {
 344             const stockinfo &rImageInfo = aFind->second;
 345             SymbolType eType = mapStockToSymbol(rImageInfo.m_sStock);
 346             SAL_WARN_IF(eType == SYMBOL_NOSYMBOL, "vcl", "missing stock image element for button");
 347             if (eType == SYMBOL_NOSYMBOL)
 348                 continue;
 349             if (!aI->m_bRadio)
 350                 pTargetButton->SetSymbol(eType);
 351             else
 352                 SAL_WARN_IF(eType != SYMBOL_IMAGE, "vcl.layout", "inimplemented symbol type for radiobuttons");
 353             if (eType == SYMBOL_IMAGE)
 354             {
 355                 Bitmap aBitmap(VclResId(mapStockToImageResource(rImageInfo.m_sStock)));
 356                 if (!aI->m_bRadio)
 357                     pTargetButton->SetModeImage(aBitmap);
 358                 else
 359                     pTargetRadio->SetModeRadioImage(aBitmap);
 360             }
 361             switch (rImageInfo.m_nSize)
 362             {
 363                 case 1:
 364                     pTarget->SetSmallSymbol();
 365                     break;
 366                 case 4:
 367                     break;
 368                 default:
 369                     SAL_WARN("vcl.layout", "unsupported image size " << rImageInfo.m_nSize);
 370                     break;
 371             }
 372         }
 373     }
 374
 375     //There may be duplicate use of an Image, so we used a set to collect and
 376     //now we can remove them from the tree after their final munge
 377     for (std::set<OString>::iterator aI = aImagesToBeRemoved.begin(),
 378         aEnd = aImagesToBeRemoved.end(); aI != aEnd; ++aI)
 379     {
 380         delete_by_name(*aI);
 381     }
 382
 383     //Set button menus when everything has been imported
 384     for (std::vector<ButtonMenuMap>::iterator aI = m_pParserState->m_aButtonMenuMaps.begin(),
 385          aEnd = m_pParserState->m_aButtonMenuMaps.end(); aI != aEnd; ++aI)
 386     {
 387         MenuButton *pTarget = get<MenuButton>(aI->m_sID);
 388         PopupMenu *pMenu = get_menu(aI->m_sValue);
 389         SAL_WARN_IF(!pTarget || !pMenu,
 390             "vcl", "missing elements of button/menu");
 391         if (!pTarget || !pMenu)
 392             continue;
 393         pTarget->SetPopupMenu(pMenu);
 394     }
 395
 396     //Remove ScrollWindow parent widgets whose children in vcl implement scrolling
 397     //internally.
 398     for (std::map<Window*, Window*>::iterator aI = m_pParserState->m_aRedundantParentWidgets.begin(),
 399         aEnd = m_pParserState->m_aRedundantParentWidgets.end(); aI != aEnd; ++aI)
 400     {
 401         delete_by_window(aI->first);
 402     }
 403
 404     //fdo#67378 merge the label into the disclosure button
 405     for (std::vector<VclExpander*>::iterator aI = m_pParserState->m_aExpanderWidgets.begin(),
 406         aEnd = m_pParserState->m_aExpanderWidgets.end(); aI != aEnd; ++aI)
 407     {
 408         VclExpander *pOne = *aI;
 409
 410         Window *pChild = pOne->get_child();
 411         Window* pLabel = pOne->GetWindow(WINDOW_LASTCHILD);
 412         if (pLabel && pLabel != pChild && pLabel->GetType() == WINDOW_FIXEDTEXT)
 413         {
 414             FixedText *pLabelWidget = static_cast<FixedText*>(pLabel);
 415             pOne->set_label(pLabelWidget->GetText());
 416             delete_by_window(pLabel);
 417         }
 418     }
 419
 420     //drop maps, etc. that we don't need again
 421     delete m_pParserState;
 422
 423     SAL_WARN_IF(!m_sID.isEmpty() && (!m_bToplevelParentFound && !get_by_name(m_sID)), "vcl.layout",
 424         "Requested top level widget \"" << m_sID.getStr() <<
 425         "\" not found in " << sUIFile);
 426
 427 #if defined SAL_LOG_WARN
 428     if (m_bToplevelParentFound && m_pParent->IsDialog())
 429     {
 430         int nButtons = 0;
 431         bool bHasDefButton = false;
 432         for (std::vector<WinAndId>::iterator aI = m_aChildren.begin(),
 433              aEnd = m_aChildren.end(); aI != aEnd; ++aI)
 434         {
 435             if (isButtonType(aI->m_pWindow->GetType()))
 436             {
 437                 ++nButtons;
 438                 if (aI->m_pWindow->GetStyle() & WB_DEFBUTTON)
 439                 {
 440                     bHasDefButton = true;
 441                     break;
 442                 }
 443             }
 444         }
 445         SAL_WARN_IF(nButtons && !bHasDefButton, "vcl.layout", "No default button defined");
 446     }
 447 #endif
 448 }
 449
 450 VclBuilder::~VclBuilder()
 451 {
 452     for (std::vector<WinAndId>::reverse_iterator aI = m_aChildren.rbegin(),
 453          aEnd = m_aChildren.rend(); aI != aEnd; ++aI)
 454     {
 455         delete aI->m_pWindow;
 456     }
 457
 458     for (std::vector<MenuAndId>::reverse_iterator aI = m_aMenus.rbegin(),
 459          aEnd = m_aMenus.rend(); aI != aEnd; ++aI)
 460     {
 461         delete aI->m_pMenu;
 462     }
 463 }
 464
 465 void VclBuilder::handleTranslations(xmlreader::XmlReader &reader)
 466 {
 467     xmlreader::Span name;
 468     int nsId;
 469
 470     OString sID, sProperty;
 471
 472     while(1)
 473     {
 474         xmlreader::XmlReader::Result res = reader.nextItem(
 475             xmlreader::XmlReader::TEXT_RAW, &name, &nsId);
 476
 477         if (res == xmlreader::XmlReader::RESULT_BEGIN)
 478         {
 479             if (name.equals("e"))
 480             {
 481                 while (reader.nextAttribute(&nsId, &name))
 482                 {
 483                     if (name.equals("g"))
 484                     {
 485                         name = reader.getAttributeValue(false);
 486                         sID = OString(name.begin, name.length);
 487                         sal_Int32 nDelim = sID.indexOf(':');
 488                         if (nDelim != -1)
 489                             sID = sID.copy(nDelim);
 490                     }
 491                     else if (name.equals("i"))
 492                     {
 493                         name = reader.getAttributeValue(false);
 494                         sProperty = OString(name.begin, name.length);
 495                     }
 496                 }
 497             }
 498         }
 499
 500         if (res == xmlreader::XmlReader::RESULT_TEXT && !sID.isEmpty())
 501         {
 502             OString sTranslation(name.begin, name.length);
 503             m_pParserState->m_aTranslations[sID][sProperty] = sTranslation;
 504         }
 505
 506         if (res == xmlreader::XmlReader::RESULT_END)
 507             sID = OString();
 508
 509         if (res == xmlreader::XmlReader::RESULT_DONE)
 510             break;
 511     }
 512 }
 513
 514 OString VclBuilder::extractCustomProperty(VclBuilder::stringmap &rMap)
 515 {
 516     OString sCustomProperty;
 517     VclBuilder::stringmap::iterator aFind = rMap.find(OString("customproperty"));
 518     if (aFind != rMap.end())
 519     {
 520         sCustomProperty = aFind->second;
 521         rMap.erase(aFind);
 522     }
 523     return sCustomProperty;
 524 }
 525
 526 namespace
 527 {
 528     bool extractResizable(VclBuilder::stringmap &rMap)
 529     {
 530         bool bResizable = true;
 531         VclBuilder::stringmap::iterator aFind = rMap.find(OString("resizable"));
 532         if (aFind != rMap.end())
 533         {
 534             bResizable = toBool(aFind->second);
 535             rMap.erase(aFind);
 536         }
 537         return bResizable;
 538     }
 539
 540     bool extractEntry(VclBuilder::stringmap &rMap)
 541     {
 542         bool bHasEntry = false;
 543         VclBuilder::stringmap::iterator aFind = rMap.find(OString("has-entry"));
 544         if (aFind != rMap.end())
 545         {
 546             bHasEntry = toBool(aFind->second);
 547             rMap.erase(aFind);
 548         }
 549         return bHasEntry;
 550     }
 551
 552     bool extractOrientation(VclBuilder::stringmap &rMap)
 553     {
 554         bool bVertical = false;
 555         VclBuilder::stringmap::iterator aFind = rMap.find(OString("orientation"));
 556         if (aFind != rMap.end())
 557         {
 558             bVertical = aFind->second.equalsIgnoreAsciiCase("vertical");
 559             rMap.erase(aFind);
 560         }
 561         return bVertical;
 562     }
 563
 564     bool extractInconsistent(VclBuilder::stringmap &rMap)
 565     {
 566         bool bInconsistent = false;
 567         VclBuilder::stringmap::iterator aFind = rMap.find(OString("inconsistent"));
 568         if (aFind != rMap.end())
 569         {
 570             bInconsistent = toBool(aFind->second);
 571             rMap.erase(aFind);
 572         }
 573         return bInconsistent;
 574     }
 575
 576     OUString getStockText(const OString &rType)
 577     {
 578         if (rType == "gtk-ok")
 579             return (VclResId(SV_BUTTONTEXT_OK).toString());
 580         else if (rType == "gtk-cancel")
 581             return (VclResId(SV_BUTTONTEXT_CANCEL).toString());
 582         else if (rType == "gtk-help")
 583             return (VclResId(SV_BUTTONTEXT_HELP).toString());
 584         else if (rType == "gtk-close")
 585             return (VclResId(SV_BUTTONTEXT_CLOSE).toString());
 586         else if (rType == "gtk-revert-to-saved")
 587             return (VclResId(SV_BUTTONTEXT_RESET).toString());
 588         else if (rType == "gtk-add")
 589             return (VclResId(SV_BUTTONTEXT_ADD).toString());
 590         else if (rType == "gtk-delete")
 591             return (VclResId(SV_BUTTONTEXT_DELETE).toString());
 592         else if (rType == "gtk-remove")
 593             return (VclResId(SV_BUTTONTEXT_REMOVE).toString());
 594         else if (rType == "gtk-new")
 595             return (VclResId(SV_BUTTONTEXT_NEW).toString());
 596         else if (rType == "gtk-edit")
 597             return (VclResId(SV_BUTTONTEXT_EDIT).toString());
 598         else if (rType == "gtk-apply")
 599             return (VclResId(SV_BUTTONTEXT_APPLY).toString());
 600         else if (rType == "gtk-save")
 601             return (VclResId(SV_BUTTONTEXT_SAVE).toString());
 602         else if (rType == "gtk-undo")
 603             return (VclResId(SV_BUTTONTEXT_UNDO).toString());
 604         else if (rType == "gtk-paste")
 605             return (VclResId(SV_BUTTONTEXT_PASTE).toString());
 606         else if (rType == "gtk-media-next")
 607             return (VclResId(SV_BUTTONTEXT_NEXT).toString());
 608         else if (rType == "gtk-go-up")
 609             return (VclResId(SV_BUTTONTEXT_GO_UP).toString());
 610         else if (rType == "gtk-go-down")
 611             return (VclResId(SV_BUTTONTEXT_GO_DOWN).toString());
 612         SAL_WARN("vcl.layout", "unknown stock type: " << rType.getStr());
 613         return OUString();
 614     }
 615
 616     bool extractStock(VclBuilder::stringmap &rMap)
 617     {
 618         bool bIsStock = false;
 619         VclBuilder::stringmap::iterator aFind = rMap.find(OString("use-stock"));
 620         if (aFind != rMap.end())
 621         {
 622             bIsStock = toBool(aFind->second);
 623             rMap.erase(aFind);
 624         }
 625         return bIsStock;
 626     }
 627
 628     OString extractLabel(VclBuilder::stringmap &rMap)
 629     {
 630         OString sType;
 631         VclBuilder::stringmap::iterator aFind = rMap.find(OString("label"));
 632         if (aFind != rMap.end())
 633         {
 634             sType = aFind->second;
 635             rMap.erase(aFind);
 636         }
 637         return sType;
 638     }
 639
 640     OString extractActionName(VclBuilder::stringmap &rMap)
 641     {
 642         OString sActionName;
 643         VclBuilder::stringmap::iterator aFind = rMap.find(OString("action-name"));
 644         if (aFind != rMap.end())
 645         {
 646             sActionName = aFind->second;
 647             rMap.erase(aFind);
 648         }
 649         return sActionName;
 650     }
 651
 652     Window * extractStockAndBuildPushButton(Window *pParent, VclBuilder::stringmap &rMap)
 653     {
 654         WinBits nBits = WB_CENTER|WB_VCENTER|WB_3DLOOK;
 655
 656         bool bIsStock = extractStock(rMap);
 657
 658         Window *pWindow = NULL;
 659
 660         if (bIsStock)
 661         {
 662             OString sType = extractLabel(rMap);
 663             if (sType == "gtk-ok")
 664                 pWindow = new OKButton(pParent, nBits);
 665             else if (sType == "gtk-cancel")
 666                 pWindow = new CancelButton(pParent, nBits);
 667             else if (sType == "gtk-close")
 668                 pWindow = new CloseButton(pParent, nBits);
 669             else if (sType == "gtk-help")
 670                 pWindow = new HelpButton(pParent, nBits);
 671             else
 672             {
 673                 pWindow = new PushButton(pParent, nBits);
 674                 pWindow->SetText(getStockText(sType));
 675             }
 676         }
 677
 678         if (!pWindow)
 679             pWindow = new PushButton(pParent, nBits);
 680         return pWindow;
 681     }
 682
 683     Window * extractStockAndBuildMenuButton(Window *pParent, VclBuilder::stringmap &rMap)
 684     {
 685         WinBits nBits = WB_CENTER|WB_VCENTER|WB_3DLOOK;
 686
 687         Window *pWindow = new MenuButton(pParent, nBits);
 688
 689         if (extractStock(rMap))
 690         {
 691             pWindow->SetText(getStockText(extractLabel(rMap)));
 692         }
 693
 694         return pWindow;
 695     }
 696
 697     FieldUnit detectMetricUnit(OString sUnit)
 698     {
 699         FieldUnit eUnit = FUNIT_NONE;
 700
 701         if (sUnit == "mm")
 702             eUnit = FUNIT_MM;
 703         else if (sUnit == "cm")
 704             eUnit = FUNIT_CM;
 705         else if (sUnit == "m")
 706             eUnit = FUNIT_M;
 707         else if (sUnit == "km")
 708             eUnit = FUNIT_KM;
 709         else if ((sUnit == "twips") || (sUnit == "twip"))
 710             eUnit = FUNIT_TWIP;
 711         else if (sUnit == "pt")
 712             eUnit = FUNIT_POINT;
 713         else if (sUnit == "pc")
 714             eUnit = FUNIT_PICA;
 715         else if (sUnit == "\"" || (sUnit == "in") || (sUnit == "inch"))
 716             eUnit = FUNIT_INCH;
 717         else if ((sUnit == "'") || (sUnit == "ft") || (sUnit == "foot") || (sUnit == "feet"))
 718             eUnit = FUNIT_FOOT;
 719         else if (sUnit == "mile" || (sUnit == "miles"))
 720             eUnit = FUNIT_MILE;
 721         else if (sUnit == "ch")
 722             eUnit = FUNIT_CHAR;
 723         else if (sUnit == "line")
 724             eUnit = FUNIT_LINE;
 725         else if (sUnit == "%")
 726             eUnit = FUNIT_PERCENT;
 727
 728         // if lack of unit is not intentional
 729         if (sUnit != "0")
 730             assert(eUnit != FUNIT_NONE); //unknown unit
 731
 732         return eUnit;
 733     }
 734 }
 735
 736 void VclBuilder::ensureDefaultWidthChars(VclBuilder::stringmap &rMap)
 737 {
 738     OString sWidthChars("width-chars");
 739     VclBuilder::stringmap::iterator aFind = rMap.find(sWidthChars);
 740     if (aFind == rMap.end())
 741         rMap[sWidthChars] = "25";
 742 }
 743
 744 bool VclBuilder::extractGroup(const OString &id, stringmap &rMap)
 745 {
 746     VclBuilder::stringmap::iterator aFind = rMap.find(OString("group"));
 747     if (aFind != rMap.end())
 748     {
 749         OString sID = aFind->second;
 750         sal_Int32 nDelim = sID.indexOf(':');
 751         if (nDelim != -1)
 752             sID = sID.copy(0, nDelim);
 753         m_pParserState->m_aGroupMaps.push_back(RadioButtonGroupMap(id, sID));
 754         rMap.erase(aFind);
 755         return true;
 756     }
 757     return false;
 758 }
 759
 760 void VclBuilder::connectNumericFormatterAdjustment(const OString &id, const OString &rAdjustment)
 761 {
 762     if (!rAdjustment.isEmpty())
 763         m_pParserState->m_aNumericFormatterAdjustmentMaps.push_back(WidgetAdjustmentMap(id, rAdjustment));
 764 }
 765
 766 void VclBuilder::connectTimeFormatterAdjustment(const OString &id, const OString &rAdjustment)
 767 {
 768     if (!rAdjustment.isEmpty())
 769         m_pParserState->m_aTimeFormatterAdjustmentMaps.push_back(WidgetAdjustmentMap(id, rAdjustment));
 770 }
 771
 772 void VclBuilder::connectDateFormatterAdjustment(const OString &id, const OString &rAdjustment)
 773 {
 774     if (!rAdjustment.isEmpty())
 775         m_pParserState->m_aDateFormatterAdjustmentMaps.push_back(WidgetAdjustmentMap(id, rAdjustment));
 776 }
 777
 778 bool VclBuilder::extractScrollAdjustment(const OString &id, VclBuilder::stringmap &rMap)
 779 {
 780     VclBuilder::stringmap::iterator aFind = rMap.find(OString("adjustment"));
 781     if (aFind != rMap.end())
 782     {
 783         m_pParserState->m_aScrollAdjustmentMaps.push_back(WidgetAdjustmentMap(id, aFind->second));
 784         rMap.erase(aFind);
 785         return true;
 786     }
 787     return false;
 788 }
 789
 790 namespace
 791 {
 792     sal_Int32 extractActive(VclBuilder::stringmap &rMap)
 793     {
 794         sal_Int32 nActiveId = 0;
 795         VclBuilder::stringmap::iterator aFind = rMap.find(OString("active"));
 796         if (aFind != rMap.end())
 797         {
 798             nActiveId = aFind->second.toInt32();
 799             rMap.erase(aFind);
 800         }
 801         return nActiveId;
 802     }
 803
 804     bool extractSelectable(VclBuilder::stringmap &rMap)
 805     {
 806         bool bSelectable = false;
 807         VclBuilder::stringmap::iterator aFind = rMap.find(OString("selectable"));
 808         if (aFind != rMap.end())
 809         {
 810             bSelectable = toBool(aFind->second);
 811             rMap.erase(aFind);
 812         }
 813         return bSelectable;
 814     }
 815
 816     OString extractAdjustment(VclBuilder::stringmap &rMap)
 817     {
 818         OString sAdjustment;
 819         VclBuilder::stringmap::iterator aFind = rMap.find(OString("adjustment"));
 820         if (aFind != rMap.end())
 821         {
 822             sAdjustment= aFind->second;
 823             rMap.erase(aFind);
 824             return sAdjustment;
 825         }
 826         return sAdjustment;
 827     }
 828 }
 829
 830 bool VclBuilder::extractModel(const OString &id, stringmap &rMap)
 831 {
 832     VclBuilder::stringmap::iterator aFind = rMap.find(OString("model"));
 833     if (aFind != rMap.end())
 834     {
 835         m_pParserState->m_aModelMaps.push_back(ComboBoxModelMap(id, aFind->second,
 836             extractActive(rMap)));
 837         rMap.erase(aFind);
 838         return true;
 839     }
 840     return false;
 841 }
 842
 843 bool VclBuilder::extractBuffer(const OString &id, stringmap &rMap)
 844 {
 845     VclBuilder::stringmap::iterator aFind = rMap.find(OString("buffer"));
 846     if (aFind != rMap.end())
 847     {
 848         m_pParserState->m_aTextBufferMaps.push_back(TextBufferMap(id, aFind->second));
 849         rMap.erase(aFind);
 850         return true;
 851     }
 852     return false;
 853 }
 854
 855 bool VclBuilder::extractStock(const OString &id, stringmap &rMap)
 856 {
 857     VclBuilder::stringmap::iterator aFind = rMap.find(OString("stock"));
 858     if (aFind != rMap.end())
 859     {
 860         stockinfo aInfo;
 861         aInfo.m_sStock = aFind->second;
 862         rMap.erase(aFind);
 863         aFind = rMap.find(OString("icon-size"));
 864         if (aFind != rMap.end())
 865         {
 866             aInfo.m_nSize = aFind->second.toInt32();
 867             rMap.erase(aFind);
 868         }
 869         m_pParserState->m_aStockMap[id] = aInfo;
 870         return true;
 871     }
 872     return false;
 873 }
 874
 875 bool VclBuilder::extractButtonImage(const OString &id, stringmap &rMap, bool bRadio)
 876 {
 877     VclBuilder::stringmap::iterator aFind = rMap.find(OString("image"));
 878     if (aFind != rMap.end())
 879     {
 880         m_pParserState->m_aButtonImageWidgetMaps.push_back(ButtonImageWidgetMap(id, aFind->second, bRadio));
 881         rMap.erase(aFind);
 882         return true;
 883     }
 884     return false;
 885 }
 886
 887 void VclBuilder::extractMnemonicWidget(const OString &rLabelID, stringmap &rMap)
 888 {
 889     VclBuilder::stringmap::iterator aFind = rMap.find(OString("mnemonic-widget"));
 890     if (aFind != rMap.end())
 891     {
 892         OString sID = aFind->second;
 893         sal_Int32 nDelim = sID.indexOf(':');
 894         if (nDelim != -1)
 895             sID = sID.copy(0, nDelim);
 896         m_pParserState->m_aMnemonicWidgetMaps.push_back(MnemonicWidgetMap(rLabelID, sID));
 897         rMap.erase(aFind);
 898     }
 899 }
 900
 901 Window* VclBuilder::prepareWidgetOwnScrolling(Window *pParent, WinBits &rWinStyle)
 902 {
 903     //For Widgets that manage their own scrolling, if one appears as a child of
 904     //a scrolling window shoehorn that scrolling settings to this widget and
 905     //return the real parent to use
 906     if (pParent && pParent->GetType() == WINDOW_SCROLLWINDOW)
 907     {
 908         WinBits nScrollBits = pParent->GetStyle();
 909         nScrollBits &= (WB_AUTOHSCROLL|WB_HSCROLL|WB_AUTOVSCROLL|WB_VSCROLL);
 910         rWinStyle |= nScrollBits;
 911         pParent = pParent->GetParent();
 912     }
 913
 914     return pParent;
 915 }
 916
 917 void VclBuilder::cleanupWidgetOwnScrolling(Window *pScrollParent, Window *pWindow, stringmap &rMap)
 918 {
 919     //remove the redundant scrolling parent
 920     sal_Int32 nWidthReq = pScrollParent->get_width_request();
 921     rMap[OString("width-request")] = OString::valueOf(nWidthReq);
 922     sal_Int32 nHeightReq = pScrollParent->get_height_request();
 923     rMap[OString("height-request")] = OString::valueOf(nHeightReq);
 924
 925     m_pParserState->m_aRedundantParentWidgets[pScrollParent] = pWindow;
 926 }
 927
 928 #ifndef DISABLE_DYNLOADING
 929 extern "C" { static void SAL_CALL thisModule() {} }
 930 #endif
 931
 932 Window *VclBuilder::makeObject(Window *pParent, const OString &name, const OString &id,
 933     stringmap &rMap, const std::vector<OString> &rItems)
 934 {
 935     bool bIsPlaceHolder = name.isEmpty();
 936     bool bVertical = false;
 937
 938     if (pParent && pParent->GetType() == WINDOW_TABCONTROL)
 939     {
 940         //We have to add a page
 941
 942         //make default pageid == position
 943         TabControl *pTabControl = static_cast<TabControl*>(pParent);
 944         sal_uInt16 nNewPageCount = pTabControl->GetPageCount()+1;
 945         sal_uInt16 nNewPageId = nNewPageCount;
 946         pTabControl->InsertPage(nNewPageId, OUString());
 947         pTabControl->SetCurPageId(nNewPageId);
 948
 949         if (!bIsPlaceHolder)
 950         {
 951             TabPage* pPage = new TabPage(pTabControl);
 952             pPage->Show();
 953
 954             //Make up a name for it
 955             OString sTabPageId = get_by_window(pParent) +
 956                 OString("-page") +
 957                 OString::number(nNewPageCount);
 958             m_aChildren.push_back(WinAndId(sTabPageId, pPage, false));
 959             pPage->SetHelpId(m_sHelpRoot + sTabPageId);
 960
 961             //And give the page one container as a child to make it a layout enabled
 962             //tab page
 963             VclBin* pContainer = new VclBin(pPage);
 964             pContainer->Show();
 965             m_aChildren.push_back(WinAndId(OString(), pContainer, false));
 966             pContainer->SetHelpId(m_sHelpRoot + sTabPageId + OString("-bin"));
 967             pParent = pContainer;
 968
 969             pTabControl->SetTabPage(nNewPageId, pPage);
 970         }
 971     }
 972
 973     if (bIsPlaceHolder || name == "GtkTreeSelection")
 974         return NULL;
 975
 976     extractButtonImage(id, rMap, name == "GtkRadioButton");
 977
 978     Window *pWindow = NULL;
 979     if (name == "GtkDialog")
 980     {
 981         WinBits nBits = WB_MOVEABLE|WB_3DLOOK|WB_CLOSEABLE;
 982         if (extractResizable(rMap))
 983             nBits |= WB_SIZEABLE;
 984         pWindow = new Dialog(pParent, nBits);
 985     }
 986     else if (name == "GtkMessageDialog")
 987     {
 988         WinBits nBits = WB_MOVEABLE|WB_3DLOOK|WB_CLOSEABLE;
 989         if (extractResizable(rMap))
 990             nBits |= WB_SIZEABLE;
 991         pWindow = new MessageDialog(pParent, nBits);
 992     }
 993     else if (name == "GtkBox")
 994     {
 995         bVertical = extractOrientation(rMap);
 996         if (bVertical)
 997             pWindow = new VclVBox(pParent);
 998         else
 999             pWindow = new VclHBox(pParent);
1000     }
1001     else if (name == "GtkHBox")
1002         pWindow = new VclHBox(pParent);
1003     else if (name == "GtkVBox")
1004         pWindow = new VclVBox(pParent);
1005     else if (name == "GtkButtonBox")
1006     {
1007         bVertical = extractOrientation(rMap);
1008         if (bVertical)
1009             pWindow = new VclVButtonBox(pParent);
1010         else
1011             pWindow = new VclHButtonBox(pParent);
1012     }
1013     else if (name == "GtkHButtonBox")
1014         pWindow = new VclHButtonBox(pParent);
1015     else if (name == "GtkVButtonBox")
1016         pWindow = new VclVButtonBox(pParent);
1017     else if (name == "GtkGrid")
1018         pWindow = new VclGrid(pParent);
1019     else if (name == "GtkFrame")
1020         pWindow = new VclFrame(pParent);
1021     else if (name == "GtkExpander")
1022     {
1023         VclExpander *pExpander = new VclExpander(pParent);
1024         m_pParserState->m_aExpanderWidgets.push_back(pExpander);
1025         pWindow = pExpander;
1026     }
1027     else if (name == "GtkAlignment")
1028         pWindow = new VclAlignment(pParent);
1029     else if (name == "GtkButton")
1030     {
1031         OString sMenu = extractCustomProperty(rMap);
1032         if (sMenu.isEmpty())
1033             pWindow = extractStockAndBuildPushButton(pParent, rMap);
1034         else
1035         {
1036             pWindow = extractStockAndBuildMenuButton(pParent, rMap);
1037             m_pParserState->m_aButtonMenuMaps.push_back(ButtonMenuMap(id, sMenu));
1038         }
1039     }
1040     else if (name == "GtkRadioButton")
1041     {
1042         extractGroup(id, rMap);
1043         WinBits nBits = WB_CENTER|WB_VCENTER|WB_3DLOOK;
1044         OString sWrap = extractCustomProperty(rMap);
1045         if (!sWrap.isEmpty())
1046             nBits |= WB_WORDBREAK;
1047         pWindow = new RadioButton(pParent, nBits);
1048     }
1049     else if (name == "GtkCheckButton")
1050     {
1051         WinBits nBits = WB_CENTER|WB_VCENTER|WB_3DLOOK;
1052         OString sWrap = extractCustomProperty(rMap);
1053         if (!sWrap.isEmpty())
1054             nBits |= WB_WORDBREAK;
1055         //maybe always import as TriStateBox and enable/disable tristate
1056         bool bIsTriState = extractInconsistent(rMap);
1057         CheckBox *pCheckBox = bIsTriState ?
1058             new TriStateBox(pParent, nBits) :
1059             new CheckBox(pParent, nBits);
1060         if (bIsTriState)
1061             pCheckBox->SetState(STATE_DONTKNOW);
1062         pWindow = pCheckBox;
1063     }
1064     else if (name == "GtkSpinButton")
1065     {
1066         OString sAdjustment = extractAdjustment(rMap);
1067         OString sPattern = extractCustomProperty(rMap);
1068         OString sUnit = sPattern;
1069
1070         for (sal_Int32 i = 0; i < sPattern.getLength(); ++i)
1071         {
1072             if (sPattern[i] != '.' && sPattern[i] != ',' && sPattern[i] != '0')
1073             {
1074                 sUnit = sPattern.copy(i);
1075                 break;
1076             }
1077         }
1078
1079         WinBits nBits = WB_LEFT|WB_BORDER|WB_3DLOOK;
1080         if (!id.endsWith("-nospin"))
1081             nBits |= WB_SPIN | WB_REPEAT;
1082
1083         if (sPattern.isEmpty())
1084         {
1085             connectNumericFormatterAdjustment(id, sAdjustment);
1086             SAL_INFO("vcl.layout", "making numeric field for " << name.getStr() << " " << sUnit.getStr());
1087             pWindow = new NumericField(pParent, nBits);
1088         }
1089         else
1090         {
1091             if (sPattern == "hh:mm")
1092             {
1093                 connectTimeFormatterAdjustment(id, sAdjustment);
1094                 SAL_INFO("vcl.layout", "making time field for " << name.getStr() << " " << sUnit.getStr());
1095                 TimeField *pField = new TimeField(pParent, nBits);
1096                 pWindow = pField;
1097             }
1098             else if (sPattern == "yy:mm:dd")
1099             {
1100                 connectDateFormatterAdjustment(id, sAdjustment);
1101                 SAL_INFO("vcl.layout", "making date field for " << name.getStr() << " " << sUnit.getStr());
1102                 DateField *pField = new DateField(pParent, nBits);
1103                 pWindow = pField;
1104             }
1105             else
1106             {
1107                 connectNumericFormatterAdjustment(id, sAdjustment);
1108                 FieldUnit eUnit = detectMetricUnit(sUnit);
1109                 SAL_INFO("vcl.layout", "making metric field for " << name.getStr() << " " << sUnit.getStr());
1110                 MetricField *pField = new MetricField(pParent, nBits);
1111                 pField->SetUnit(eUnit);
1112                 pWindow = pField;
1113             }
1114         }
1115     }
1116     else if (name == "GtkLinkButton")
1117         pWindow = new FixedHyperlink(pParent, WB_CENTER|WB_VCENTER|WB_3DLOOK|WB_NOLABEL);
1118     else if ((name == "GtkComboBox") || (name == "GtkComboBoxText") || (name == "VclComboBoxText"))
1119     {
1120         extractModel(id, rMap);
1121         if (extractEntry(rMap))
1122         {
1123             ComboBox* pComboBox = new ComboBox(pParent, WB_LEFT|WB_DROPDOWN|WB_VCENTER|WB_3DLOOK);
1124             pComboBox->EnableAutoSize(true);
1125             if (!rItems.empty())
1126             {
1127                 sal_uInt16 nActiveId = extractActive(rMap);
1128                 for (std::vector<OString>::const_iterator aI = rItems.begin(), aEnd = rItems.end(); aI != aEnd; ++aI)
1129                     pComboBox->InsertEntry(OStringToOUString(*aI, RTL_TEXTENCODING_UTF8));
1130                 if (nActiveId < rItems.size())
1131                     pComboBox->SelectEntryPos(nActiveId);
1132             }
1133             pWindow = pComboBox;
1134         }
1135         else
1136         {
1137             ListBox *pListBox = new ListBox(pParent, WB_LEFT|WB_DROPDOWN|WB_VCENTER|WB_3DLOOK|WB_SIMPLEMODE);
1138             pListBox->EnableAutoSize(true);
1139             if (!rItems.empty())
1140             {
1141                 sal_uInt16 nActiveId = extractActive(rMap);
1142                 for (std::vector<OString>::const_iterator aI = rItems.begin(), aEnd = rItems.end(); aI != aEnd; ++aI)
1143                     pListBox->InsertEntry(OStringToOUString(*aI, RTL_TEXTENCODING_UTF8));
1144                 if (nActiveId < rItems.size())
1145                     pListBox->SelectEntryPos(nActiveId);
1146             }
1147             pWindow = pListBox;
1148         }
1149     }
1150     else if (name == "VclComboBoxNumeric")
1151     {
1152         NumericBox* pComboBox = new NumericBox(pParent, WB_LEFT|WB_DROPDOWN|WB_VCENTER|WB_3DLOOK);
1153         pComboBox->EnableAutoSize(true);
1154         pWindow = pComboBox;
1155     }
1156     else if (name == "GtkTreeView")
1157     {
1158         //To-Do
1159         //a) move svtools SvTreeViewBox into vcl
1160         //b) make that the default target for GtkTreeView
1161         //c) remove the non-drop down mode of ListBox and convert
1162         //   everything over to SvTreeViewBox
1163         //d) remove the users of makeSvTreeViewBox
1164         extractModel(id, rMap);
1165         WinBits nWinStyle = WB_LEFT|WB_VCENTER|WB_3DLOOK|WB_SIMPLEMODE;
1166         OString sBorder = extractCustomProperty(rMap);
1167         if (!sBorder.isEmpty())
1168             nWinStyle |= WB_BORDER;
1169         //ListBox manages its own scrolling,
1170         Window *pRealParent = prepareWidgetOwnScrolling(pParent, nWinStyle);
1171         pWindow = new ListBox(pRealParent, nWinStyle);
1172         if (pRealParent != pParent)
1173             cleanupWidgetOwnScrolling(pParent, pWindow, rMap);
1174     }
1175     else if (name == "GtkLabel")
1176     {
1177         extractMnemonicWidget(id, rMap);
1178         if (extractSelectable(rMap))
1179             pWindow = new SelectableFixedText(pParent, WB_CENTER|WB_VCENTER|WB_3DLOOK);
1180         else
1181             pWindow = new FixedText(pParent, WB_CENTER|WB_VCENTER|WB_3DLOOK);
1182     }
1183     else if (name == "GtkImage")
1184     {
1185         extractStock(id, rMap);
1186         pWindow = new FixedImage(pParent, WB_CENTER|WB_VCENTER|WB_3DLOOK);
1187         //such parentless GtkImages are temps used to set icons on buttons
1188         //default them to hidden to stop e.g. insert->index entry flicking temp
1189         //full screen windows
1190         if (!pParent)
1191         {
1192             rMap["visible"] = "false";
1193         }
1194
1195     }
1196     else if (name == "GtkSeparator")
1197     {
1198         bVertical = extractOrientation(rMap);
1199         if (bVertical)
1200             pWindow = new FixedLine(pParent, WB_VERT);
1201         else
1202             pWindow = new FixedLine(pParent, WB_HORZ);
1203     }
1204     else if (name == "GtkScrollbar")
1205     {
1206         extractScrollAdjustment(id, rMap);
1207         bVertical = extractOrientation(rMap);
1208         if (bVertical)
1209             pWindow = new ScrollBar(pParent, WB_VERT);
1210         else
1211             pWindow = new ScrollBar(pParent, WB_HORZ);
1212     }
1213     else if (name == "GtkProgressBar")
1214     {
1215         extractScrollAdjustment(id, rMap);
1216         bVertical = extractOrientation(rMap);
1217         if (bVertical)
1218             pWindow = new ProgressBar(pParent, WB_VERT);
1219         else
1220             pWindow = new ProgressBar(pParent, WB_HORZ);
1221     }
1222     else if (name == "GtkScrolledWindow")
1223     {
1224         pWindow = new VclScrolledWindow(pParent);
1225     }
1226     else if (name == "GtkEventBox")
1227     {
1228         pWindow = new VclEventBox(pParent);
1229     }
1230     else if (name == "GtkEntry")
1231     {
1232         pWindow = new Edit(pParent, WB_LEFT|WB_VCENTER|WB_BORDER|WB_3DLOOK);
1233         ensureDefaultWidthChars(rMap);
1234     }
1235     else if (name == "GtkNotebook")
1236         pWindow = new TabControl(pParent, WB_STDTABCONTROL|WB_3DLOOK);
1237     else if (name == "GtkDrawingArea")
1238     {
1239         OString sBorder = extractCustomProperty(rMap);
1240         pWindow = new Window(pParent, sBorder.isEmpty() ? 0 : WB_BORDER);
1241     }
1242     else if (name == "GtkTextView")
1243     {
1244         extractBuffer(id, rMap);
1245
1246         WinBits nWinStyle = WB_LEFT;
1247         OString sBorder = extractCustomProperty(rMap);
1248         if (!sBorder.isEmpty())
1249             nWinStyle |= WB_BORDER;
1250         //VclMultiLineEdit manages its own scrolling,
1251         Window *pRealParent = prepareWidgetOwnScrolling(pParent, nWinStyle);
1252         pWindow = new VclMultiLineEdit(pRealParent, nWinStyle);
1253         if (pRealParent != pParent)
1254             cleanupWidgetOwnScrolling(pParent, pWindow, rMap);
1255     }
1256     else if (name == "GtkToolbar")
1257     {
1258         pWindow = new ToolBox(pParent, WB_3DLOOK | WB_TABSTOP);
1259     }
1260     else if (name == "GtkToolButton" || name == "GtkMenuToolButton")
1261     {
1262         ToolBox *pToolBox = dynamic_cast<ToolBox*>(pParent);
1263         if (pToolBox)
1264         {
1265             OUString aCommand(OStringToOUString(extractActionName(rMap), RTL_TEXTENCODING_UTF8));
1266
1267             ToolBoxItemBits nBits = 0;
1268             if (name == "GtkMenuToolButton")
1269                 nBits |= TIB_DROPDOWN;
1270
1271             if (!aCommand.isEmpty())
1272                 pToolBox->InsertItem(aCommand, m_xFrame, nBits);
1273
1274             return NULL; // no widget to be created
1275         }
1276     }
1277     else
1278     {
1279         sal_Int32 nDelim = name.indexOf('-');
1280         if (nDelim != -1)
1281         {
1282 #ifndef DISABLE_DYNLOADING
1283             OUStringBuffer sModuleBuf;
1284 #ifdef SAL_DLLPREFIX
1285             sModuleBuf.append(SAL_DLLPREFIX);
1286 #endif
1287             sModuleBuf.append(OStringToOUString(name.copy(0, nDelim), RTL_TEXTENCODING_UTF8));
1288 #ifdef SAL_DLLEXTENSION
1289             sModuleBuf.append(SAL_DLLEXTENSION);
1290 #endif
1291 #endif
1292             OUString sFunction(OStringToOUString(OString("make") + name.copy(nDelim+1), RTL_TEXTENCODING_UTF8));
1293 #ifndef DISABLE_DYNLOADING
1294             OUString sModule = sModuleBuf.makeStringAndClear();
1295             ModuleMap::iterator aI = m_aModuleMap.find(sModule);
1296             osl::Module* pModule = NULL;
1297             if (aI == m_aModuleMap.end())
1298             {
1299                 pModule = new osl::Module;
1300                 pModule->loadRelative(&thisModule, sModule);
1301                 aI = m_aModuleMap.insert(sModule, pModule).first;
1302             }
1303             customMakeWidget pFunction = (customMakeWidget)aI->second->getFunctionSymbol(sFunction);
1304 #else
1305             customMakeWidget pFunction = (customMakeWidget)osl_getFunctionSymbol((oslModule) RTLD_DEFAULT, sFunction.pData);
1306 #endif
1307             if (pFunction)
1308                 pWindow = (*pFunction)(pParent, rMap);
1309         }
1310     }
1311     SAL_WARN_IF(!pWindow, "vcl.layout", "probably need to implement " << name.getStr() << " or add a make" << name.getStr() << " function");
1312     if (pWindow)
1313     {
1314         pWindow->SetHelpId(m_sHelpRoot + id);
1315         SAL_INFO("vcl.layout", "for " << name.getStr() <<
1316             ", created " << pWindow << " child of " <<
1317             pParent << "(" << pWindow->mpWindowImpl->mpParent << "/" <<
1318             pWindow->mpWindowImpl->mpRealParent << "/" <<
1319             pWindow->mpWindowImpl->mpBorderWindow << ") with helpid " <<
1320             pWindow->GetHelpId().getStr());
1321         m_aChildren.push_back(WinAndId(id, pWindow, bVertical));
1322     }
1323     return pWindow;
1324 }
1325
1326 namespace
1327 {
1328     //return true for window types which exist in vcl but are not themselves
1329     //represented in the .ui format, i.e. only their children exist.
1330     bool isConsideredGtkPseudo(Window *pWindow)
1331     {
1332         return pWindow->GetType() == WINDOW_TABPAGE;
1333     }
1334 }
1335
1336 //Any properties from .ui load we couldn't set because of potential virtual methods
1337 //during ctor are applied here
1338 void VclBuilder::setDeferredProperties()
1339 {
1340     if (!m_bToplevelHasDeferredProperties)
1341         return;
1342     stringmap aDeferredProperties;
1343     aDeferredProperties.swap(m_aDeferredProperties);
1344     m_bToplevelHasDeferredProperties = false;
1345     set_properties(m_pParent, aDeferredProperties);
1346 }
1347
1348 void VclBuilder::set_properties(Window *pWindow, const stringmap &rProps)
1349 {
1350     for (stringmap::const_iterator aI = rProps.begin(), aEnd = rProps.end(); aI != aEnd; ++aI)
1351     {
1352         const OString &rKey = aI->first;
1353         const OString &rValue = aI->second;
1354         pWindow->set_property(rKey, rValue);
1355     }
1356 }
1357
1358 Window *VclBuilder::insertObject(Window *pParent, const OString &rClass,
1359     const OString &rID, stringmap &rProps, stringmap &rPango,
1360     stringmap &rAtk,
1361     std::vector<OString> &rItems)
1362 {
1363     Window *pCurrentChild = NULL;
1364
1365     if (m_pParent && !isConsideredGtkPseudo(m_pParent) && !m_sID.isEmpty() && rID.equals(m_sID))
1366     {
1367         pCurrentChild = m_pParent;
1368         //toplevels default to resizable
1369         if (pCurrentChild->IsDialog())
1370         {
1371             Dialog *pDialog = (Dialog*)pCurrentChild;
1372             pDialog->doDeferredInit(extractResizable(rProps));
1373             m_bToplevelHasDeferredInit = false;
1374         }
1375         if (pCurrentChild->GetHelpId().isEmpty())
1376         {
1377             pCurrentChild->SetHelpId(m_sHelpRoot + m_sID);
1378             SAL_INFO("vcl.layout", "for toplevel dialog " << this << " " <<
1379                 rID.getStr() << ", set helpid " <<
1380                 pCurrentChild->GetHelpId().getStr());
1381         }
1382         m_bToplevelParentFound = true;
1383     }
1384     else
1385     {
1386         //if we're being inserting under a toplevel dialog whose init is
1387         //deferred due to waiting to encounter it in this .ui, and it hasn't
1388         //been seen yet, then make unattached widgets parent-less toplevels
1389         if (pParent == m_pParent && m_bToplevelHasDeferredInit)
1390             pParent = NULL;
1391         pCurrentChild = makeObject(pParent, rClass, rID, rProps, rItems);
1392     }
1393
1394     if (pCurrentChild)
1395     {
1396         if (pCurrentChild == m_pParent && m_bToplevelHasDeferredProperties)
1397             m_aDeferredProperties = rProps;
1398         else
1399             set_properties(pCurrentChild, rProps);
1400
1401         for (stringmap::iterator aI = rPango.begin(), aEnd = rPango.end(); aI != aEnd; ++aI)
1402         {
1403             const OString &rKey = aI->first;
1404             const OString &rValue = aI->second;
1405             pCurrentChild->set_font_attribute(rKey, rValue);
1406         }
1407
1408         m_pParserState->m_aAtkInfo[pCurrentChild] = rAtk;
1409     }
1410
1411     rProps.clear();
1412     rPango.clear();
1413     rAtk.clear();
1414     rItems.clear();
1415
1416     if (!pCurrentChild)
1417         pCurrentChild = m_aChildren.empty() ? pParent : m_aChildren.back().m_pWindow;
1418     return pCurrentChild;
1419 }
1420
1421 void VclBuilder::reorderWithinParent(Window &rWindow, sal_uInt16 nNewPosition)
1422 {
1423     if (rWindow.mpWindowImpl->mpParent != rWindow.mpWindowImpl->mpRealParent)
1424     {
1425         assert(rWindow.mpWindowImpl->mpBorderWindow ==
1426             rWindow.mpWindowImpl->mpParent);
1427         assert(rWindow.mpWindowImpl->mpBorderWindow->mpWindowImpl->mpParent ==
1428             rWindow.mpWindowImpl->mpRealParent);
1429         reorderWithinParent(*rWindow.mpWindowImpl->mpBorderWindow, nNewPosition);
1430         return;
1431     }
1432     rWindow.reorderWithinParent(nNewPosition);
1433 }
1434
1435 void VclBuilder::handleTabChild(Window *pParent, xmlreader::XmlReader &reader)
1436 {
1437     OString sID;
1438
1439     int nLevel = 1;
1440     stringmap aProperties;
1441     while(1)
1442     {
1443         xmlreader::Span name;
1444         int nsId;
1445
1446         xmlreader::XmlReader::Result res = reader.nextItem(
1447             xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
1448
1449         if (res == xmlreader::XmlReader::RESULT_BEGIN)
1450         {
1451             ++nLevel;
1452             if (name.equals("object"))
1453             {
1454                 while (reader.nextAttribute(&nsId, &name))
1455                 {
1456                     if (name.equals("id"))
1457                     {
1458                         name = reader.getAttributeValue(false);
1459                         sID = OString(name.begin, name.length);
1460                         sal_Int32 nDelim = sID.indexOf(':');
1461                         if (nDelim != -1)
1462                         {
1463                             OString sPattern = sID.copy(nDelim+1);
1464                             aProperties[OString("customproperty")] = sPattern;
1465                             sID = sID.copy(0, nDelim);
1466                         }
1467                     }
1468                 }
1469             }
1470             else if (name.equals("property"))
1471                 collectProperty(reader, sID, aProperties);
1472         }
1473
1474         if (res == xmlreader::XmlReader::RESULT_END)
1475             --nLevel;
1476
1477         if (!nLevel)
1478             break;
1479
1480         if (res == xmlreader::XmlReader::RESULT_DONE)
1481             break;
1482     }
1483
1484     TabControl *pTabControl = static_cast<TabControl*>(pParent);
1485     VclBuilder::stringmap::iterator aFind = aProperties.find(OString("label"));
1486     if (aFind != aProperties.end())
1487     {
1488         sal_uInt16 nPageId = pTabControl->GetCurPageId();
1489         pTabControl->SetPageText(nPageId,
1490             OStringToOUString(aFind->second, RTL_TEXTENCODING_UTF8));
1491         pTabControl->SetPageName(nPageId, sID);
1492     }
1493     else
1494         pTabControl->RemovePage(pTabControl->GetCurPageId());
1495 }
1496
1497 //so that tabbing between controls goes in a visually sensible sequence
1498 //we sort these into a best-tab-order sequence
1499 bool VclBuilder::sortIntoBestTabTraversalOrder::operator()(const Window *pA, const Window *pB) const
1500 {
1501     //sort child order within parent list by grid position
1502     sal_Int32 nTopA = pA->get_grid_top_attach();
1503     sal_Int32 nTopB = pB->get_grid_top_attach();
1504     if (nTopA < nTopB)
1505         return true;
1506     if (nTopA > nTopB)
1507         return false;
1508     sal_Int32 nLeftA = pA->get_grid_left_attach();
1509     sal_Int32 nLeftB = pB->get_grid_left_attach();
1510     if (nLeftA < nLeftB)
1511         return true;
1512     if (nLeftA > nLeftB)
1513         return false;
1514     //sort into two groups of pack start and pack end
1515     VclPackType ePackA = pA->get_pack_type();
1516     VclPackType ePackB = pB->get_pack_type();
1517     if (ePackA < ePackB)
1518         return true;
1519     if (ePackA > ePackB)
1520         return false;
1521     bool bVerticalContainer = m_pBuilder->get_window_packing_data(pA->GetParent()).m_bVerticalOrient;
1522     bool bPackA = pA->get_secondary();
1523     bool bPackB = pB->get_secondary();
1524     if (!bVerticalContainer)
1525     {
1526         //for horizontal boxes group secondaries before primaries
1527         if (bPackA > bPackB)
1528             return true;
1529         if (bPackA < bPackB)
1530             return false;
1531     }
1532     else
1533     {
1534         //for vertical boxes group secondaries after primaries
1535         if (bPackA < bPackB)
1536             return true;
1537         if (bPackA > bPackB)
1538             return false;
1539     }
1540     //honour relative box positions with pack group
1541     bPackA = m_pBuilder->get_window_packing_data(pA).m_nPosition;
1542     bPackB = m_pBuilder->get_window_packing_data(pB).m_nPosition;
1543     if (bPackA < bPackB)
1544         return true;
1545     if (bPackA > bPackB)
1546         return false;
1547     //sort labels of Frames before body
1548     if (pA->GetParent() == pB->GetParent())
1549     {
1550         const VclFrame *pFrameParent = dynamic_cast<const VclFrame*>(pA->GetParent());
1551         if (pFrameParent)
1552         {
1553             const Window *pLabel = pFrameParent->get_label_widget();
1554             int nFramePosA = (pA == pLabel) ? 0 : 1;
1555             int nFramePosB = (pB == pLabel) ? 0 : 1;
1556             return nFramePosA < nFramePosB;
1557         }
1558     }
1559     return false;
1560 }
1561
1562 void VclBuilder::handleChild(Window *pParent, xmlreader::XmlReader &reader)
1563 {
1564     Window *pCurrentChild = NULL;
1565
1566     xmlreader::Span name;
1567     int nsId;
1568     OString sType, sInternalChild;
1569
1570     while (reader.nextAttribute(&nsId, &name))
1571     {
1572         if (name.equals("type"))
1573         {
1574             name = reader.getAttributeValue(false);
1575             sType = OString(name.begin, name.length);
1576         }
1577         else if (name.equals("internal-child"))
1578         {
1579             name = reader.getAttributeValue(false);
1580             sInternalChild = OString(name.begin, name.length);
1581         }
1582     }
1583
1584     if (sType.equals("tab"))
1585     {
1586         handleTabChild(pParent, reader);
1587         return;
1588     }
1589
1590     int nLevel = 1;
1591     while(1)
1592     {
1593         xmlreader::XmlReader::Result res = reader.nextItem(
1594             xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
1595
1596         if (res == xmlreader::XmlReader::RESULT_BEGIN)
1597         {
1598             if (name.equals("object") || name.equals("placeholder"))
1599             {
1600                 pCurrentChild = handleObject(pParent, reader);
1601
1602                 bool bObjectInserted = pCurrentChild && pParent != pCurrentChild;
1603
1604                 if (bObjectInserted)
1605                 {
1606                     //Internal-children default in glade to not having their visible bits set
1607                     //even though they are visible (generally anyway)
1608                     if (!sInternalChild.isEmpty())
1609                         pCurrentChild->Show();
1610
1611                     //Select the first page if its a notebook
1612                     if (pCurrentChild->GetType() == WINDOW_TABCONTROL)
1613                     {
1614                         TabControl *pTabControl = static_cast<TabControl*>(pCurrentChild);
1615                         pTabControl->SetCurPageId(pTabControl->GetPageId(0));
1616
1617                         //To-Do add reorder capability to the TabControl
1618                     }
1619                     else
1620                     {
1621                         // We want to sort labels before contents of frames
1622                         // for key board traversal, especially if there
1623                         // are multiple widgets using the same mnemonic
1624                         if (sType.equals("label"))
1625                         {
1626                             if (VclFrame *pFrameParent = dynamic_cast<VclFrame*>(pParent))
1627                                 pFrameParent->designate_label(pCurrentChild);
1628                         }
1629                         if (sInternalChild.equals("vbox") || sInternalChild.equals("messagedialog-vbox"))
1630                         {
1631                             if (Dialog *pBoxParent = dynamic_cast<Dialog*>(pParent))
1632                                 pBoxParent->set_content_area(static_cast<VclBox*>(pCurrentChild));
1633                         }
1634                         else if (sInternalChild.equals("action_area") || sInternalChild.equals("messagedialog-action_area"))
1635                         {
1636                             Window *pContentArea = pCurrentChild->GetParent();
1637                             assert(pContentArea && pContentArea->GetType() == WINDOW_CONTAINER);
1638                             if (Dialog *pBoxParent = dynamic_cast<Dialog*>(pContentArea ? pContentArea->GetParent() : NULL))
1639                             {
1640                                 pBoxParent->set_action_area(static_cast<VclButtonBox*>(pCurrentChild));
1641                             }
1642                         }
1643
1644                         //To-Do make reorder a virtual in Window, move this foo
1645                         //there and see above
1646                         std::vector<Window*> aChilds;
1647                         for (Window* pChild = pCurrentChild->GetWindow(WINDOW_FIRSTCHILD); pChild;
1648                             pChild = pChild->GetWindow(WINDOW_NEXT))
1649                         {
1650                             aChilds.push_back(pChild);
1651                         }
1652
1653                         bool bIsButtonBox = dynamic_cast<VclButtonBox*>(pCurrentChild) != NULL;
1654
1655                         //sort child order within parent so that tabbing
1656                         //between controls goes in a visually sensible sequence
1657                         std::stable_sort(aChilds.begin(), aChilds.end(), sortIntoBestTabTraversalOrder(this));
1658                         reorderWithinParent(aChilds, bIsButtonBox);
1659                     }
1660                 }
1661             }
1662             else if (name.equals("packing"))
1663             {
1664                 handlePacking(pCurrentChild, reader);
1665             }
1666             else
1667                 ++nLevel;
1668         }
1669
1670         if (res == xmlreader::XmlReader::RESULT_END)
1671             --nLevel;
1672
1673         if (!nLevel)
1674             break;
1675
1676         if (res == xmlreader::XmlReader::RESULT_DONE)
1677             break;
1678     }
1679 }
1680
1681 void VclBuilder::reorderWithinParent(std::vector<Window*>& rChilds, bool bIsButtonBox)
1682 {
1683     for (size_t i = 0; i < rChilds.size(); ++i)
1684     {
1685         reorderWithinParent(*rChilds[i], i);
1686
1687         if (!bIsButtonBox)
1688             continue;
1689
1690         //The first member of the group for legacy code needs WB_GROUP set and the
1691         //others not
1692         WinBits nBits = rChilds[i]->GetStyle();
1693         nBits &= ~WB_GROUP;
1694         if (i == 0)
1695             nBits |= WB_GROUP;
1696         rChilds[i]->SetStyle(nBits);
1697     }
1698 }
1699
1700 void VclBuilder::collectPangoAttribute(xmlreader::XmlReader &reader, stringmap &rMap)
1701 {
1702     xmlreader::Span span;
1703     int nsId;
1704
1705     OString sProperty;
1706     OString sValue;
1707
1708     while (reader.nextAttribute(&nsId, &span))
1709     {
1710         if (span.equals("name"))
1711         {
1712             span = reader.getAttributeValue(false);
1713             sProperty = OString(span.begin, span.length);
1714         }
1715         else if (span.equals("value"))
1716         {
1717             span = reader.getAttributeValue(false);
1718             sValue = OString(span.begin, span.length);
1719         }
1720     }
1721
1722     if (!sProperty.isEmpty())
1723         rMap[sProperty] = sValue;
1724 }
1725
1726 void VclBuilder::collectAtkAttribute(xmlreader::XmlReader &reader, stringmap &rMap)
1727 {
1728     xmlreader::Span span;
1729     int nsId;
1730
1731     OString sProperty;
1732     OString sValue;
1733
1734     while (reader.nextAttribute(&nsId, &span))
1735     {
1736         if (span.equals("type"))
1737         {
1738             span = reader.getAttributeValue(false);
1739             sProperty = OString(span.begin, span.length);
1740         }
1741         else if (span.equals("target"))
1742         {
1743             span = reader.getAttributeValue(false);
1744             sValue = OString(span.begin, span.length);
1745             sal_Int32 nDelim = sValue.indexOf(':');
1746             if (nDelim != -1)
1747                 sValue = sValue.copy(0, nDelim);
1748         }
1749     }
1750
1751     if (!sProperty.isEmpty())
1752         rMap[sProperty] = sValue;
1753 }
1754
1755 void VclBuilder::handleAdjustment(const OString &rID, stringmap &rProperties)
1756 {
1757     m_pParserState->m_aAdjustments[rID] = rProperties;
1758 }
1759
1760 void VclBuilder::handleTextBuffer(const OString &rID, stringmap &rProperties)
1761 {
1762     m_pParserState->m_aTextBuffers[rID] = rProperties;
1763 }
1764
1765 void VclBuilder::handleRow(xmlreader::XmlReader &reader, const OString &rID, sal_Int32 nRowIndex)
1766 {
1767     int nLevel = 1;
1768
1769     ListStore::row aRow;
1770
1771     while(1)
1772     {
1773         xmlreader::Span name;
1774         int nsId;
1775
1776         xmlreader::XmlReader::Result res = reader.nextItem(
1777             xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
1778
1779         if (res == xmlreader::XmlReader::RESULT_DONE)
1780             break;
1781
1782         if (res == xmlreader::XmlReader::RESULT_BEGIN)
1783         {
1784             ++nLevel;
1785             if (name.equals("col"))
1786             {
1787                 bool bTranslated = false;
1788                 OString sValue;
1789                 sal_uInt32 nId = 0;
1790
1791                 while (reader.nextAttribute(&nsId, &name))
1792                 {
1793                     if (name.equals("id"))
1794                     {
1795                         name = reader.getAttributeValue(false);
1796                         nId = OString(name.begin, name.length).toInt32();
1797                     }
1798                     else if (nId == 0 && name.equals("translatable") && reader.getAttributeValue(false).equals("yes"))
1799                     {
1800                         sValue = getTranslation(rID, OString::valueOf(nRowIndex));
1801                         bTranslated = !sValue.isEmpty();
1802                     }
1803                 }
1804
1805                 reader.nextItem(
1806                     xmlreader::XmlReader::TEXT_RAW, &name, &nsId);
1807
1808                 if (!bTranslated)
1809                     sValue = OString(name.begin, name.length);
1810
1811                 if (aRow.size() < nId+1)
1812                     aRow.resize(nId+1);
1813                 aRow[nId] = sValue;
1814             }
1815         }
1816
1817         if (res == xmlreader::XmlReader::RESULT_END)
1818         {
1819             --nLevel;
1820         }
1821
1822         if (!nLevel)
1823             break;
1824     }
1825
1826     m_pParserState->m_aModels[rID].m_aEntries.push_back(aRow);
1827 }
1828
1829 void VclBuilder::handleListStore(xmlreader::XmlReader &reader, const OString &rID)
1830 {
1831     int nLevel = 1;
1832     sal_Int32 nRowIndex = 0;
1833
1834     while(1)
1835     {
1836         xmlreader::Span name;
1837         int nsId;
1838
1839         xmlreader::XmlReader::Result res = reader.nextItem(
1840             xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
1841
1842         if (res == xmlreader::XmlReader::RESULT_DONE)
1843             break;
1844
1845         if (res == xmlreader::XmlReader::RESULT_BEGIN)
1846         {
1847             if (name.equals("row"))
1848                 handleRow(reader, rID, nRowIndex++);
1849             else
1850                 ++nLevel;
1851         }
1852
1853         if (res == xmlreader::XmlReader::RESULT_END)
1854         {
1855             --nLevel;
1856         }
1857
1858         if (!nLevel)
1859             break;
1860     }
1861 }
1862
1863 void VclBuilder::handleAtkObject(xmlreader::XmlReader &reader, const OString &rID, Window *pWindow)
1864 {
1865     assert(pWindow);
1866
1867     int nLevel = 1;
1868
1869     stringmap aProperties;
1870
1871     while(1)
1872     {
1873         xmlreader::Span name;
1874         int nsId;
1875
1876         xmlreader::XmlReader::Result res = reader.nextItem(
1877             xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
1878
1879         if (res == xmlreader::XmlReader::RESULT_DONE)
1880             break;
1881
1882         if (res == xmlreader::XmlReader::RESULT_BEGIN)
1883         {
1884             ++nLevel;
1885             if (name.equals("property"))
1886                 collectProperty(reader, rID, aProperties);
1887         }
1888
1889         if (res == xmlreader::XmlReader::RESULT_END)
1890         {
1891             --nLevel;
1892         }
1893
1894         if (!nLevel)
1895             break;
1896     }
1897
1898     for (stringmap::iterator aI = aProperties.begin(), aEnd = aProperties.end(); aI != aEnd; ++aI)
1899     {
1900         const OString &rKey = aI->first;
1901         const OString &rValue = aI->second;
1902
1903         if (rKey.match("AtkObject::"))
1904             pWindow->set_property(rKey.copy(RTL_CONSTASCII_LENGTH("AtkObject::")), rValue);
1905         else
1906             SAL_WARN("vcl.layout", "unhandled atk prop: " << rKey.getStr());
1907     }
1908 }
1909
1910 std::vector<OString> VclBuilder::handleItems(xmlreader::XmlReader &reader, const OString &rID)
1911 {
1912     int nLevel = 1;
1913
1914     std::vector<OString> aItems;
1915     sal_Int32 nItemIndex = 0;
1916
1917     while(1)
1918     {
1919         xmlreader::Span name;
1920         int nsId;
1921
1922         xmlreader::XmlReader::Result res = reader.nextItem(
1923             xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
1924
1925         if (res == xmlreader::XmlReader::RESULT_DONE)
1926             break;
1927
1928         if (res == xmlreader::XmlReader::RESULT_BEGIN)
1929         {
1930             ++nLevel;
1931             if (name.equals("item"))
1932             {
1933                 bool bTranslated = false;
1934                 OString sValue;
1935
1936                 while (reader.nextAttribute(&nsId, &name))
1937                 {
1938                     if (name.equals("translatable") && reader.getAttributeValue(false).equals("yes"))
1939                     {
1940                         sValue = getTranslation(rID, OString::valueOf(nItemIndex));
1941                         bTranslated = !sValue.isEmpty();
1942                     }
1943                 }
1944
1945                 reader.nextItem(
1946                     xmlreader::XmlReader::TEXT_RAW, &name, &nsId);
1947
1948                 if (!bTranslated)
1949                     sValue = OString(name.begin, name.length);
1950
1951                 if (m_pStringReplace)
1952                 {
1953                     OUString sTmp = (*m_pStringReplace)(OStringToOUString(sValue, RTL_TEXTENCODING_UTF8));
1954                     sValue = OUStringToOString(sTmp, RTL_TEXTENCODING_UTF8);
1955                 }
1956
1957                 aItems.push_back(sValue);
1958                 ++nItemIndex;
1959             }
1960         }
1961
1962         if (res == xmlreader::XmlReader::RESULT_END)
1963         {
1964             --nLevel;
1965         }
1966
1967         if (!nLevel)
1968             break;
1969     }
1970
1971     return aItems;
1972 }
1973
1974 void VclBuilder::handleMenu(xmlreader::XmlReader &reader, const OString &rID)
1975 {
1976     PopupMenu *pCurrentMenu = new PopupMenu;
1977
1978     int nLevel = 1;
1979
1980     stringmap aProperties;
1981
1982     while(1)
1983     {
1984         xmlreader::Span name;
1985         int nsId;
1986
1987         xmlreader::XmlReader::Result res = reader.nextItem(
1988             xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
1989
1990         if (res == xmlreader::XmlReader::RESULT_DONE)
1991             break;
1992
1993         if (res == xmlreader::XmlReader::RESULT_BEGIN)
1994         {
1995             if (name.equals("child"))
1996             {
1997                 handleMenuChild(pCurrentMenu, reader);
1998             }
1999             else
2000             {
2001                 ++nLevel;
2002                 if (name.equals("property"))
2003                     collectProperty(reader, rID, aProperties);
2004             }
2005         }
2006
2007         if (res == xmlreader::XmlReader::RESULT_END)
2008         {
2009             --nLevel;
2010         }
2011
2012         if (!nLevel)
2013             break;
2014     }
2015
2016     m_aMenus.push_back(MenuAndId(rID, pCurrentMenu));
2017 }
2018
2019 void VclBuilder::handleMenuChild(PopupMenu *pParent, xmlreader::XmlReader &reader)
2020 {
2021     xmlreader::Span name;
2022     int nsId;
2023
2024     int nLevel = 1;
2025     while(1)
2026     {
2027         xmlreader::XmlReader::Result res = reader.nextItem(
2028             xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
2029
2030         if (res == xmlreader::XmlReader::RESULT_BEGIN)
2031         {
2032             if (name.equals("object") || name.equals("placeholder"))
2033             {
2034                 handleMenuObject(pParent, reader);
2035             }
2036             else
2037                 ++nLevel;
2038         }
2039
2040         if (res == xmlreader::XmlReader::RESULT_END)
2041             --nLevel;
2042
2043         if (!nLevel)
2044             break;
2045
2046         if (res == xmlreader::XmlReader::RESULT_DONE)
2047             break;
2048     }
2049 }
2050
2051 void VclBuilder::handleMenuObject(PopupMenu *pParent, xmlreader::XmlReader &reader)
2052 {
2053     OString sClass;
2054     OString sID;
2055     OString sCustomProperty;
2056
2057     xmlreader::Span name;
2058     int nsId;
2059
2060     while (reader.nextAttribute(&nsId, &name))
2061     {
2062         if (name.equals("class"))
2063         {
2064             name = reader.getAttributeValue(false);
2065             sClass = OString(name.begin, name.length);
2066         }
2067         else if (name.equals("id"))
2068         {
2069             name = reader.getAttributeValue(false);
2070             sID = OString(name.begin, name.length);
2071             sal_Int32 nDelim = sID.indexOf(':');
2072             if (nDelim != -1)
2073             {
2074                 sCustomProperty = sID.copy(nDelim+1);
2075                 sID = sID.copy(0, nDelim);
2076             }
2077         }
2078     }
2079
2080     int nLevel = 1;
2081
2082     stringmap aProperties, aAccelerators;
2083
2084     if (!sCustomProperty.isEmpty())
2085         aProperties[OString("customproperty")] = sCustomProperty;
2086
2087     while(1)
2088     {
2089         xmlreader::XmlReader::Result res = reader.nextItem(
2090             xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
2091
2092         if (res == xmlreader::XmlReader::RESULT_DONE)
2093             break;
2094
2095         if (res == xmlreader::XmlReader::RESULT_BEGIN)
2096         {
2097             ++nLevel;
2098             if (name.equals("property"))
2099                 collectProperty(reader, sID, aProperties);
2100             else if (name.equals("accelerator"))
2101                 collectAccelerator(reader, aAccelerators);
2102         }
2103
2104         if (res == xmlreader::XmlReader::RESULT_END)
2105         {
2106             --nLevel;
2107         }
2108
2109         if (!nLevel)
2110             break;
2111     }
2112
2113     insertMenuObject(pParent, sClass, sID, aProperties, aAccelerators);
2114 }
2115
2116 void VclBuilder::handleSizeGroup(xmlreader::XmlReader &reader, const OString &rID)
2117 {
2118     m_pParserState->m_aSizeGroups.push_back(SizeGroup(rID));
2119     SizeGroup &rSizeGroup = m_pParserState->m_aSizeGroups.back();
2120
2121     int nLevel = 1;
2122
2123     while(1)
2124     {
2125         xmlreader::Span name;
2126         int nsId;
2127
2128         xmlreader::XmlReader::Result res = reader.nextItem(
2129             xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
2130
2131         if (res == xmlreader::XmlReader::RESULT_DONE)
2132             break;
2133
2134         if (res == xmlreader::XmlReader::RESULT_BEGIN)
2135         {
2136             ++nLevel;
2137             if (name.equals("widget"))
2138             {
2139                 while (reader.nextAttribute(&nsId, &name))
2140                 {
2141                     if (name.equals("name"))
2142                     {
2143                         name = reader.getAttributeValue(false);
2144                         OString sWidget = OString(name.begin, name.length);
2145                         sal_Int32 nDelim = sWidget.indexOf(':');
2146                         if (nDelim != -1)
2147                             sWidget = sWidget.copy(0, nDelim);
2148                         rSizeGroup.m_aWidgets.push_back(sWidget);
2149                     }
2150                 }
2151             }
2152             else
2153             {
2154                 if (name.equals("property"))
2155                     collectProperty(reader, rID, rSizeGroup.m_aProperties);
2156             }
2157         }
2158
2159         if (res == xmlreader::XmlReader::RESULT_END)
2160         {
2161             --nLevel;
2162         }
2163
2164         if (!nLevel)
2165             break;
2166     }
2167 }
2168
2169 OString VclBuilder::convertMnemonicMarkup(const OString &rIn)
2170 {
2171     OStringBuffer aRet(rIn);
2172     for (sal_Int32 nI = 0; nI < aRet.getLength(); ++nI)
2173     {
2174         if (aRet[nI] == '_')
2175         {
2176             if (aRet[nI+1] != '_')
2177                 aRet[nI] = MNEMONIC_CHAR;
2178             else
2179                 aRet.remove(nI, 1);
2180             ++nI;
2181         }
2182     }
2183     return aRet.makeStringAndClear();
2184 }
2185
2186 namespace
2187 {
2188     KeyCode makeKeyCode(const OString &rKey)
2189     {
2190         if (rKey == "Insert")
2191             return KeyCode(KEY_INSERT);
2192         else if (rKey == "Delete")
2193             return KeyCode(KEY_DELETE);
2194
2195         assert (rKey.getLength() == 1);
2196         sal_Char cChar = rKey.toChar();
2197
2198         if (cChar >= 'a' && cChar <= 'z')
2199             return KeyCode(KEY_A + (cChar - 'a'));
2200         else if (cChar >= 'A' && cChar <= 'Z')
2201             return KeyCode(KEY_A + (cChar - 'A'));
2202         else if (cChar >= '0' && cChar <= '9')
2203             return KeyCode(KEY_0 + (cChar - 'A'));
2204
2205         return KeyCode(cChar);
2206     }
2207 }
2208
2209 void VclBuilder::insertMenuObject(PopupMenu *pParent, const OString &rClass, const OString &rID,
2210     stringmap &rProps, stringmap &rAccels)
2211 {
2212     sal_uInt16 nOldCount = pParent->GetItemCount();
2213     sal_uInt16 nNewId = nOldCount + 1;
2214
2215     if (rClass == "GtkMenuItem")
2216     {
2217         OUString sLabel(OStringToOUString(convertMnemonicMarkup(extractLabel(rProps)), RTL_TEXTENCODING_UTF8));
2218         pParent->InsertItem(nNewId, sLabel, MIB_TEXT, rID);
2219     }
2220     else if (rClass == "GtkSeparatorMenuItem")
2221     {
2222         pParent->InsertSeparator(rID);
2223     }
2224
2225     SAL_WARN_IF(nOldCount == pParent->GetItemCount(), "vcl.layout", "probably need to implement " << rClass.getStr());
2226
2227     if (nOldCount != pParent->GetItemCount())
2228     {
2229         pParent->SetHelpId(nNewId, m_sHelpRoot + rID);
2230
2231         for (stringmap::iterator aI = rProps.begin(), aEnd = rProps.end(); aI != aEnd; ++aI)
2232         {
2233             const OString &rKey = aI->first;
2234             const OString &rValue = aI->second;
2235
2236             if (rKey == "tooltip-markup")
2237                 pParent->SetTipHelpText(nNewId, OStringToOUString(rValue, RTL_TEXTENCODING_UTF8));
2238             else if (rKey == "tooltip-text")
2239                 pParent->SetTipHelpText(nNewId, OStringToOUString(rValue, RTL_TEXTENCODING_UTF8));
2240             else if (rKey == "visible")
2241                 pParent->ShowItem(nNewId, toBool(rValue));
2242             else if (rKey == "has-default" && toBool(rValue))
2243                 pParent->SetSelectedEntry(nNewId);
2244             else
2245                 SAL_INFO("vcl.layout", "unhandled property: " << rKey.getStr());
2246         }
2247
2248         for (stringmap::iterator aI = rAccels.begin(), aEnd = rAccels.end(); aI != aEnd; ++aI)
2249         {
2250             const OString &rSignal = aI->first;
2251             const OString &rValue = aI->second;
2252
2253             if (rSignal == "activate")
2254                 pParent->SetAccelKey(nNewId, makeKeyCode(rValue));
2255             else
2256                 SAL_INFO("vcl.layout", "unhandled accelerator for: " << rSignal.getStr());
2257         }
2258     }
2259
2260     rProps.clear();
2261 }
2262
2263 Window* VclBuilder::handleObject(Window *pParent, xmlreader::XmlReader &reader)
2264 {
2265     OString sClass;
2266     OString sID;
2267     OString sCustomProperty;
2268
2269     xmlreader::Span name;
2270     int nsId;
2271
2272     while (reader.nextAttribute(&nsId, &name))
2273     {
2274         if (name.equals("class"))
2275         {
2276             name = reader.getAttributeValue(false);
2277             sClass = OString(name.begin, name.length);
2278         }
2279         else if (name.equals("id"))
2280         {
2281             name = reader.getAttributeValue(false);
2282             sID = OString(name.begin, name.length);
2283             sal_Int32 nDelim = sID.indexOf(':');
2284             if (nDelim != -1)
2285             {
2286                 sCustomProperty = sID.copy(nDelim+1);
2287                 sID = sID.copy(0, nDelim);
2288             }
2289         }
2290     }
2291
2292     if (sClass == "GtkListStore")
2293     {
2294         handleListStore(reader, sID);
2295         return NULL;
2296     }
2297     else if (sClass == "GtkMenu")
2298     {
2299         handleMenu(reader, sID);
2300         return NULL;
2301     }
2302     else if (sClass == "GtkSizeGroup")
2303     {
2304         handleSizeGroup(reader, sID);
2305         return NULL;
2306     }
2307     else if (sClass == "AtkObject")
2308     {
2309         handleAtkObject(reader, sID, pParent);
2310         return NULL;
2311     }
2312
2313     int nLevel = 1;
2314
2315     stringmap aProperties, aPangoAttributes, aAtkAttributes;
2316     std::vector<OString> aItems;
2317
2318     if (!sCustomProperty.isEmpty())
2319         aProperties[OString("customproperty")] = sCustomProperty;
2320
2321     Window *pCurrentChild = NULL;
2322     while(1)
2323     {
2324         xmlreader::XmlReader::Result res = reader.nextItem(
2325             xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
2326
2327         if (res == xmlreader::XmlReader::RESULT_DONE)
2328             break;
2329
2330         if (res == xmlreader::XmlReader::RESULT_BEGIN)
2331         {
2332             if (name.equals("child"))
2333             {
2334                 if (!pCurrentChild)
2335                 {
2336                     pCurrentChild = insertObject(pParent, sClass, sID,
2337                         aProperties, aPangoAttributes, aAtkAttributes, aItems);
2338                 }
2339                 handleChild(pCurrentChild, reader);
2340             }
2341             else if (name.equals("items"))
2342                 aItems = handleItems(reader, sID);
2343             else
2344             {
2345                 ++nLevel;
2346                 if (name.equals("property"))
2347                     collectProperty(reader, sID, aProperties);
2348                 else if (name.equals("attribute"))
2349                     collectPangoAttribute(reader, aPangoAttributes);
2350                 else if (name.equals("relation"))
2351                     collectAtkAttribute(reader, aAtkAttributes);
2352                 else if (name.equals("action-widget"))
2353                     handleActionWidget(reader);
2354             }
2355         }
2356
2357         if (res == xmlreader::XmlReader::RESULT_END)
2358         {
2359             --nLevel;
2360         }
2361
2362         if (!nLevel)
2363             break;
2364     }
2365
2366     if (sClass == "GtkAdjustment")
2367     {
2368         handleAdjustment(sID, aProperties);
2369         return NULL;
2370     }
2371     else if (sClass == "GtkTextBuffer")
2372     {
2373         handleTextBuffer(sID, aProperties);
2374         return NULL;
2375     }
2376
2377     if (!pCurrentChild)
2378     {
2379         pCurrentChild = insertObject(pParent, sClass, sID, aProperties,
2380             aPangoAttributes, aAtkAttributes, aItems);
2381     }
2382
2383     return pCurrentChild;
2384 }
2385
2386 void VclBuilder::handlePacking(Window *pCurrent, xmlreader::XmlReader &reader)
2387 {
2388     xmlreader::Span name;
2389     int nsId;
2390
2391     int nLevel = 1;
2392
2393     while(1)
2394     {
2395         xmlreader::XmlReader::Result res = reader.nextItem(
2396             xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
2397
2398         if (res == xmlreader::XmlReader::RESULT_DONE)
2399             break;
2400
2401         if (res == xmlreader::XmlReader::RESULT_BEGIN)
2402         {
2403             ++nLevel;
2404             if (name.equals("property"))
2405                 applyPackingProperty(pCurrent, reader);
2406         }
2407
2408         if (res == xmlreader::XmlReader::RESULT_END)
2409         {
2410             --nLevel;
2411         }
2412
2413         if (!nLevel)
2414             break;
2415     }
2416 }
2417
2418 void VclBuilder::applyPackingProperty(Window *pCurrent,
2419     xmlreader::XmlReader &reader)
2420 {
2421     if (!pCurrent)
2422         return;
2423
2424     xmlreader::Span name;
2425     int nsId;
2426
2427     if (pCurrent->GetType() == WINDOW_SCROLLWINDOW)
2428     {
2429         std::map<Window*, Window*>::iterator aFind = m_pParserState->m_aRedundantParentWidgets.find(pCurrent);
2430         if (aFind != m_pParserState->m_aRedundantParentWidgets.end())
2431         {
2432             pCurrent = aFind->second;
2433             assert(pCurrent);
2434         }
2435     }
2436
2437     while (reader.nextAttribute(&nsId, &name))
2438     {
2439         if (name.equals("name"))
2440         {
2441             name = reader.getAttributeValue(false);
2442             OString sKey(name.begin, name.length);
2443             sKey = sKey.replace('_', '-');
2444             reader.nextItem(
2445                 xmlreader::XmlReader::TEXT_RAW, &name, &nsId);
2446             OString sValue(name.begin, name.length);
2447
2448             if (sKey == "expand")
2449             {
2450                 bool bTrue = (sValue[0] == 't' || sValue[0] == 'T' || sValue[0] == '1');
2451                 pCurrent->set_expand(bTrue);
2452             }
2453             else if (sKey == "fill")
2454             {
2455                 bool bTrue = (sValue[0] == 't' || sValue[0] == 'T' || sValue[0] == '1');
2456                 pCurrent->set_fill(bTrue);
2457             }
2458             else if (sKey == "pack-type")
2459             {
2460                 VclPackType ePackType = (sValue[0] == 'e' || sValue[0] == 'E') ? VCL_PACK_END : VCL_PACK_START;
2461                 pCurrent->set_pack_type(ePackType);
2462             }
2463             else if (sKey == "left-attach")
2464             {
2465                 pCurrent->set_grid_left_attach(sValue.toInt32());
2466             }
2467             else if (sKey == "top-attach")
2468             {
2469                 pCurrent->set_grid_top_attach(sValue.toInt32());
2470             }
2471             else if (sKey == "width")
2472             {
2473                 pCurrent->set_grid_width(sValue.toInt32());
2474             }
2475             else if (sKey == "height")
2476             {
2477                 pCurrent->set_grid_height(sValue.toInt32());
2478             }
2479             else if (sKey == "padding")
2480             {
2481                 pCurrent->set_padding(sValue.toInt32());
2482             }
2483             else if (sKey == "position")
2484             {
2485                 set_window_packing_position(pCurrent, sValue.toInt32());
2486             }
2487             else if (sKey == "secondary")
2488             {
2489                 pCurrent->set_secondary(toBool(sValue));
2490             }
2491             else
2492             {
2493                 SAL_WARN("vcl.layout", "unknown packing: " << sKey.getStr());
2494             }
2495         }
2496     }
2497 }
2498
2499 OString VclBuilder::getTranslation(const OString &rID, const OString &rProperty) const
2500 {
2501     Translations::const_iterator aWidgetFind = m_pParserState->m_aTranslations.find(rID);
2502     if (aWidgetFind != m_pParserState->m_aTranslations.end())
2503     {
2504         const WidgetTranslations &rWidgetTranslations = aWidgetFind->second;
2505         WidgetTranslations::const_iterator aPropertyFind = rWidgetTranslations.find(rProperty);
2506         if (aPropertyFind != rWidgetTranslations.end())
2507             return aPropertyFind->second;
2508     }
2509     return OString();
2510 }
2511
2512 void VclBuilder::collectProperty(xmlreader::XmlReader &reader, const OString &rID, stringmap &rMap)
2513 {
2514     xmlreader::Span name;
2515     int nsId;
2516
2517     OString sProperty;
2518     OString sValue;
2519
2520     bool bTranslated = false;
2521
2522     while (reader.nextAttribute(&nsId, &name))
2523     {
2524         if (name.equals("name"))
2525         {
2526             name = reader.getAttributeValue(false);
2527             sProperty = OString(name.begin, name.length);
2528         }
2529         else if (name.equals("translatable") && reader.getAttributeValue(false).equals("yes"))
2530         {
2531             sValue = getTranslation(rID, sProperty);
2532             bTranslated = !sValue.isEmpty();
2533         }
2534
2535     }
2536
2537     reader.nextItem(xmlreader::XmlReader::TEXT_RAW, &name, &nsId);
2538     if (!bTranslated)
2539         sValue = OString(name.begin, name.length);
2540
2541     if (!sProperty.isEmpty())
2542     {
2543         sProperty = sProperty.replace('_', '-');
2544         if (m_pStringReplace)
2545         {
2546             OUString sTmp = (*m_pStringReplace)(OStringToOUString(sValue, RTL_TEXTENCODING_UTF8));
2547             rMap[sProperty] = OUStringToOString(sTmp, RTL_TEXTENCODING_UTF8);
2548         }
2549         else
2550         {
2551             rMap[sProperty] = sValue;
2552         }
2553     }
2554 }
2555
2556 void VclBuilder::handleActionWidget(xmlreader::XmlReader &reader)
2557 {
2558     xmlreader::Span name;
2559     int nsId;
2560
2561     OString sResponse;
2562
2563     while (reader.nextAttribute(&nsId, &name))
2564     {
2565         if (name.equals("response"))
2566         {
2567             name = reader.getAttributeValue(false);
2568             sResponse = OString(name.begin, name.length);
2569         }
2570     }
2571
2572     reader.nextItem(xmlreader::XmlReader::TEXT_RAW, &name, &nsId);
2573     OString sID = OString(name.begin, name.length);
2574     sal_Int32 nDelim = sID.indexOf(':');
2575     if (nDelim != -1)
2576         sID = sID.copy(0, nDelim);
2577     set_response(sID, sResponse.toInt32());
2578 }
2579
2580
2581 void VclBuilder::collectAccelerator(xmlreader::XmlReader &reader, stringmap &rMap)
2582 {
2583     xmlreader::Span name;
2584     int nsId;
2585
2586     OString sProperty;
2587     OString sValue;
2588
2589     while (reader.nextAttribute(&nsId, &name))
2590     {
2591         if (name.equals("key"))
2592         {
2593             name = reader.getAttributeValue(false);
2594             sValue = OString(name.begin, name.length);
2595         }
2596         else if (name.equals("signal"))
2597         {
2598             name = reader.getAttributeValue(false);
2599             sProperty = OString(name.begin, name.length);
2600         }
2601
2602     }
2603
2604     if (!sProperty.isEmpty() && !sValue.isEmpty())
2605     {
2606         rMap[sProperty] = sValue;
2607     }
2608 }
2609
2610 Window *VclBuilder::get_widget_root()
2611 {
2612     return m_aChildren.empty() ? NULL : m_aChildren[0].m_pWindow;
2613 }
2614
2615 Window *VclBuilder::get_by_name(OString sID)
2616 {
2617     for (std::vector<WinAndId>::iterator aI = m_aChildren.begin(),
2618          aEnd = m_aChildren.end(); aI != aEnd; ++aI)
2619     {
2620         if (aI->m_sID.equals(sID))
2621             return aI->m_pWindow;
2622     }
2623
2624     return NULL;
2625 }
2626
2627 PopupMenu *VclBuilder::get_menu(OString sID)
2628 {
2629     for (std::vector<MenuAndId>::iterator aI = m_aMenus.begin(),
2630          aEnd = m_aMenus.end(); aI != aEnd; ++aI)
2631     {
2632         if (aI->m_sID.equals(sID))
2633             return aI->m_pMenu;
2634     }
2635
2636     return NULL;
2637 }
2638
2639 short VclBuilder::get_response(const Window *pWindow) const
2640 {
2641     for (std::vector<WinAndId>::const_iterator aI = m_aChildren.begin(),
2642          aEnd = m_aChildren.end(); aI != aEnd; ++aI)
2643     {
2644         if (aI->m_pWindow == pWindow)
2645         {
2646             return aI->m_nResponseId;
2647         }
2648     }
2649
2650     //how did we not find sID ?
2651     assert(false);
2652     return RET_CANCEL;
2653 }
2654
2655 void VclBuilder::set_response(OString sID, short nResponse)
2656 {
2657     for (std::vector<WinAndId>::iterator aI = m_aChildren.begin(),
2658          aEnd = m_aChildren.end(); aI != aEnd; ++aI)
2659     {
2660         if (aI->m_sID.equals(sID))
2661         {
2662             aI->m_nResponseId = nResponse;
2663             return;
2664         }
2665     }
2666
2667     //how did we not find sID ?
2668     assert(false);
2669 }
2670
2671 void VclBuilder::delete_by_name(OString sID)
2672 {
2673     for (std::vector<WinAndId>::iterator aI = m_aChildren.begin(),
2674          aEnd = m_aChildren.end(); aI != aEnd; ++aI)
2675     {
2676         if (aI->m_sID.equals(sID))
2677         {
2678             delete aI->m_pWindow;
2679             m_aChildren.erase(aI);
2680             break;
2681         }
2682     }
2683 }
2684
2685 void VclBuilder::delete_by_window(const Window *pWindow)
2686 {
2687     for (std::vector<WinAndId>::iterator aI = m_aChildren.begin(),
2688          aEnd = m_aChildren.end(); aI != aEnd; ++aI)
2689     {
2690         if (aI->m_pWindow == pWindow)
2691         {
2692             delete aI->m_pWindow;
2693             m_aChildren.erase(aI);
2694             break;
2695         }
2696     }
2697 }
2698
2699 OString VclBuilder::get_by_window(const Window *pWindow) const
2700 {
2701     for (std::vector<WinAndId>::const_iterator aI = m_aChildren.begin(),
2702          aEnd = m_aChildren.end(); aI != aEnd; ++aI)
2703     {
2704         if (aI->m_pWindow == pWindow)
2705             return aI->m_sID;
2706     }
2707
2708     return OString();
2709 }
2710
2711 VclBuilder::PackingData VclBuilder::get_window_packing_data(const Window *pWindow) const
2712 {
2713     //We've stored the return of new Control, some of these get
2714     //border windows placed around them which are what you get
2715     //from GetChild, so scoot up a level if necessary to get the
2716     //window whose position value we have
2717     const Window *pPropHolder = pWindow->mpWindowImpl->mpClientWindow ?
2718         pWindow->mpWindowImpl->mpClientWindow : pWindow;
2719
2720     for (std::vector<WinAndId>::const_iterator aI = m_aChildren.begin(),
2721          aEnd = m_aChildren.end(); aI != aEnd; ++aI)
2722     {
2723         if (aI->m_pWindow == pPropHolder)
2724             return aI->m_aPackingData;
2725     }
2726
2727     return PackingData();
2728 }
2729
2730 void VclBuilder::set_window_packing_position(const Window *pWindow, sal_Int32 nPosition)
2731 {
2732     for (std::vector<WinAndId>::iterator aI = m_aChildren.begin(),
2733          aEnd = m_aChildren.end(); aI != aEnd; ++aI)
2734     {
2735         if (aI->m_pWindow == pWindow)
2736             aI->m_aPackingData.m_nPosition = nPosition;
2737     }
2738 }
2739
2740 const VclBuilder::ListStore *VclBuilder::get_model_by_name(OString sID) const
2741 {
2742     std::map<OString, ListStore>::const_iterator aI = m_pParserState->m_aModels.find(sID);
2743     if (aI != m_pParserState->m_aModels.end())
2744         return &(aI->second);
2745     return NULL;
2746 }
2747
2748 const VclBuilder::TextBuffer *VclBuilder::get_buffer_by_name(OString sID) const
2749 {
2750     std::map<OString, TextBuffer>::const_iterator aI = m_pParserState->m_aTextBuffers.find(sID);
2751     if (aI != m_pParserState->m_aTextBuffers.end())
2752         return &(aI->second);
2753     return NULL;
2754 }
2755
2756 const VclBuilder::Adjustment *VclBuilder::get_adjustment_by_name(OString sID) const
2757 {
2758     std::map<OString, Adjustment>::const_iterator aI = m_pParserState->m_aAdjustments.find(sID);
2759     if (aI != m_pParserState->m_aAdjustments.end())
2760         return &(aI->second);
2761     return NULL;
2762 }
2763
2764 void VclBuilder::mungeModel(ListBox &rTarget, const ListStore &rStore, sal_uInt16 nActiveId)
2765 {
2766     for (std::vector<ListStore::row>::const_iterator aI = rStore.m_aEntries.begin(), aEnd = rStore.m_aEntries.end();
2767         aI != aEnd; ++aI)
2768     {
2769         const ListStore::row &rRow = *aI;
2770         sal_uInt16 nEntry = rTarget.InsertEntry(OStringToOUString(rRow[0], RTL_TEXTENCODING_UTF8));
2771         if (rRow.size() > 1)
2772         {
2773             sal_IntPtr nValue = rRow[1].toInt32();
2774             rTarget.SetEntryData(nEntry, (void*)nValue);
2775         }
2776     }
2777     if (nActiveId < rStore.m_aEntries.size())
2778         rTarget.SelectEntryPos(nActiveId);
2779 }
2780
2781 void VclBuilder::mungeAdjustment(NumericFormatter &rTarget, const Adjustment &rAdjustment)
2782 {
2783     int nMul = rtl_math_pow10Exp(1, rTarget.GetDecimalDigits());
2784
2785     for (stringmap::const_iterator aI = rAdjustment.begin(), aEnd = rAdjustment.end(); aI != aEnd; ++aI)
2786     {
2787         const OString &rKey = aI->first;
2788         const OString &rValue = aI->second;
2789
2790         if (rKey == "upper")
2791         {
2792             sal_Int64 nUpper = rValue.toDouble() * nMul;
2793             rTarget.SetMax(nUpper);
2794             rTarget.SetLast(nUpper);
2795         }
2796         else if (rKey == "lower")
2797         {
2798             sal_Int64 nLower = rValue.toDouble() * nMul;
2799             rTarget.SetMin(nLower);
2800             rTarget.SetFirst(nLower);
2801         }
2802         else if (rKey == "value")
2803         {
2804             sal_Int64 nValue = rValue.toDouble() * nMul;
2805             rTarget.SetValue(nValue);
2806         }
2807         else if (rKey == "step-increment")
2808         {
2809             sal_Int64 nSpinSize = rValue.toDouble() * nMul;
2810             rTarget.SetSpinSize(nSpinSize);
2811         }
2812         else
2813         {
2814             SAL_INFO("vcl.layout", "unhandled property :" << rKey.getStr());
2815         }
2816     }
2817 }
2818
2819 void VclBuilder::mungeAdjustment(TimeField &rTarget, const Adjustment &rAdjustment)
2820 {
2821     for (stringmap::const_iterator aI = rAdjustment.begin(), aEnd = rAdjustment.end(); aI != aEnd; ++aI)
2822     {
2823         const OString &rKey = aI->first;
2824         const OString &rValue = aI->second;
2825
2826         if (rKey == "upper")
2827         {
2828             Time aUpper(rValue.toInt32());
2829             rTarget.SetMax(aUpper);
2830             rTarget.SetLast(aUpper);
2831         }
2832         else if (rKey == "lower")
2833         {
2834             Time aLower(rValue.toInt32());
2835             rTarget.SetMin(aLower);
2836             rTarget.SetFirst(aLower);
2837         }
2838         else if (rKey == "value")
2839         {
2840             Time aValue(rValue.toInt32());
2841             rTarget.SetTime(aValue);
2842         }
2843         else
2844         {
2845             SAL_INFO("vcl.layout", "unhandled property :" << rKey.getStr());
2846         }
2847     }
2848 }
2849
2850 void VclBuilder::mungeAdjustment(DateField &rTarget, const Adjustment &rAdjustment)
2851 {
2852     for (stringmap::const_iterator aI = rAdjustment.begin(), aEnd = rAdjustment.end(); aI != aEnd; ++aI)
2853     {
2854         const OString &rKey = aI->first;
2855         const OString &rValue = aI->second;
2856
2857         if (rKey == "upper")
2858         {
2859             Date aUpper(rValue.toInt32());
2860             rTarget.SetMax(aUpper);
2861             rTarget.SetLast(aUpper);
2862         }
2863         else if (rKey == "lower")
2864         {
2865             Date aLower(rValue.toInt32());
2866             rTarget.SetMin(aLower);
2867             rTarget.SetFirst(aLower);
2868         }
2869         else if (rKey == "value")
2870         {
2871             Date aValue(rValue.toInt32());
2872             rTarget.SetDate(aValue);
2873         }
2874         else
2875         {
2876             SAL_INFO("vcl.layout", "unhandled property :" << rKey.getStr());
2877         }
2878     }
2879 }
2880
2881 void VclBuilder::mungeAdjustment(ScrollBar &rTarget, const Adjustment &rAdjustment)
2882 {
2883     for (stringmap::const_iterator aI = rAdjustment.begin(), aEnd = rAdjustment.end(); aI != aEnd; ++aI)
2884     {
2885         const OString &rKey = aI->first;
2886         const OString &rValue = aI->second;
2887
2888         if (rKey == "upper")
2889             rTarget.SetRangeMax(rValue.toInt32());
2890         else if (rKey == "lower")
2891             rTarget.SetRangeMin(rValue.toInt32());
2892         else if (rKey == "value")
2893             rTarget.SetThumbPos(rValue.toInt32());
2894         else if (rKey == "step-increment")
2895             rTarget.SetLineSize(rValue.toInt32());
2896         else if (rKey == "page-increment")
2897             rTarget.SetPageSize(rValue.toInt32());
2898         else
2899         {
2900             SAL_INFO("vcl.layout", "unhandled property :" << rKey.getStr());
2901         }
2902     }
2903 }
2904
2905 void VclBuilder::mungeTextBuffer(VclMultiLineEdit &rTarget, const TextBuffer &rTextBuffer)
2906 {
2907     for (stringmap::const_iterator aI = rTextBuffer.begin(), aEnd = rTextBuffer.end(); aI != aEnd; ++aI)
2908     {
2909         const OString &rKey = aI->first;
2910         const OString &rValue = aI->second;
2911
2912         if (rKey == "text")
2913             rTarget.SetText(OStringToOUString(rValue, RTL_TEXTENCODING_UTF8));
2914         else
2915         {
2916             SAL_INFO("vcl.layout", "unhandled property :" << rKey.getStr());
2917         }
2918     }
2919 }
2920
2921 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */