?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bump version to 6.4-15
[LibreOffice.git] / svx / source / form / datanavi.cxx
bloba409731f18c02d7c5ff5324d4189ce6d95cb0d2e
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <sal/config.h>
21
22 #include <memory>
23
24 #include <sal/macros.h>
25 #include <sal/log.hxx>
26 #include <datanavi.hxx>
27 #include <fmservs.hxx>
28
29 #include <bitmaps.hlst>
30 #include <fpicker/strings.hrc>
31 #include <svx/svxids.hrc>
32 #include <tools/diagnose_ex.h>
33 #include <unotools/resmgr.hxx>
34 #include <svx/xmlexchg.hxx>
35 #include <svx/fmshell.hxx>
36 #include <svtools/miscopt.hxx>
37 #include <unotools/pathoptions.hxx>
38 #include <unotools/viewoptions.hxx>
39 #include <vcl/treelistentry.hxx>
40 #include <sfx2/app.hxx>
41 #include <sfx2/filedlghelper.hxx>
42 #include <sfx2/objitem.hxx>
43 #include <sfx2/viewfrm.hxx>
44 #include <sfx2/objsh.hxx>
45 #include <sfx2/bindings.hxx>
46 #include <sfx2/dispatch.hxx>
47 #include <vcl/weld.hxx>
48 #include <vcl/builderfactory.hxx>
49 #include <com/sun/star/beans/PropertyAttribute.hpp>
50 #include <com/sun/star/container/XSet.hpp>
51 #include <com/sun/star/datatransfer/XTransferable.hpp>
52 #include <com/sun/star/frame/XController.hpp>
53 #include <com/sun/star/frame/XModel.hpp>
54 #include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
55 #include <com/sun/star/xforms/XFormsSupplier.hpp>
56 #include <com/sun/star/xml/dom/XDocument.hpp>
57 #include <com/sun/star/xml/dom/DOMException.hpp>
58 #include <com/sun/star/form/binding/XValueBinding.hpp>
59 #include <comphelper/string.hxx>
60
61 using namespace ::com::sun::star::beans;
62 using namespace ::com::sun::star::container;
63 using namespace ::com::sun::star::datatransfer;
64 using namespace ::com::sun::star::frame;
65 using namespace ::com::sun::star::uno;
66 using namespace ::com::sun::star::xml::dom::events;
67 using namespace ::svx;
68
69 #define CFGNAME_DATANAVIGATOR "DataNavigator"
70 #define CFGNAME_SHOWDETAILS "ShowDetails"
71 #define MSG_VARIABLE "%1"
72 #define MODELNAME "$MODELNAME"
73 #define INSTANCENAME "$INSTANCENAME"
74 #define ELEMENTNAME "$ELEMENTNAME"
75 #define ATTRIBUTENAME "$ATTRIBUTENAME"
76 #define SUBMISSIONNAME "$SUBMISSIONNAME"
77 #define BINDINGNAME "$BINDINGNAME"
78
79
80 namespace svxform
81 {
82
83 // properties of instance
84 #define PN_INSTANCE_MODEL "Instance"
85 #define PN_INSTANCE_ID "ID"
86 #define PN_INSTANCE_URL "URL"
87
88 // properties of binding
89 #define PN_BINDING_ID "BindingID"
90 #define PN_BINDING_EXPR "BindingExpression"
91 #define PN_BINDING_MODEL "Model"
92 #define PN_BINDING_NAMESPACES "ModelNamespaces"
93 #define PN_READONLY_EXPR "ReadonlyExpression"
94 #define PN_RELEVANT_EXPR "RelevantExpression"
95 #define PN_REQUIRED_EXPR "RequiredExpression"
96 #define PN_CONSTRAINT_EXPR "ConstraintExpression"
97 #define PN_CALCULATE_EXPR "CalculateExpression"
98 #define PN_BINDING_TYPE "Type"
99
100 // properties of submission
101 #define PN_SUBMISSION_ID "ID"
102 #define PN_SUBMISSION_BIND "Bind"
103 #define PN_SUBMISSION_REF "Ref"
104 #define PN_SUBMISSION_ACTION "Action"
105 #define PN_SUBMISSION_METHOD "Method"
106 #define PN_SUBMISSION_REPLACE "Replace"
107
108 // other const strings
109 #define TRUE_VALUE "true()"
110 #define NEW_ELEMENT "newElement"
111 #define NEW_ATTRIBUTE "newAttribute"
112 #define EVENTTYPE_CHARDATA "DOMCharacterDataModified"
113 #define EVENTTYPE_ATTR "DOMAttrModified"
114
115 #define MIN_PAGE_COUNT 3 // at least one instance, one submission and one binding page
116
117 struct ItemNode
118 {
119 Reference< css::xml::dom::XNode > m_xNode;
120 Reference< XPropertySet > m_xPropSet;
121
122 explicit ItemNode( const Reference< css::xml::dom::XNode >& _rxNode ) :
123 m_xNode( _rxNode ) {}
124 explicit ItemNode( const Reference< XPropertySet >& _rxSet ) :
125 m_xPropSet( _rxSet ) {}
126 };
127
128 DataTreeListBox::DataTreeListBox(vcl::Window* pParent, WinBits nBits)
129 : SvTreeListBox(pParent, nBits)
130 , m_pXFormsPage(nullptr)
131 , m_eGroup(DGTUnknown)
132 , m_nAddId(0)
133 , m_nAddElementId(0)
134 , m_nAddAttributeId(0)
135 , m_nEditId(0)
136 , m_nRemoveId(0)
137 {
138 EnableContextMenuHandling();
139
140 if ( DGTInstance == m_eGroup )
141 SetDragDropMode( DragDropMode::CTRL_MOVE |DragDropMode::CTRL_COPY | DragDropMode::APP_COPY );
142 }
143
144 DataTreeListBox::~DataTreeListBox()
145 {
146 disposeOnce();
147 }
148
149 void DataTreeListBox::dispose()
150 {
151 DeleteAndClear();
152 m_xMenu.clear();
153 m_xBuilder.reset();
154 m_pXFormsPage.clear();
155 SvTreeListBox::dispose();
156 }
157
158 sal_Int8 DataTreeListBox::AcceptDrop( const AcceptDropEvent& /*rEvt*/ )
159 {
160 return DND_ACTION_NONE;
161 }
162
163 sal_Int8 DataTreeListBox::ExecuteDrop( const ExecuteDropEvent& /*rEvt*/ )
164 {
165 return DND_ACTION_NONE;
166 }
167
168 void DataTreeListBox::StartDrag( sal_Int8 /*_nAction*/, const Point& /*_rPosPixel*/ )
169 {
170 SvTreeListEntry* pSelected = FirstSelected();
171 if ( !pSelected )
172 // no drag without an entry
173 return;
174
175 if ( m_eGroup == DGTBinding )
176 // for the moment, bindings cannot be dragged.
177 // #i59395# / 2005-12-15 / frank.schoenheit@sun.com
178 return;
179
180 // GetServiceNameForNode() requires a datatype repository which
181 // will be automatically build if requested???
182 Reference< css::xforms::XModel > xModel( m_pXFormsPage->GetXFormsHelper(), UNO_QUERY );
183 Reference< css::xforms::XDataTypeRepository > xDataTypes =
184 xModel->getDataTypeRepository();
185 if(!xDataTypes.is())
186 return;
187
188 ItemNode *pItemNode = static_cast<ItemNode*>(pSelected->GetUserData());
189
190 if ( !pItemNode )
191 {
192 // the only known (and allowed?) case where this happens are sub-entries of a submission
193 // entry
194 DBG_ASSERT( DGTSubmission == m_eGroup, "DataTreeListBox::StartDrag: how this?" );
195 pSelected = GetParent( pSelected );
196 DBG_ASSERT( pSelected && !GetParent( pSelected ), "DataTreeListBox::StartDrag: what kind of entry *is* this?" );
197 // on the submission page, we have only top-level entries (the submission themself)
198 // plus direct children of those (facets of a submission)
199 pItemNode = pSelected ? static_cast< ItemNode* >( pSelected->GetUserData() ) : nullptr;
200 if ( !pItemNode )
201 return;
202 }
203
204 OXFormsDescriptor desc;
205 desc.szName = GetEntryText(pSelected);
206 if(pItemNode->m_xNode.is()) {
207 // a valid node interface tells us that we need to create a control from a binding
208 desc.szServiceName = m_pXFormsPage->GetServiceNameForNode(pItemNode->m_xNode);
209 desc.xPropSet = m_pXFormsPage->GetBindingForNode(pItemNode->m_xNode);
210 DBG_ASSERT( desc.xPropSet.is(), "DataTreeListBox::StartDrag(): invalid node binding" );
211 }
212 else {
213 desc.szServiceName = FM_COMPONENT_COMMANDBUTTON;
214 desc.xPropSet = pItemNode->m_xPropSet;
215 }
216 rtl::Reference<OXFormsTransferable> pTransferable = new OXFormsTransferable(desc);
217 EndSelection();
218 pTransferable->StartDrag( this, DND_ACTION_COPY );
219 }
220
221 VclPtr<PopupMenu> DataTreeListBox::CreateContextMenu()
222 {
223 m_xMenu.disposeAndClear();
224 m_xBuilder.reset(new VclBuilder(nullptr, VclBuilderContainer::getUIRootDir(), "svx/ui/formdatamenu.ui", ""));
225 m_xMenu.set(m_xBuilder->get_menu("menu"));
226
227 if ( DGTInstance == m_eGroup )
228 m_xMenu->RemoveItem(m_xMenu->GetItemPos(m_xMenu->GetItemId("additem")));
229 else
230 {
231 m_xMenu->RemoveItem(m_xMenu->GetItemPos(m_xMenu->GetItemId("addelement")));
232 m_xMenu->RemoveItem(m_xMenu->GetItemPos(m_xMenu->GetItemId("addattribute")));
233
234 if ( DGTSubmission == m_eGroup )
235 {
236 m_xMenu->SetItemText(m_xMenu->GetItemId("additem"), SvxResId(RID_STR_DATANAV_ADD_SUBMISSION));
237 m_xMenu->SetItemText(m_xMenu->GetItemId("edit"), SvxResId(RID_STR_DATANAV_EDIT_SUBMISSION));
238 m_xMenu->SetItemText(m_xMenu->GetItemId("delete"), SvxResId(RID_STR_DATANAV_REMOVE_SUBMISSION));
239 }
240 else
241 {
242 m_xMenu->SetItemText(m_xMenu->GetItemId("additem"), SvxResId(RID_STR_DATANAV_ADD_BINDING));
243 m_xMenu->SetItemText(m_xMenu->GetItemId("edit"), SvxResId(RID_STR_DATANAV_EDIT_BINDING));
244 m_xMenu->SetItemText(m_xMenu->GetItemId("delete"), SvxResId(RID_STR_DATANAV_REMOVE_BINDING));
245 }
246 }
247 m_pXFormsPage->EnableMenuItems(m_xMenu.get());
248 return m_xMenu;
249 }
250
251 void DataTreeListBox::ExecuteContextMenuAction( sal_uInt16 _nSelectedPopupEntry )
252 {
253 if (m_xMenu->GetItemId("additem") == _nSelectedPopupEntry)
254 m_pXFormsPage->DoMenuAction(m_nAddId);
255 else if (m_xMenu->GetItemId("addelement") == _nSelectedPopupEntry)
256 m_pXFormsPage->DoMenuAction(m_nAddElementId);
257 else if (m_xMenu->GetItemId("addattribute") == _nSelectedPopupEntry)
258 m_pXFormsPage->DoMenuAction(m_nAddAttributeId);
259 else if (m_xMenu->GetItemId("edit") == _nSelectedPopupEntry)
260 m_pXFormsPage->DoMenuAction(m_nEditId);
261 else if (m_xMenu->GetItemId("delete") == _nSelectedPopupEntry)
262 m_pXFormsPage->DoMenuAction(m_nRemoveId);
263 }
264
265 void DataTreeListBox::RemoveEntry( SvTreeListEntry const * _pEntry )
266 {
267 if ( _pEntry )
268 {
269 delete static_cast< ItemNode* >( _pEntry->GetUserData() );
270 SvTreeListBox::GetModel()->Remove( _pEntry );
271 }
272 }
273
274 void DataTreeListBox::SetGroup(DataGroupType _eGroup)
275 {
276 m_eGroup = _eGroup;
277 }
278
279 void DataTreeListBox::SetXFormsPage(XFormsPage* _pPage)
280 {
281 m_pXFormsPage = _pPage;
282 }
283
284 void DataTreeListBox::SetToolBoxItemIds(sal_uInt16 _nAddId,
285 sal_uInt16 _nAddElementId,
286 sal_uInt16 _nAddAttributeId,
287 sal_uInt16 _nEditId,
288 sal_uInt16 _nRemoveId)
289 {
290 m_nAddId = _nAddId;
291 m_nAddElementId = _nAddElementId;
292 m_nAddAttributeId = _nAddAttributeId;
293 m_nEditId = _nEditId;
294 m_nRemoveId = _nRemoveId;
295 }
296
297 void DataTreeListBox::DeleteAndClear()
298 {
299 sal_uIntPtr i, nCount = GetEntryCount();
300 for ( i = 0; i < nCount; ++i )
301 {
302 SvTreeListEntry* pEntry = GetEntry(i);
303 if ( pEntry )
304 delete static_cast< ItemNode* >( pEntry->GetUserData() );
305 }
306
307 Clear();
308 }
309
310
311 // class XFormsPage
312
313 VCL_BUILDER_FACTORY_ARGS(DataTreeListBox, WB_BORDER)
314
315 XFormsPage::XFormsPage( vcl::Window* pParent, DataNavigatorWindow* _pNaviWin, DataGroupType _eGroup ) :
316
317 TabPage( pParent, "XFormsPage", "svx/ui/xformspage.ui" ),
318 m_pNaviWin ( _pNaviWin ),
319 m_bHasModel ( false ),
320 m_eGroup ( _eGroup ),
321 m_bLinkOnce ( false )
322
323 {
324 get(m_pToolBox, "toolbar");
325 get(m_pItemList, "items");
326 Size aSize(LogicToPixel(Size(63, 100), MapMode(MapUnit::MapAppFont)));
327 m_pItemList->set_width_request(aSize.Width());
328 m_pItemList->set_height_request(aSize.Height());
329
330 m_pItemList->SetGroup(_eGroup);
331 m_pItemList->SetXFormsPage( this );
332
333 m_nAddId = m_pToolBox->GetItemId("TBI_ITEM_ADD");
334 m_nAddElementId = m_pToolBox->GetItemId("TBI_ITEM_ADD_ELEMENT");
335 m_nAddAttributeId = m_pToolBox->GetItemId("TBI_ITEM_ADD_ATTRIBUTE");
336 m_nEditId = m_pToolBox->GetItemId("TBI_ITEM_EDIT");
337 m_nRemoveId = m_pToolBox->GetItemId("TBI_ITEM_REMOVE");
338
339 m_pItemList->SetToolBoxItemIds(m_nAddId, m_nAddElementId, m_nAddAttributeId, m_nEditId, m_nRemoveId);
340
341 m_pToolBox->InsertSeparator(4,5);
342 m_pToolBox->SetItemImage(m_nAddId, Image(StockImage::Yes, RID_SVXBMP_ADD));
343 m_pToolBox->SetItemImage(m_nAddElementId, Image(StockImage::Yes, RID_SVXBMP_ADD_ELEMENT));
344 m_pToolBox->SetItemImage(m_nAddAttributeId, Image(StockImage::Yes, RID_SVXBMP_ADD_ATTRIBUTE));
345 m_pToolBox->SetItemImage(m_nEditId, Image(StockImage::Yes, RID_SVXBMP_EDIT));
346 m_pToolBox->SetItemImage(m_nRemoveId, Image(StockImage::Yes, RID_SVXBMP_REMOVE));
347
348 if ( DGTInstance == m_eGroup )
349 m_pToolBox->RemoveItem( m_pToolBox->GetItemPos( m_nAddId ) );
350 else
351 {
352 m_pToolBox->RemoveItem( m_pToolBox->GetItemPos( m_nAddElementId ) );
353 m_pToolBox->RemoveItem( m_pToolBox->GetItemPos( m_nAddAttributeId ) );
354
355 if ( DGTSubmission == m_eGroup )
356 {
357 m_pToolBox->SetItemText( m_nAddId, SvxResId( RID_STR_DATANAV_ADD_SUBMISSION ) );
358 m_pToolBox->SetItemText( m_nEditId, SvxResId( RID_STR_DATANAV_EDIT_SUBMISSION ) );
359 m_pToolBox->SetItemText( m_nRemoveId, SvxResId( RID_STR_DATANAV_REMOVE_SUBMISSION ) );
360 }
361 else
362 {
363 m_pToolBox->SetItemText( m_nAddId, SvxResId( RID_STR_DATANAV_ADD_BINDING ) );
364 m_pToolBox->SetItemText( m_nEditId, SvxResId( RID_STR_DATANAV_EDIT_BINDING ) );
365 m_pToolBox->SetItemText( m_nRemoveId, SvxResId( RID_STR_DATANAV_REMOVE_BINDING ) );
366 }
367 }
368
369 const Size aTbxSz( m_pToolBox->CalcWindowSizePixel() );
370 m_pToolBox->SetSizePixel( aTbxSz );
371 m_pToolBox->SetOutStyle( SvtMiscOptions().GetToolboxStyle() );
372 m_pToolBox->SetSelectHdl( LINK( this, XFormsPage, TbxSelectHdl ) );
373 Point aPos = m_pItemList->GetPosPixel();
374 aPos.setY( aTbxSz.Height() );
375 m_pItemList->SetPosPixel( aPos );
376
377 m_pItemList->SetSelectHdl( LINK( this, XFormsPage, ItemSelectHdl ) );
378 m_pItemList->SetNodeDefaultImages();
379 WinBits nBits = WB_BORDER | WB_TABSTOP | WB_HIDESELECTION | WB_NOINITIALSELECTION;
380 if ( DGTInstance == m_eGroup || DGTSubmission == m_eGroup )
381 nBits |= WB_HASBUTTONS | WB_HASLINES | WB_HASLINESATROOT | WB_HASBUTTONSATROOT;
382 m_pItemList->SetStyle( m_pItemList->GetStyle() | nBits );
383 m_pItemList->Show();
384 ItemSelectHdl( m_pItemList );
385 }
386
387 XFormsPage::~XFormsPage()
388 {
389 disposeOnce();
390 }
391
392 void XFormsPage::dispose()
393 {
394 m_pToolBox.clear();
395 m_pItemList.clear();
396 m_pNaviWin.clear();
397 TabPage::dispose();
398 }
399
400 IMPL_LINK_NOARG(XFormsPage, TbxSelectHdl, ToolBox *, void)
401 {
402 DoToolBoxAction( m_pToolBox->GetCurItemId() );
403 }
404
405 IMPL_LINK_NOARG(XFormsPage, ItemSelectHdl, SvTreeListBox*, void)
406 {
407 EnableMenuItems( nullptr );
408 }
409
410 void XFormsPage::AddChildren(SvTreeListEntry* _pParent,
411 const Reference< css::xml::dom::XNode >& _xNode)
412 {
413 DBG_ASSERT( m_xUIHelper.is(), "XFormsPage::AddChildren(): invalid UIHelper" );
414
415 try
416 {
417 Reference< css::xml::dom::XNodeList > xNodeList = _xNode->getChildNodes();
418 if ( xNodeList.is() )
419 {
420 bool bShowDetails = m_pNaviWin->IsShowDetails();
421 sal_Int32 i, nNodeCount = xNodeList->getLength();
422 for ( i = 0; i < nNodeCount; ++i )
423 {
424 Reference< css::xml::dom::XNode > xChild = xNodeList->item(i);
425 css::xml::dom::NodeType eChildType = xChild->getNodeType();
426 Image aExpImg, aCollImg;
427 switch ( eChildType )
428 {
429 case css::xml::dom::NodeType_ATTRIBUTE_NODE:
430 aExpImg = aCollImg = Image(StockImage::Yes, RID_SVXBMP_ATTRIBUTE);
431 break;
432 case css::xml::dom::NodeType_ELEMENT_NODE:
433 aExpImg = aCollImg = Image(StockImage::Yes, RID_SVXBMP_ELEMENT);
434 break;
435 case css::xml::dom::NodeType_TEXT_NODE:
436 aExpImg = aCollImg = Image(StockImage::Yes, RID_SVXBMP_TEXT);
437 break;
438 default:
439 aExpImg = aCollImg = Image(StockImage::Yes, RID_SVXBMP_OTHER);
440 }
441
442 OUString sName = m_xUIHelper->getNodeDisplayName( xChild, bShowDetails );
443 if ( !sName.isEmpty() )
444 {
445 ItemNode* pNode = new ItemNode( xChild );
446 SvTreeListEntry* pEntry = m_pItemList->InsertEntry(
447 sName, aExpImg, aCollImg, _pParent, false, TREELIST_APPEND, pNode );
448 if ( xChild->hasAttributes() )
449 {
450 Reference< css::xml::dom::XNamedNodeMap > xMap = xChild->getAttributes();
451 if ( xMap.is() )
452 {
453 aExpImg = aCollImg = Image(StockImage::Yes, RID_SVXBMP_ATTRIBUTE);
454 sal_Int32 j, nMapLen = xMap->getLength();
455 for ( j = 0; j < nMapLen; ++j )
456 {
457 Reference< css::xml::dom::XNode > xAttr = xMap->item(j);
458 pNode = new ItemNode( xAttr );
459 OUString sAttrName =
460 m_xUIHelper->getNodeDisplayName( xAttr, bShowDetails );
461 m_pItemList->InsertEntry(
462 sAttrName, aExpImg, aCollImg,
463 pEntry, false, TREELIST_APPEND, pNode );
464 }
465 }
466 }
467 if ( xChild->hasChildNodes() )
468 AddChildren(pEntry, xChild);
469 }
470 }
471 }
472 }
473 catch( Exception& )
474 {
475 DBG_UNHANDLED_EXCEPTION("svx");
476 }
477 }
478
479 bool XFormsPage::DoToolBoxAction( sal_uInt16 _nToolBoxID ) {
480
481 bool bHandled = false;
482 bool bIsDocModified = false;
483 m_pNaviWin->DisableNotify( true );
484
485 if(_nToolBoxID == m_nAddId || _nToolBoxID == m_nAddElementId || _nToolBoxID == m_nAddAttributeId)
486 {
487 bHandled = true;
488 Reference< css::xforms::XModel > xModel( m_xUIHelper, UNO_QUERY );
489 DBG_ASSERT( xModel.is(), "XFormsPage::DoToolBoxAction(): Action without model" );
490 if ( DGTSubmission == m_eGroup )
491 {
492 AddSubmissionDialog aDlg(GetFrameWeld(), nullptr, m_xUIHelper);
493 if ( aDlg.run() == RET_OK && aDlg.GetNewSubmission().is() )
494 {
495 try
496 {
497 Reference< css::xforms::XSubmission > xNewSubmission = aDlg.GetNewSubmission();
498 Reference< XSet > xSubmissions = xModel->getSubmissions();
499 xSubmissions->insert( makeAny( xNewSubmission ) );
500 SvTreeListEntry* pEntry = AddEntry( xNewSubmission );
501 m_pItemList->Select( pEntry );
502 bIsDocModified = true;
503 }
504 catch ( Exception const & )
505 {
506 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolBoxAction()" );
507 }
508 }
509 }
510 else
511 {
512 DataItemType eType = DITElement;
513 SvTreeListEntry* pEntry = m_pItemList->FirstSelected();
514 std::unique_ptr<ItemNode> pNode;
515 Reference< css::xml::dom::XNode > xParentNode;
516 Reference< XPropertySet > xNewBinding;
517 const char* pResId = nullptr;
518 bool bIsElement = true;
519 if ( DGTInstance == m_eGroup )
520 {
521 if ( !m_sInstanceURL.isEmpty() )
522 {
523 LinkedInstanceWarningBox aMsgBox(GetFrameWeld());
524 if (aMsgBox.run() != RET_OK)
525 return bHandled;
526 }
527
528 DBG_ASSERT( pEntry, "XFormsPage::DoToolBoxAction(): no entry" );
529 ItemNode* pParentNode = static_cast< ItemNode* >( pEntry->GetUserData() );
530 DBG_ASSERT( pParentNode, "XFormsPage::DoToolBoxAction(): no parent node" );
531 xParentNode = pParentNode->m_xNode;
532 Reference< css::xml::dom::XNode > xNewNode;
533 if ( m_nAddElementId == _nToolBoxID )
534 {
535 try
536 {
537 pResId = RID_STR_DATANAV_ADD_ELEMENT;
538 xNewNode = m_xUIHelper->createElement( xParentNode, NEW_ELEMENT );
539 }
540 catch ( Exception const & )
541 {
542 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolBoxAction(): exception while create element" );
543 }
544 }
545 else
546 {
547 pResId = RID_STR_DATANAV_ADD_ATTRIBUTE;
548 bIsElement = false;
549 eType = DITAttribute;
550 try
551 {
552 xNewNode = m_xUIHelper->createAttribute( xParentNode, NEW_ATTRIBUTE );
553 }
554 catch ( Exception const & )
555 {
556 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolBoxAction(): exception while create attribute" );
557 }
558 }
559
560 try
561 {
562 xNewNode = xParentNode->appendChild( xNewNode );
563 }
564 catch ( Exception const & )
565 {
566 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolBoxAction(): exception while append child" );
567 }
568
569 try
570 {
571 Reference< css::xml::dom::XNode > xPNode;
572 if ( xNewNode.is() )
573 xPNode = xNewNode->getParentNode();
574 // attributes don't have parents in the DOM model
575 DBG_ASSERT( m_nAddAttributeId == _nToolBoxID
576 || xPNode.is(), "XFormsPage::DoToolboxAction(): node not added" );
577 }
578 catch ( Exception const & )
579 {
580 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolboxAction()" );
581 }
582
583 try
584 {
585 m_xUIHelper->getBindingForNode( xNewNode, true );
586 }
587 catch ( Exception const & )
588 {
589 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolBoxAction(): exception while get binding for node" );
590 }
591 pNode.reset(new ItemNode( xNewNode ));
592 }
593 else
594 {
595 try
596 {
597 pResId = RID_STR_DATANAV_ADD_BINDING;
598 xNewBinding = xModel->createBinding();
599 Reference< XSet > xBindings = xModel->getBindings();
600 xBindings->insert( makeAny( xNewBinding ) );
601 pNode.reset(new ItemNode( xNewBinding ));
602 eType = DITBinding;
603 }
604 catch ( Exception const & )
605 {
606 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolBoxAction(): exception while adding binding" );
607 }
608 }
609
610 AddDataItemDialog aDlg(GetFrameWeld(), pNode.get(), m_xUIHelper);
611 aDlg.set_title(SvxResId(pResId));
612 aDlg.InitText( eType );
613 short nReturn = aDlg.run();
614 if ( DGTInstance == m_eGroup )
615 {
616 if ( RET_OK == nReturn )
617 {
618 SvTreeListEntry* pNewEntry = AddEntry( std::move(pNode), bIsElement );
619 m_pItemList->MakeVisible( pNewEntry );
620 m_pItemList->Select( pNewEntry );
621 bIsDocModified = true;
622 }
623 else
624 {
625 try
626 {
627 Reference< css::xml::dom::XNode > xPNode;
628 Reference< css::xml::dom::XNode > xNode =
629 xParentNode->removeChild( pNode->m_xNode );
630 if ( xNode.is() )
631 xPNode = xNode->getParentNode();
632 DBG_ASSERT( !xPNode.is(), "XFormsPage::RemoveEntry(): node not removed" );
633 }
634 catch ( Exception const & )
635 {
636 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolboxAction()" );
637 }
638 }
639 }
640 else
641 {
642 if ( RET_OK == nReturn )
643 {
644 SvTreeListEntry* pNewEntry = AddEntry( xNewBinding );
645 m_pItemList->Select( pNewEntry );
646 bIsDocModified = true;
647 }
648 else
649 {
650 try
651 {
652 Reference< XSet > xBindings = xModel->getBindings();
653 xBindings->remove( makeAny( xNewBinding ) );
654 }
655 catch ( Exception const & )
656 {
657 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolboxAction()" );
658 }
659 }
660 }
661 }
662 }
663 else if(_nToolBoxID == m_nEditId)
664 {
665 bHandled = true;
666 SvTreeListEntry* pEntry = m_pItemList->FirstSelected();
667 if ( pEntry )
668 {
669 if ( DGTSubmission == m_eGroup && m_pItemList->GetParent( pEntry ) )
670 pEntry = m_pItemList->GetParent( pEntry );
671 ItemNode* pNode = static_cast< ItemNode* >( pEntry->GetUserData() );
672 if ( DGTInstance == m_eGroup || DGTBinding == m_eGroup )
673 {
674 if ( DGTInstance == m_eGroup && !m_sInstanceURL.isEmpty() )
675 {
676 LinkedInstanceWarningBox aMsgBox(GetFrameWeld());
677 if (aMsgBox.run() != RET_OK)
678 return bHandled;
679 }
680
681 AddDataItemDialog aDlg(GetFrameWeld(), pNode, m_xUIHelper);
682 DataItemType eType = DITElement;
683 const char* pResId = RID_STR_DATANAV_EDIT_ELEMENT;
684 if ( pNode && pNode->m_xNode.is() )
685 {
686 try
687 {
688 css::xml::dom::NodeType eChildType = pNode->m_xNode->getNodeType();
689 if ( eChildType == css::xml::dom::NodeType_ATTRIBUTE_NODE )
690 {
691 pResId = RID_STR_DATANAV_EDIT_ATTRIBUTE;
692 eType = DITAttribute;
693 }
694 }
695 catch ( Exception const & )
696 {
697 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolboxAction()" );
698 }
699 }
700 else if ( DGTBinding == m_eGroup )
701 {
702 pResId = RID_STR_DATANAV_EDIT_BINDING;
703 eType = DITBinding;
704 }
705 aDlg.set_title(SvxResId(pResId));
706 aDlg.InitText( eType );
707 if (aDlg.run() == RET_OK)
708 {
709 // Set the new name
710 OUString sNewName;
711 if ( DGTInstance == m_eGroup )
712 {
713 try
714 {
715 sNewName = m_xUIHelper->getNodeDisplayName(
716 pNode->m_xNode, m_pNaviWin->IsShowDetails() );
717 }
718 catch ( Exception const & )
719 {
720 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolboxAction()" );
721 }
722 }
723 else if (pNode)
724 {
725 try
726 {
727 OUString sTemp;
728 pNode->m_xPropSet->getPropertyValue( PN_BINDING_ID ) >>= sTemp;
729 sNewName += sTemp + ": ";
730 pNode->m_xPropSet->getPropertyValue( PN_BINDING_EXPR ) >>= sTemp;
731 sNewName += sTemp;
732 }
733 catch ( Exception const & )
734 {
735 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::DoToolboxAction()" );
736 }
737 }
738
739 m_pItemList->SetEntryText( pEntry, sNewName );
740 bIsDocModified = true;
741 }
742 }
743 else
744 {
745 AddSubmissionDialog aDlg(GetFrameWeld(), pNode, m_xUIHelper);
746 aDlg.set_title(SvxResId(RID_STR_DATANAV_EDIT_SUBMISSION));
747 if (aDlg.run() == RET_OK)
748 {
749 EditEntry( pNode->m_xPropSet );
750 bIsDocModified = true;
751 }
752 }
753 }
754 }
755 else if(_nToolBoxID == m_nRemoveId)
756 {
757 bHandled = true;
758 if ( DGTInstance == m_eGroup && !m_sInstanceURL.isEmpty() )
759 {
760 LinkedInstanceWarningBox aMsgBox(GetFrameWeld());
761 if (aMsgBox.run() != RET_OK)
762 return bHandled;
763 }
764 bIsDocModified = RemoveEntry();
765 }
766 else
767 {
768 OSL_FAIL( "XFormsPage::DoToolboxAction: unknown ID!" );
769 }
770
771 m_pNaviWin->DisableNotify( false );
772 EnableMenuItems( nullptr );
773 if ( bIsDocModified )
774 svxform::DataNavigatorWindow::SetDocModified();
775 return bHandled;
776 }
777
778 SvTreeListEntry* XFormsPage::AddEntry( std::unique_ptr<ItemNode> _pNewNode, bool _bIsElement )
779 {
780 SvTreeListEntry* pParent = m_pItemList->FirstSelected();
781 Image aImage(StockImage::Yes, _bIsElement ? OUString(RID_SVXBMP_ELEMENT) : OUString(RID_SVXBMP_ATTRIBUTE));
782 OUString sName;
783 try
784 {
785 sName = m_xUIHelper->getNodeDisplayName(
786 _pNewNode->m_xNode, m_pNaviWin->IsShowDetails() );
787 }
788 catch ( Exception& )
789 {
790 DBG_UNHANDLED_EXCEPTION("svx");
791 }
792 return m_pItemList->InsertEntry(
793 sName, aImage, aImage, pParent, false, TREELIST_APPEND, _pNewNode.release() );
794 }
795
796 SvTreeListEntry* XFormsPage::AddEntry( const Reference< XPropertySet >& _rEntry )
797 {
798 SvTreeListEntry* pEntry = nullptr;
799 Image aImage(StockImage::Yes, RID_SVXBMP_ELEMENT);
800
801 ItemNode* pNode = new ItemNode( _rEntry );
802 OUString sTemp;
803
804 if ( DGTSubmission == m_eGroup )
805 {
806 try
807 {
808 // ID
809 _rEntry->getPropertyValue( PN_SUBMISSION_ID ) >>= sTemp;
810 pEntry = m_pItemList->InsertEntry( sTemp, aImage, aImage, nullptr, false, TREELIST_APPEND, pNode );
811 // Action
812 _rEntry->getPropertyValue( PN_SUBMISSION_ACTION ) >>= sTemp;
813 OUString sEntry = SvxResId( RID_STR_DATANAV_SUBM_ACTION ) + sTemp;
814 m_pItemList->InsertEntry( sEntry, aImage, aImage, pEntry );
815 // Method
816 _rEntry->getPropertyValue( PN_SUBMISSION_METHOD ) >>= sTemp;
817 sEntry = SvxResId( RID_STR_DATANAV_SUBM_METHOD ) +
818 m_aMethodString.toUI( sTemp );
819 m_pItemList->InsertEntry( sEntry, aImage, aImage, pEntry );
820 // Ref
821 _rEntry->getPropertyValue( PN_SUBMISSION_REF ) >>= sTemp;
822 sEntry = SvxResId( RID_STR_DATANAV_SUBM_REF ) + sTemp;
823 m_pItemList->InsertEntry( sEntry, aImage, aImage, pEntry );
824 // Bind
825 _rEntry->getPropertyValue( PN_SUBMISSION_BIND ) >>= sTemp;
826 sEntry = SvxResId( RID_STR_DATANAV_SUBM_BIND ) + sTemp;
827 m_pItemList->InsertEntry( sEntry, aImage, aImage, pEntry );
828 // Replace
829 _rEntry->getPropertyValue( PN_SUBMISSION_REPLACE ) >>= sTemp;
830 sEntry = SvxResId( RID_STR_DATANAV_SUBM_REPLACE ) +
831 m_aReplaceString.toUI( sTemp );
832 m_pItemList->InsertEntry( sEntry, aImage, aImage, pEntry );
833 }
834 catch ( Exception const & )
835 {
836 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::AddEntry(Ref)" );
837 }
838 }
839 else // then Binding Page
840 {
841 try
842 {
843 OUString sName;
844 _rEntry->getPropertyValue( PN_BINDING_ID ) >>= sTemp;
845 sName += sTemp + ": ";
846 _rEntry->getPropertyValue( PN_BINDING_EXPR ) >>= sTemp;
847 sName += sTemp;
848 pEntry = m_pItemList->InsertEntry(
849 sName, aImage, aImage, nullptr, false, TREELIST_APPEND, pNode );
850 }
851 catch ( Exception const & )
852 {
853 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::AddEntry(Ref)" );
854 }
855 }
856
857 return pEntry;
858 }
859
860
861 void XFormsPage::EditEntry( const Reference< XPropertySet >& _rEntry )
862 {
863 OUString sTemp;
864
865 if ( DGTSubmission == m_eGroup )
866 {
867 try
868 {
869 SvTreeListEntry* pEntry = m_pItemList->FirstSelected();
870
871 // #i36262# may be called for submission entry *or* for
872 // submission children. If we don't have any children, we
873 // assume the latter case and use the parent
874 if( m_pItemList->GetEntry( pEntry, 0 ) == nullptr )
875 {
876 pEntry = m_pItemList->GetModel()->GetParent( pEntry );
877 }
878
879 _rEntry->getPropertyValue( PN_SUBMISSION_ID ) >>= sTemp;
880 m_pItemList->SetEntryText( pEntry, sTemp );
881
882 _rEntry->getPropertyValue( PN_SUBMISSION_BIND ) >>= sTemp;
883 OUString sEntry = SvxResId( RID_STR_DATANAV_SUBM_BIND ) + sTemp;
884 sal_uIntPtr nPos = 0;
885 SvTreeListEntry* pChild = m_pItemList->GetEntry( pEntry, nPos++ );
886 m_pItemList->SetEntryText( pChild, sEntry );
887 _rEntry->getPropertyValue( PN_SUBMISSION_REF ) >>= sTemp;
888 sEntry = SvxResId( RID_STR_DATANAV_SUBM_REF ) + sTemp;
889 pChild = m_pItemList->GetEntry( pEntry, nPos++ );
890 m_pItemList->SetEntryText( pChild, sEntry );
891 _rEntry->getPropertyValue( PN_SUBMISSION_ACTION ) >>= sTemp;
892 sEntry = SvxResId( RID_STR_DATANAV_SUBM_ACTION ) + sTemp;
893 pChild = m_pItemList->GetEntry( pEntry, nPos++ );
894 m_pItemList->SetEntryText( pChild, sEntry );
895 _rEntry->getPropertyValue( PN_SUBMISSION_METHOD ) >>= sTemp;
896 sEntry = SvxResId( RID_STR_DATANAV_SUBM_METHOD ) +
897 m_aMethodString.toUI( sTemp );
898 pChild = m_pItemList->GetEntry( pEntry, nPos++ );
899 m_pItemList->SetEntryText( pChild, sEntry );
900 _rEntry->getPropertyValue( PN_SUBMISSION_REPLACE ) >>= sTemp;
901 sEntry = SvxResId( RID_STR_DATANAV_SUBM_REPLACE ) +
902 m_aReplaceString.toUI( sTemp );
903 pChild = m_pItemList->GetEntry( pEntry, nPos++ );
904 m_pItemList->SetEntryText( pChild, sEntry );
905 }
906 catch ( Exception const & )
907 {
908 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::EditEntry()" );
909 }
910 }
911 }
912
913
914 bool XFormsPage::RemoveEntry()
915 {
916 bool bRet = false;
917 SvTreeListEntry* pEntry = m_pItemList->FirstSelected();
918 if ( pEntry &&
919 ( DGTInstance != m_eGroup || m_pItemList->GetParent( pEntry ) ) )
920 {
921 Reference< css::xforms::XModel > xModel( m_xUIHelper, UNO_QUERY );
922 DBG_ASSERT( xModel.is(), "XFormsPage::RemoveEntry(): no model" );
923 ItemNode* pNode = static_cast< ItemNode* >( pEntry->GetUserData() );
924 DBG_ASSERT( pNode, "XFormsPage::RemoveEntry(): no node" );
925
926 if ( DGTInstance == m_eGroup )
927 {
928 try
929 {
930 DBG_ASSERT( pNode->m_xNode.is(), "XFormsPage::RemoveEntry(): no XNode" );
931 css::xml::dom::NodeType eChildType = pNode->m_xNode->getNodeType();
932 bool bIsElement = ( eChildType == css::xml::dom::NodeType_ELEMENT_NODE );
933 const char* pResId = bIsElement ? RID_STR_QRY_REMOVE_ELEMENT : RID_STR_QRY_REMOVE_ATTRIBUTE;
934 OUString sVar = bIsElement ? OUString(ELEMENTNAME) : OUString(ATTRIBUTENAME);
935 std::unique_ptr<weld::MessageDialog> xQBox(Application::CreateMessageDialog(GetFrameWeld(),
936 VclMessageType::Question, VclButtonsType::YesNo,
937 SvxResId(pResId)));
938 OUString sMessText = xQBox->get_primary_text();
939 sMessText = sMessText.replaceFirst(
940 sVar, m_xUIHelper->getNodeDisplayName( pNode->m_xNode, false ) );
941 xQBox->set_primary_text(sMessText);
942 if (xQBox->run() == RET_YES)
943 {
944 SvTreeListEntry* pParent = m_pItemList->GetParent( pEntry );
945 DBG_ASSERT( pParent, "XFormsPage::RemoveEntry(): no parent entry" );
946 ItemNode* pParentNode = static_cast< ItemNode* >( pParent->GetUserData() );
947 DBG_ASSERT( pParentNode && pParentNode->m_xNode.is(), "XFormsPage::RemoveEntry(): no parent XNode" );
948
949 Reference< css::xml::dom::XNode > xPNode;
950 Reference< css::xml::dom::XNode > xNode =
951 pParentNode->m_xNode->removeChild( pNode->m_xNode );
952 if ( xNode.is() )
953 xPNode = xNode->getParentNode();
954 DBG_ASSERT( !xPNode.is(), "XFormsPage::RemoveEntry(): node not removed" );
955 bRet = true;
956 }
957 }
958 catch ( Exception const & )
959 {
960 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::RemoveEntry()" );
961 }
962 }
963 else
964 {
965 DBG_ASSERT( pNode->m_xPropSet.is(), "XFormsPage::RemoveEntry(): no propset" );
966 bool bSubmission = ( DGTSubmission == m_eGroup );
967 const char* pResId = bSubmission ? RID_STR_QRY_REMOVE_SUBMISSION : RID_STR_QRY_REMOVE_BINDING;
968 OUString sProperty = bSubmission ? OUString(PN_SUBMISSION_ID) : OUString(PN_BINDING_ID);
969 OUString sSearch = bSubmission ? OUString(SUBMISSIONNAME) : OUString(BINDINGNAME);
970 OUString sName;
971 try
972 {
973 pNode->m_xPropSet->getPropertyValue( sProperty ) >>= sName;
974 }
975 catch ( Exception const & )
976 {
977 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::RemoveEntry()" );
978 }
979 std::unique_ptr<weld::MessageDialog> xQBox(Application::CreateMessageDialog(GetFrameWeld(),
980 VclMessageType::Question, VclButtonsType::YesNo,
981 SvxResId(pResId)));
982 OUString sMessText = xQBox->get_primary_text();
983 sMessText = sMessText.replaceFirst( sSearch, sName);
984 xQBox->set_primary_text(sMessText);
985 if (xQBox->run() == RET_YES)
986 {
987 try
988 {
989 if ( bSubmission )
990 xModel->getSubmissions()->remove( makeAny( pNode->m_xPropSet ) );
991 else // then Binding Page
992 xModel->getBindings()->remove( makeAny( pNode->m_xPropSet ) );
993 bRet = true;
994 }
995 catch ( Exception const & )
996 {
997 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::RemoveEntry()" );
998 }
999 }
1000 }
1001
1002 if ( bRet )
1003 m_pItemList->RemoveEntry( pEntry );
1004 }
1005
1006 return bRet;
1007 }
1008
1009
1010 bool XFormsPage::EventNotify( NotifyEvent& rNEvt )
1011 {
1012 bool bHandled = false;
1013
1014 if ( rNEvt.GetType() == MouseNotifyEvent::KEYINPUT )
1015 {
1016 sal_uInt16 nCode = rNEvt.GetKeyEvent()->GetKeyCode().GetCode();
1017
1018 switch ( nCode )
1019 {
1020 case KEY_DELETE:
1021 bHandled = DoMenuAction( m_nRemoveId );
1022 break;
1023 }
1024 }
1025
1026 return bHandled || Window::EventNotify( rNEvt );
1027 }
1028
1029 void XFormsPage::Resize()
1030 {
1031 Size aSize = GetOutputSizePixel();
1032 Size aTbxSize = m_pToolBox->GetSizePixel();
1033 aTbxSize.setWidth( aSize.Width() );
1034 m_pToolBox->SetSizePixel( aTbxSize );
1035 aSize.AdjustWidth( -4 );
1036 aSize.AdjustHeight( -( 4 + aTbxSize.Height() ) );
1037 m_pItemList->SetPosSizePixel( Point( 2, 2 + aTbxSize.Height() ), aSize );
1038 }
1039
1040 OUString XFormsPage::SetModel( const Reference< css::xforms::XModel >& _xModel, sal_uInt16 _nPagePos )
1041 {
1042 DBG_ASSERT( _xModel.is(), "XFormsPage::SetModel(): invalid model" );
1043
1044 m_xUIHelper.set( _xModel, UNO_QUERY );
1045 OUString sRet;
1046 m_bHasModel = true;
1047
1048 switch ( m_eGroup )
1049 {
1050 case DGTInstance :
1051 {
1052 DBG_ASSERT( _nPagePos != TAB_PAGE_NOTFOUND, "XFormsPage::SetModel(): invalid page position" );
1053 try
1054 {
1055 Reference< XContainer > xContainer( _xModel->getInstances(), UNO_QUERY );
1056 if ( xContainer.is() )
1057 m_pNaviWin->AddContainerBroadcaster( xContainer );
1058
1059 Reference< XEnumerationAccess > xNumAccess = _xModel->getInstances();
1060 if ( xNumAccess.is() )
1061 {
1062 Reference < XEnumeration > xNum = xNumAccess->createEnumeration();
1063 if ( xNum.is() && xNum->hasMoreElements() )
1064 {
1065 sal_uInt16 nIter = 0;
1066 while ( xNum->hasMoreElements() )
1067 {
1068 if ( nIter == _nPagePos )
1069 {
1070 Sequence< PropertyValue > xPropSeq;
1071 Any aAny = xNum->nextElement();
1072 if ( aAny >>= xPropSeq )
1073 sRet = LoadInstance(xPropSeq);
1074 else
1075 {
1076 SAL_WARN( "svx.form", "XFormsPage::SetModel(): invalid instance" );
1077 }
1078 break;
1079 }
1080 else
1081 {
1082 xNum->nextElement();
1083 ++nIter;
1084 }
1085 }
1086 }
1087 }
1088 }
1089 catch( Exception const & )
1090 {
1091 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::SetModel()" );
1092 }
1093 break;
1094 }
1095
1096 case DGTSubmission :
1097 {
1098 DBG_ASSERT( TAB_PAGE_NOTFOUND == _nPagePos, "XFormsPage::SetModel(): invalid page position" );
1099 try
1100 {
1101 Reference< XContainer > xContainer( _xModel->getSubmissions(), UNO_QUERY );
1102 if ( xContainer.is() )
1103 m_pNaviWin->AddContainerBroadcaster( xContainer );
1104
1105 Reference< XEnumerationAccess > xNumAccess = _xModel->getSubmissions();
1106 if ( xNumAccess.is() )
1107 {
1108 Reference < XEnumeration > xNum = xNumAccess->createEnumeration();
1109 if ( xNum.is() && xNum->hasMoreElements() )
1110 {
1111 while ( xNum->hasMoreElements() )
1112 {
1113 Reference< XPropertySet > xPropSet;
1114 Any aAny = xNum->nextElement();
1115 if ( aAny >>= xPropSet )
1116 AddEntry( xPropSet );
1117 }
1118 }
1119 }
1120 }
1121 catch( Exception const & )
1122 {
1123 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::SetModel()" );
1124 }
1125 break;
1126 }
1127
1128 case DGTBinding :
1129 {
1130 DBG_ASSERT( TAB_PAGE_NOTFOUND == _nPagePos, "XFormsPage::SetModel(): invalid page position" );
1131 try
1132 {
1133 Reference< XContainer > xContainer( _xModel->getBindings(), UNO_QUERY );
1134 if ( xContainer.is() )
1135 m_pNaviWin->AddContainerBroadcaster( xContainer );
1136
1137 Reference< XEnumerationAccess > xNumAccess = _xModel->getBindings();
1138 if ( xNumAccess.is() )
1139 {
1140 Reference < XEnumeration > xNum = xNumAccess->createEnumeration();
1141 if ( xNum.is() && xNum->hasMoreElements() )
1142 {
1143 Image aImage(StockImage::Yes, RID_SVXBMP_ELEMENT);
1144 while ( xNum->hasMoreElements() )
1145 {
1146 Reference< XPropertySet > xPropSet;
1147 Any aAny = xNum->nextElement();
1148 if ( aAny >>= xPropSet )
1149 {
1150 OUString sEntry;
1151 OUString sTemp;
1152 xPropSet->getPropertyValue( PN_BINDING_ID ) >>= sTemp;
1153 sEntry += sTemp + ": ";
1154 xPropSet->getPropertyValue( PN_BINDING_EXPR ) >>= sTemp;
1155 sEntry += sTemp;
1156
1157 ItemNode* pNode = new ItemNode( xPropSet );
1158 m_pItemList->InsertEntry(
1159 sEntry, aImage, aImage, nullptr, false, TREELIST_APPEND, pNode );
1160 }
1161 }
1162 }
1163 }
1164 }
1165 catch( Exception const & )
1166 {
1167 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::SetModel()" );
1168 }
1169 break;
1170 }
1171 default:
1172 OSL_FAIL( "XFormsPage::SetModel: unknown group!" );
1173 break;
1174 }
1175
1176 EnableMenuItems( nullptr );
1177
1178 return sRet;
1179 }
1180
1181 void XFormsPage::ClearModel()
1182 {
1183 m_bHasModel = false;
1184 m_pItemList->DeleteAndClear();
1185 }
1186
1187 OUString XFormsPage::LoadInstance(const Sequence< PropertyValue >& _xPropSeq)
1188 {
1189 OUString sRet;
1190 OUString sTemp;
1191 OUString sInstModel = PN_INSTANCE_MODEL;
1192 OUString sInstName = PN_INSTANCE_ID;
1193 OUString sInstURL = PN_INSTANCE_URL;
1194 for ( const PropertyValue& rProp : _xPropSeq )
1195 {
1196 if ( sInstModel == rProp.Name )
1197 {
1198 Reference< css::xml::dom::XNode > xRoot;
1199 if ( rProp.Value >>= xRoot )
1200 {
1201 try
1202 {
1203 Reference< XEventTarget > xTarget( xRoot, UNO_QUERY );
1204 if ( xTarget.is() )
1205 m_pNaviWin->AddEventBroadcaster( xTarget );
1206
1207 OUString sNodeName =
1208 m_xUIHelper->getNodeDisplayName( xRoot, m_pNaviWin->IsShowDetails() );
1209 if ( sNodeName.isEmpty() )
1210 sNodeName = xRoot->getNodeName();
1211 if ( xRoot->hasChildNodes() )
1212 AddChildren(nullptr, xRoot);
1213 }
1214 catch ( Exception const & )
1215 {
1216 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::LoadInstance()" );
1217 }
1218 }
1219 }
1220 else if ( sInstName == rProp.Name && ( rProp.Value >>= sTemp ) )
1221 m_sInstanceName = sRet = sTemp;
1222 else if ( sInstURL == rProp.Name && ( rProp.Value >>= sTemp ) )
1223 m_sInstanceURL = sTemp;
1224 }
1225
1226 return sRet;
1227 }
1228
1229
1230 bool XFormsPage::DoMenuAction( sal_uInt16 _nMenuID )
1231 {
1232 return DoToolBoxAction( _nMenuID );
1233 }
1234
1235
1236 void XFormsPage::EnableMenuItems( Menu* _pMenu )
1237 {
1238 bool bEnableAdd = false;
1239 bool bEnableEdit = false;
1240 bool bEnableRemove = false;
1241
1242 SvTreeListEntry* pEntry = m_pItemList->FirstSelected();
1243 if ( pEntry )
1244 {
1245 bEnableAdd = true;
1246 bool bSubmitChild = false;
1247 if ( DGTSubmission == m_eGroup && m_pItemList->GetParent( pEntry ) )
1248 {
1249 pEntry = m_pItemList->GetParent( pEntry );
1250 bSubmitChild = true;
1251 }
1252 ItemNode* pNode = static_cast< ItemNode* >( pEntry->GetUserData() );
1253 if ( pNode && ( pNode->m_xNode.is() || pNode->m_xPropSet.is() ) )
1254 {
1255 bEnableEdit = true;
1256 bEnableRemove = !bSubmitChild;
1257 if ( DGTInstance == m_eGroup && !m_pItemList->GetParent( pEntry ) )
1258 bEnableRemove = false;
1259 if ( pNode->m_xNode.is() )
1260 {
1261 try
1262 {
1263 css::xml::dom::NodeType eChildType = pNode->m_xNode->getNodeType();
1264 if ( eChildType != css::xml::dom::NodeType_ELEMENT_NODE
1265 && eChildType != css::xml::dom::NodeType_DOCUMENT_NODE )
1266 {
1267 bEnableAdd = false;
1268 }
1269 }
1270 catch ( Exception const & )
1271 {
1272 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::EnableMenuItems()" );
1273 }
1274 }
1275 }
1276 }
1277 else if ( m_eGroup != DGTInstance )
1278 bEnableAdd = true;
1279
1280 m_pToolBox->EnableItem( m_nAddId, bEnableAdd );
1281 m_pToolBox->EnableItem( m_nAddElementId, bEnableAdd );
1282 m_pToolBox->EnableItem( m_nAddAttributeId, bEnableAdd );
1283 m_pToolBox->EnableItem( m_nEditId, bEnableEdit );
1284 m_pToolBox->EnableItem( m_nRemoveId, bEnableRemove );
1285
1286 if ( _pMenu )
1287 {
1288 _pMenu->EnableItem(_pMenu->GetItemId("additem"), bEnableAdd);
1289 _pMenu->EnableItem(_pMenu->GetItemId("addelement"), bEnableAdd);
1290 _pMenu->EnableItem(_pMenu->GetItemId("addattribute"), bEnableAdd);
1291 _pMenu->EnableItem(_pMenu->GetItemId("edit"), bEnableEdit);
1292 _pMenu->EnableItem(_pMenu->GetItemId("delete"), bEnableRemove);
1293 }
1294 if ( DGTInstance == m_eGroup )
1295 {
1296 const char* pResId1 = RID_STR_DATANAV_EDIT_ELEMENT;
1297 const char* pResId2 = RID_STR_DATANAV_REMOVE_ELEMENT;
1298 if ( pEntry )
1299 {
1300 ItemNode* pNode = static_cast< ItemNode* >( pEntry->GetUserData() );
1301 if ( pNode && pNode->m_xNode.is() )
1302 {
1303 try
1304 {
1305 css::xml::dom::NodeType eChildType = pNode->m_xNode->getNodeType();
1306 if ( eChildType == css::xml::dom::NodeType_ATTRIBUTE_NODE )
1307 {
1308 pResId1 = RID_STR_DATANAV_EDIT_ATTRIBUTE;
1309 pResId2 = RID_STR_DATANAV_REMOVE_ATTRIBUTE;
1310 }
1311 }
1312 catch ( Exception const & )
1313 {
1314 TOOLS_WARN_EXCEPTION( "svx.form", "XFormsPage::EnableMenuItems()" );
1315 }
1316 }
1317 }
1318 m_pToolBox->SetItemText( m_nEditId, SvxResId( pResId1 ) );
1319 m_pToolBox->SetItemText( m_nRemoveId, SvxResId( pResId2 ) );
1320 if ( _pMenu )
1321 {
1322 _pMenu->SetItemText(_pMenu->GetItemId("edit"), SvxResId( pResId1 ) );
1323 _pMenu->SetItemText(_pMenu->GetItemId("delete"), SvxResId( pResId2 ) );
1324 }
1325 }
1326 }
1327
1328 DataNavigatorWindow::DataNavigatorWindow(vcl::Window* pParent, SfxBindings const * pBindings)
1329 : Window(pParent)
1330 , m_pInstPage(nullptr)
1331 , m_pSubmissionPage(nullptr)
1332 , m_pBindingPage(nullptr)
1333 , m_nLastSelectedPos(LISTBOX_ENTRY_NOTFOUND)
1334 , m_bShowDetails(false)
1335 , m_bIsNotifyDisabled(false)
1336 , m_xDataListener(new DataListener(this))
1337 {
1338 m_pUIBuilder.reset(new VclBuilder(this, getUIRootDir(), "svx/ui/datanavigator.ui", "DataNavigator"));
1339 get(m_pModelsBox, "modelslist");
1340 get(m_pModelBtn, "modelsbutton");
1341 get(m_pTabCtrl, "tabcontrol");
1342 get(m_pInstanceBtn, "instances");
1343
1344 // handler
1345 m_pModelsBox->SetSelectHdl( LINK( this, DataNavigatorWindow, ModelSelectListBoxHdl ) );
1346 Link<MenuButton *, void> aLink1 = LINK( this, DataNavigatorWindow, MenuSelectHdl );
1347 m_pModelBtn->SetSelectHdl( aLink1 );
1348 m_pInstanceBtn->SetSelectHdl( aLink1 );
1349 Link<MenuButton*,void> aLink2 = LINK( this, DataNavigatorWindow, MenuActivateHdl );
1350 m_pModelBtn->SetActivateHdl( aLink2 );
1351 m_pInstanceBtn->SetActivateHdl( aLink2 );
1352 m_pTabCtrl->SetActivatePageHdl( LINK( this, DataNavigatorWindow, ActivatePageHdl ) );
1353 m_aUpdateTimer.SetTimeout( 2000 );
1354 m_aUpdateTimer.SetInvokeHandler( LINK( this, DataNavigatorWindow, UpdateHdl ) );
1355
1356 // init tabcontrol
1357 m_pTabCtrl->Show();
1358 OString sPageId("instance");
1359 SvtViewOptions aViewOpt( EViewType::TabDialog, CFGNAME_DATANAVIGATOR );
1360 if ( aViewOpt.Exists() )
1361 {
1362 sPageId = aViewOpt.GetPageID();
1363 aViewOpt.GetUserItem(CFGNAME_SHOWDETAILS) >>= m_bShowDetails;
1364 }
1365
1366 Menu* pMenu = m_pInstanceBtn->GetPopupMenu();
1367 sal_uInt16 nInstancesDetailsId = pMenu->GetItemId("instancesdetails");
1368 pMenu->SetItemBits(nInstancesDetailsId, MenuItemBits::CHECKABLE );
1369 pMenu->CheckItem(nInstancesDetailsId, m_bShowDetails );
1370
1371 m_pTabCtrl->SetCurPageId(m_pTabCtrl->GetPageId(sPageId));
1372 ActivatePageHdl(m_pTabCtrl);
1373
1374 // get our frame
1375 DBG_ASSERT( pBindings != nullptr,
1376 "DataNavigatorWindow::LoadModels(): no SfxBindings; can't get frame" );
1377 m_xFrame = pBindings->GetDispatcher()->GetFrame()->GetFrame().GetFrameInterface();
1378 DBG_ASSERT( m_xFrame.is(), "DataNavigatorWindow::LoadModels(): no frame" );
1379 // add frameaction listener
1380 Reference< XFrameActionListener > xListener(
1381 static_cast< XFrameActionListener* >( m_xDataListener.get() ), UNO_QUERY );
1382 m_xFrame->addFrameActionListener( xListener );
1383
1384 // load xforms models of the current document
1385 LoadModels();
1386 }
1387
1388 DataNavigatorWindow::~DataNavigatorWindow()
1389 {
1390 disposeOnce();
1391 }
1392
1393 void DataNavigatorWindow::dispose()
1394 {
1395 SvtViewOptions aViewOpt( EViewType::TabDialog, CFGNAME_DATANAVIGATOR );
1396 aViewOpt.SetPageID(m_pTabCtrl->GetPageName(m_pTabCtrl->GetCurPageId()));
1397 aViewOpt.SetUserItem(CFGNAME_SHOWDETAILS, Any(m_bShowDetails));
1398
1399 m_pInstPage.disposeAndClear();
1400 m_pSubmissionPage.disposeAndClear();
1401 m_pBindingPage.disposeAndClear();
1402
1403 sal_Int32 i, nCount = m_aPageList.size();
1404 for ( i = 0; i < nCount; ++i )
1405 m_aPageList[i].disposeAndClear();
1406 m_aPageList.clear();
1407
1408 Reference< XFrameActionListener > xListener(
1409 static_cast< XFrameActionListener* >( m_xDataListener.get() ), UNO_QUERY );
1410 m_xFrame->removeFrameActionListener( xListener );
1411 RemoveBroadcaster();
1412 m_xDataListener.clear();
1413 disposeBuilder();
1414 m_pModelsBox.clear();
1415 m_pModelBtn.clear();
1416 m_pTabCtrl.clear();
1417 m_pInstanceBtn.clear();
1418 vcl::Window::dispose();
1419 }
1420
1421
1422 IMPL_LINK( DataNavigatorWindow, ModelSelectListBoxHdl, ListBox&, rBox, void )
1423 {
1424 ModelSelectHdl(&rBox);
1425 }
1426 void DataNavigatorWindow::ModelSelectHdl(ListBox const * pBox)
1427 {
1428 sal_Int32 nPos = m_pModelsBox->GetSelectedEntryPos();
1429 // pBox == NULL, if you want to force a new fill.
1430 if ( nPos != m_nLastSelectedPos || !pBox )
1431 {
1432 m_nLastSelectedPos = nPos;
1433 ClearAllPageModels( pBox != nullptr );
1434 InitPages();
1435 SetPageModel();
1436 }
1437 }
1438
1439 IMPL_LINK( DataNavigatorWindow, MenuSelectHdl, MenuButton *, pBtn, void )
1440 {
1441 bool bIsDocModified = false;
1442 Reference< css::xforms::XFormsUIHelper1 > xUIHelper;
1443 sal_Int32 nSelectedPos = m_pModelsBox->GetSelectedEntryPos();
1444 OUString sSelectedModel( m_pModelsBox->GetEntry( nSelectedPos ) );
1445 Reference< css::xforms::XModel > xModel;
1446 try
1447 {
1448 Any aAny = m_xDataContainer->getByName( sSelectedModel );
1449 if ( aAny >>= xModel )
1450 xUIHelper.set( xModel, UNO_QUERY );
1451 }
1452 catch ( Exception const & )
1453 {
1454 TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::MenuSelectHdl()" );
1455 }
1456 DBG_ASSERT( xUIHelper.is(), "DataNavigatorWindow::MenuSelectHdl(): no UIHelper" );
1457
1458 m_bIsNotifyDisabled = true;
1459
1460 if (m_pModelBtn == pBtn)
1461 {
1462 OString sIdent(pBtn->GetCurItemIdent());
1463 if (sIdent == "modelsadd")
1464 {
1465 AddModelDialog aDlg(GetFrameWeld(), false);
1466 bool bShowDialog = true;
1467 while ( bShowDialog )
1468 {
1469 bShowDialog = false;
1470 if (aDlg.run() == RET_OK)
1471 {
1472 OUString sNewName = aDlg.GetName();
1473 bool bDocumentData = aDlg.GetModifyDoc();
1474
1475 if ( m_pModelsBox->GetEntryPos( sNewName ) != LISTBOX_ENTRY_NOTFOUND )
1476 {
1477 // error: model name already exists
1478 std::unique_ptr<weld::MessageDialog> xErrBox(Application::CreateMessageDialog(GetFrameWeld(),
1479 VclMessageType::Warning, VclButtonsType::Ok,
1480 SvxResId(RID_STR_DOUBLE_MODELNAME)));
1481 xErrBox->set_primary_text(xErrBox->get_primary_text().replaceFirst(MSG_VARIABLE, sNewName));
1482 xErrBox->run();
1483 bShowDialog = true;
1484 }
1485 else
1486 {
1487 try
1488 {
1489 // add new model to frame model
1490 Reference< css::xforms::XModel > xNewModel(
1491 xUIHelper->newModel( m_xFrameModel, sNewName ), UNO_SET_THROW );
1492
1493 Reference< XPropertySet > xModelProps( xNewModel, UNO_QUERY_THROW );
1494 xModelProps->setPropertyValue("ExternalData", makeAny( !bDocumentData ) );
1495
1496 sal_Int32 nNewPos = m_pModelsBox->InsertEntry( sNewName );
1497 m_pModelsBox->SelectEntryPos( nNewPos );
1498 ModelSelectHdl(m_pModelsBox);
1499 bIsDocModified = true;
1500 }
1501 catch ( Exception const & )
1502 {
1503 TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::MenuSelectHdl()" );
1504 }
1505 }
1506 }
1507 }
1508 }
1509 else if (sIdent == "modelsedit")
1510 {
1511 AddModelDialog aDlg(GetFrameWeld(), true);
1512 aDlg.SetName( sSelectedModel );
1513
1514 bool bDocumentData( false );
1515 try
1516 {
1517 Reference< css::xforms::XFormsSupplier > xFormsSupp( m_xFrameModel, UNO_QUERY_THROW );
1518 Reference< XNameContainer > xXForms( xFormsSupp->getXForms(), UNO_SET_THROW );
1519 Reference< XPropertySet > xModelProps( xXForms->getByName( sSelectedModel ), UNO_QUERY_THROW );
1520 bool bExternalData = false;
1521 OSL_VERIFY( xModelProps->getPropertyValue( "ExternalData" ) >>= bExternalData );
1522 bDocumentData = !bExternalData;
1523 }
1524 catch( const Exception& )
1525 {
1526 DBG_UNHANDLED_EXCEPTION("svx");
1527 }
1528 aDlg.SetModifyDoc( bDocumentData );
1529
1530 if (aDlg.run() == RET_OK)
1531 {
1532 if ( aDlg.GetModifyDoc() != bDocumentData )
1533 {
1534 bDocumentData = aDlg.GetModifyDoc();
1535 try
1536 {
1537 Reference< css::xforms::XFormsSupplier > xFormsSupp( m_xFrameModel, UNO_QUERY_THROW );
1538 Reference< XNameContainer > xXForms( xFormsSupp->getXForms(), UNO_SET_THROW );
1539 Reference< XPropertySet > xModelProps( xXForms->getByName( sSelectedModel ), UNO_QUERY_THROW );
1540 xModelProps->setPropertyValue( "ExternalData", makeAny( !bDocumentData ) );
1541 bIsDocModified = true;
1542 }
1543 catch( const Exception& )
1544 {
1545 DBG_UNHANDLED_EXCEPTION("svx");
1546 }
1547 }
1548
1549 OUString sNewName = aDlg.GetName();
1550 if ( !sNewName.isEmpty() && ( sNewName != sSelectedModel ) )
1551 {
1552 try
1553 {
1554 xUIHelper->renameModel( m_xFrameModel, sSelectedModel, sNewName );
1555
1556 m_pModelsBox->RemoveEntry( nSelectedPos );
1557 nSelectedPos = m_pModelsBox->InsertEntry( sNewName );
1558 m_pModelsBox->SelectEntryPos( nSelectedPos );
1559 bIsDocModified = true;
1560 }
1561 catch ( Exception const & )
1562 {
1563 TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::MenuSelectHdl()" );
1564 }
1565 }
1566 }
1567 }
1568 else if (sIdent == "modelsremove")
1569 {
1570 std::unique_ptr<weld::MessageDialog> xQBox(Application::CreateMessageDialog(GetFrameWeld(),
1571 VclMessageType::Question, VclButtonsType::YesNo,
1572 SvxResId( RID_STR_QRY_REMOVE_MODEL)));
1573 OUString sText = xQBox->get_primary_text();
1574 sText = sText.replaceFirst( MODELNAME, sSelectedModel );
1575 xQBox->set_primary_text(sText);
1576 if (xQBox->run() == RET_YES)
1577 {
1578 try
1579 {
1580 xUIHelper->removeModel( m_xFrameModel, sSelectedModel );
1581 }
1582 catch ( Exception const & )
1583 {
1584 TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::MenuSelectHdl()" );
1585 }
1586 m_pModelsBox->RemoveEntry( nSelectedPos );
1587 if ( m_pModelsBox->GetEntryCount() <= nSelectedPos )
1588 nSelectedPos = m_pModelsBox->GetEntryCount() - 1;
1589 m_pModelsBox->SelectEntryPos( nSelectedPos );
1590 ModelSelectHdl(m_pModelsBox);
1591 bIsDocModified = true;
1592 }
1593 }
1594 else
1595 {
1596 SAL_WARN( "svx.form", "DataNavigatorWindow::MenuSelectHdl(): wrong menu item" );
1597 }
1598 }
1599 else if (m_pInstanceBtn == pBtn)
1600 {
1601 OString sIdent(pBtn->GetCurItemIdent());
1602 if (sIdent == "instancesadd")
1603 {
1604 AddInstanceDialog aDlg(GetFrameWeld(), false);
1605 if (aDlg.run() == RET_OK)
1606 {
1607 sal_uInt16 nInst = GetNewPageId();
1608 OUString sName = aDlg.GetName();
1609 OUString sURL = aDlg.GetURL();
1610 bool bLinkOnce = aDlg.IsLinkInstance();
1611 try
1612 {
1613 xUIHelper->newInstance( sName, sURL, !bLinkOnce );
1614 }
1615 catch ( Exception const & )
1616 {
1617 TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::MenuSelectHdl()" );
1618 }
1619 ModelSelectHdl( nullptr );
1620 m_pTabCtrl->SetCurPageId( nInst );
1621 XFormsPage* pPage = GetCurrentPage( nInst );
1622 pPage->SetInstanceName(sName);
1623 pPage->SetInstanceURL(sURL);
1624 pPage->SetLinkOnce(bLinkOnce);
1625 ActivatePageHdl(m_pTabCtrl);
1626 bIsDocModified = true;
1627 }
1628 }
1629 else if (sIdent == "instancesedit")
1630 {
1631 sal_uInt16 nId = 0;
1632 XFormsPage* pPage = GetCurrentPage( nId );
1633 if ( pPage )
1634 {
1635 AddInstanceDialog aDlg(GetFrameWeld(), true);
1636 aDlg.SetName( pPage->GetInstanceName() );
1637 aDlg.SetURL( pPage->GetInstanceURL() );
1638 aDlg.SetLinkInstance( pPage->GetLinkOnce() );
1639 OUString sOldName = aDlg.GetName();
1640 if (aDlg.run() == RET_OK)
1641 {
1642 OUString sNewName = aDlg.GetName();
1643 OUString sURL = aDlg.GetURL();
1644 bool bLinkOnce = aDlg.IsLinkInstance();
1645 try
1646 {
1647 xUIHelper->renameInstance( sOldName,
1648 sNewName,
1649 sURL,
1650 !bLinkOnce );
1651 }
1652 catch ( Exception const & )
1653 {
1654 TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::MenuSelectHdl()" );
1655 }
1656 pPage->SetInstanceName(sNewName);
1657 pPage->SetInstanceURL(sURL);
1658 pPage->SetLinkOnce(bLinkOnce);
1659 m_pTabCtrl->SetPageText( nId, sNewName );
1660 bIsDocModified = true;
1661 }
1662 }
1663 }
1664 else if (sIdent == "instancesremove")
1665 {
1666 sal_uInt16 nId = 0;
1667 VclPtr<XFormsPage> pPage = GetCurrentPage( nId );
1668 if ( pPage )
1669 {
1670 OUString sInstName = pPage->GetInstanceName();
1671 std::unique_ptr<weld::MessageDialog> xQBox(Application::CreateMessageDialog(GetFrameWeld(),
1672 VclMessageType::Question, VclButtonsType::YesNo,
1673 SvxResId(RID_STR_QRY_REMOVE_INSTANCE)));
1674 OUString sMessText = xQBox->get_primary_text();
1675 sMessText = sMessText.replaceFirst( INSTANCENAME, sInstName );
1676 xQBox->set_primary_text(sMessText);
1677 if (xQBox->run() == RET_YES)
1678 {
1679 bool bDoRemove = false;
1680 if (IsAdditionalPage(nId))
1681 {
1682 auto aPageListEnd = m_aPageList.end();
1683 auto aFoundPage = std::find( m_aPageList.begin(), aPageListEnd, pPage );
1684 if ( aFoundPage != aPageListEnd )
1685 {
1686 m_aPageList.erase( aFoundPage );
1687 pPage.disposeAndClear() ;
1688 bDoRemove = true;
1689 }
1690 }
1691 else
1692 {
1693 m_pInstPage.disposeAndClear();
1694 bDoRemove = true;
1695 }
1696
1697 if ( bDoRemove )
1698 {
1699 try
1700 {
1701 xUIHelper->removeInstance( sInstName );
1702 }
1703 catch (const Exception&)
1704 {
1705 TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::MenuSelectHdl()" );
1706 }
1707 m_pTabCtrl->RemovePage( nId );
1708 m_pTabCtrl->SetCurPageId(m_pTabCtrl->GetPageId("instance"));
1709 ModelSelectHdl( nullptr );
1710 bIsDocModified = true;
1711 }
1712 }
1713 }
1714 }
1715 else if (sIdent == "instancesdetails")
1716 {
1717 m_bShowDetails = !m_bShowDetails;
1718 PopupMenu* pMenu = m_pInstanceBtn->GetPopupMenu();
1719 pMenu->CheckItem("instancesdetails", m_bShowDetails );
1720 ModelSelectHdl(m_pModelsBox);
1721 }
1722 else
1723 {
1724 SAL_WARN( "svx.form", "DataNavigatorWindow::MenuSelectHdl(): wrong menu item" );
1725 }
1726 }
1727 else
1728 {
1729 SAL_WARN( "svx.form", "DataNavigatorWindow::MenuSelectHdl(): wrong button" );
1730 }
1731
1732 m_bIsNotifyDisabled = false;
1733
1734 if ( bIsDocModified )
1735 SetDocModified();
1736 }
1737
1738 bool DataNavigatorWindow::IsAdditionalPage(sal_uInt16 nId) const
1739 {
1740 return m_pTabCtrl->GetPageName(nId).isEmpty();
1741 }
1742
1743 IMPL_LINK( DataNavigatorWindow, MenuActivateHdl, MenuButton *, pBtn, void )
1744 {
1745 Menu* pMenu = pBtn->GetPopupMenu();
1746
1747 if (m_pInstanceBtn == pBtn)
1748 {
1749 sal_uInt16 nId(m_pTabCtrl->GetCurPageId());
1750 bool bIsInstPage = (IsAdditionalPage(nId) || m_pTabCtrl->GetPageName(nId) == "instance");
1751 pMenu->EnableItem( "instancesedit", bIsInstPage );
1752 pMenu->EnableItem( "instancesremove",
1753 bIsInstPage && m_pTabCtrl->GetPageCount() > MIN_PAGE_COUNT );
1754 pMenu->EnableItem( "instancesdetails", bIsInstPage );
1755 }
1756 else if (m_pModelBtn == pBtn)
1757 {
1758 // we need at least one model!
1759 pMenu->EnableItem("modelsremove", m_pModelsBox->GetEntryCount() > 1 );
1760 }
1761 else
1762 {
1763 SAL_WARN( "svx.form", "DataNavigatorWindow::MenuActivateHdl(): wrong button" );
1764 }
1765 }
1766
1767 IMPL_LINK_NOARG(DataNavigatorWindow, ActivatePageHdl, TabControl*, void)
1768 {
1769 sal_uInt16 nId = 0;
1770 XFormsPage* pPage = GetCurrentPage( nId );
1771 if ( pPage )
1772 {
1773 m_pTabCtrl->SetTabPage( nId, pPage );
1774 if ( m_xDataContainer.is() && !pPage->HasModel() )
1775 SetPageModel();
1776 }
1777 }
1778
1779 IMPL_LINK_NOARG(DataNavigatorWindow, UpdateHdl, Timer *, void)
1780 {
1781 ModelSelectHdl( nullptr );
1782 }
1783
1784 XFormsPage* DataNavigatorWindow::GetCurrentPage( sal_uInt16& rCurId )
1785 {
1786 rCurId = m_pTabCtrl->GetCurPageId();
1787 VclPtr<XFormsPage> pPage;
1788 OString sName(m_pTabCtrl->GetPageName(rCurId));
1789 if (sName == "submissions")
1790 {
1791 if ( !m_pSubmissionPage )
1792 m_pSubmissionPage = VclPtr<XFormsPage>::Create(m_pTabCtrl, this, DGTSubmission);
1793 pPage = m_pSubmissionPage;
1794 }
1795 else if (sName == "bindings")
1796 {
1797 if ( !m_pBindingPage )
1798 m_pBindingPage = VclPtr<XFormsPage>::Create(m_pTabCtrl, this, DGTBinding);
1799 pPage = m_pBindingPage;
1800 }
1801 else if (sName == "instance")
1802 {
1803 if ( !m_pInstPage )
1804 m_pInstPage = VclPtr<XFormsPage>::Create(m_pTabCtrl, this, DGTInstance);
1805 pPage = m_pInstPage;
1806 }
1807 else
1808 {
1809 sal_uInt16 nPos = m_pTabCtrl->GetPagePos( rCurId );
1810 if ( HasFirstInstancePage() && nPos > 0 )
1811 nPos--;
1812 if ( m_aPageList.size() > nPos )
1813 pPage = m_aPageList[nPos];
1814 else
1815 {
1816 pPage = VclPtr<XFormsPage>::Create(m_pTabCtrl, this, DGTInstance);
1817 m_aPageList.push_back( pPage );
1818 }
1819 }
1820
1821 return pPage;
1822 }
1823
1824 void DataNavigatorWindow::LoadModels()
1825 {
1826 if ( !m_xFrameModel.is() )
1827 {
1828 // get model of active frame
1829 Reference< XController > xCtrl = m_xFrame->getController();
1830 if ( xCtrl.is() )
1831 {
1832 try
1833 {
1834 m_xFrameModel = xCtrl->getModel();
1835 }
1836 catch ( Exception const & )
1837 {
1838 TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::LoadModels()" );
1839 }
1840 }
1841 }
1842
1843 if ( m_xFrameModel.is() )
1844 {
1845 try
1846 {
1847 Reference< css::xforms::XFormsSupplier > xFormsSupp( m_xFrameModel, UNO_QUERY );
1848 if ( xFormsSupp.is() )
1849 {
1850 Reference< XNameContainer > xContainer = xFormsSupp->getXForms();
1851 if ( xContainer.is() )
1852 {
1853 m_xDataContainer = xContainer;
1854 const Sequence< OUString > aNameList = m_xDataContainer->getElementNames();
1855 for ( const OUString& rName : aNameList )
1856 {
1857 Any aAny = m_xDataContainer->getByName( rName );
1858 Reference< css::xforms::XModel > xFormsModel;
1859 if ( aAny >>= xFormsModel )
1860 m_pModelsBox->InsertEntry( xFormsModel->getID() );
1861 }
1862 }
1863 }
1864 }
1865 catch( Exception const & )
1866 {
1867 TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::LoadModels()" );
1868 }
1869 }
1870
1871 if ( m_pModelsBox->GetEntryCount() > 0 )
1872 {
1873 m_pModelsBox->SelectEntryPos(0);
1874 ModelSelectHdl(m_pModelsBox);
1875 }
1876 }
1877
1878 void DataNavigatorWindow::SetPageModel()
1879 {
1880 OUString sModel( m_pModelsBox->GetSelectedEntry() );
1881 try
1882 {
1883 Any aAny = m_xDataContainer->getByName( sModel );
1884 Reference< css::xforms::XModel > xFormsModel;
1885 if ( aAny >>= xFormsModel )
1886 {
1887 sal_uInt16 nPagePos = TAB_PAGE_NOTFOUND;
1888 sal_uInt16 nId = 0;
1889 XFormsPage* pPage = GetCurrentPage( nId );
1890 DBG_ASSERT( pPage, "DataNavigatorWindow::SetPageModel(): no page" );
1891 if (IsAdditionalPage(nId) || m_pTabCtrl->GetPageName(nId) == "instance")
1892 {
1893 // instance page
1894 nPagePos = m_pTabCtrl->GetPagePos( nId );
1895 }
1896 m_bIsNotifyDisabled = true;
1897 OUString sText = pPage->SetModel( xFormsModel, nPagePos );
1898 m_bIsNotifyDisabled = false;
1899 if ( !sText.isEmpty() )
1900 m_pTabCtrl->SetPageText( nId, sText );
1901 }
1902 }
1903 catch (const NoSuchElementException& )
1904 {
1905 SAL_WARN( "svx.form", "DataNavigatorWindow::SetPageModel(): no such element" );
1906 }
1907 catch( Exception const & )
1908 {
1909 TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::SetPageModel()" );
1910 }
1911 }
1912
1913 void DataNavigatorWindow::InitPages()
1914 {
1915 OUString sModel( m_pModelsBox->GetSelectedEntry() );
1916 try
1917 {
1918 Any aAny = m_xDataContainer->getByName( sModel );
1919 Reference< css::xforms::XModel > xModel;
1920 if ( aAny >>= xModel )
1921 {
1922 Reference< XEnumerationAccess > xNumAccess = xModel->getInstances();
1923 if ( xNumAccess.is() )
1924 {
1925 Reference < XEnumeration > xNum = xNumAccess->createEnumeration();
1926 if ( xNum.is() && xNum->hasMoreElements() )
1927 {
1928 sal_Int32 nAlreadyLoadedCount = m_aPageList.size();
1929 if ( !HasFirstInstancePage() && nAlreadyLoadedCount > 0 )
1930 nAlreadyLoadedCount--;
1931 sal_Int32 nIdx = 0;
1932 while ( xNum->hasMoreElements() )
1933 {
1934 if ( nIdx > nAlreadyLoadedCount )
1935 {
1936 Sequence< PropertyValue > xPropSeq;
1937 if ( xNum->nextElement() >>= xPropSeq )
1938 CreateInstancePage( xPropSeq );
1939 else
1940 {
1941 SAL_WARN( "svx.form", "DataNavigator::InitPages(): invalid instance" );
1942 }
1943 }
1944 else
1945 xNum->nextElement();
1946 nIdx++;
1947 }
1948 }
1949 }
1950 }
1951 }
1952 catch ( NoSuchElementException& )
1953 {
1954 SAL_WARN( "svx.form", "DataNavigatorWindow::SetPageModel(): no such element" );
1955 }
1956 catch( Exception const & )
1957 {
1958 TOOLS_WARN_EXCEPTION( "svx.form", "DataNavigatorWindow::SetPageModel()" );
1959 }
1960 }
1961
1962 void DataNavigatorWindow::ClearAllPageModels( bool bClearPages )
1963 {
1964 if ( m_pInstPage )
1965 m_pInstPage->ClearModel();
1966 if ( m_pSubmissionPage )
1967 m_pSubmissionPage->ClearModel();
1968 if ( m_pBindingPage )
1969 m_pBindingPage->ClearModel();
1970
1971 sal_Int32 i, nCount = m_aPageList.size();
1972 for ( i = 0; i < nCount; ++i )
1973 {
1974 VclPtr<XFormsPage> pPage = m_aPageList[i];
1975 pPage->ClearModel();
1976 if ( bClearPages )
1977 pPage.disposeAndClear();
1978 }
1979
1980 if ( bClearPages )
1981 {
1982 m_aPageList.clear();
1983 while ( m_pTabCtrl->GetPageCount() > MIN_PAGE_COUNT )
1984 m_pTabCtrl->RemovePage( m_pTabCtrl->GetPageId( 1 ) );
1985 }
1986 }
1987
1988 void DataNavigatorWindow::CreateInstancePage( const Sequence< PropertyValue >& _xPropSeq )
1989 {
1990 OUString sInstName;
1991 auto pProp = std::find_if(_xPropSeq.begin(), _xPropSeq.end(),
1992 [](const PropertyValue& rProp) { return PN_INSTANCE_ID == rProp.Name; });
1993 if (pProp != _xPropSeq.end())
1994 pProp->Value >>= sInstName;
1995
1996 sal_uInt16 nPageId = GetNewPageId();
1997 if ( sInstName.isEmpty() )
1998 {
1999 SAL_WARN( "svx.form", "DataNavigatorWindow::CreateInstancePage(): instance without name" );
2000 sInstName = "untitled" + OUString::number( nPageId );
2001 }
2002 m_pTabCtrl->InsertPage( nPageId, sInstName, m_pTabCtrl->GetPageCount() - 2 );
2003 }
2004
2005 bool DataNavigatorWindow::HasFirstInstancePage() const
2006 {
2007 return (m_pTabCtrl->GetPageName(m_pTabCtrl->GetPageId(0)) == "instance");
2008 }
2009
2010 sal_uInt16 DataNavigatorWindow::GetNewPageId() const
2011 {
2012 sal_uInt16 i, nMax = 0, nCount = m_pTabCtrl->GetPageCount();
2013 for ( i = 0; i < nCount; ++i )
2014 {
2015 if ( nMax < m_pTabCtrl->GetPageId(i) )
2016 nMax = m_pTabCtrl->GetPageId(i);
2017 }
2018 return ( nMax + 1 );
2019 }
2020
2021 void DataNavigatorWindow::Resize()
2022 {
2023 vcl::Window *pChild = GetWindow(GetWindowType::FirstChild);
2024 if (!pChild)
2025 return;
2026 VclContainer::setLayoutAllocation(*pChild, Point(0,0), GetSizePixel());
2027 }
2028
2029 Size DataNavigatorWindow::GetOptimalSize() const
2030 {
2031 const vcl::Window *pChild = GetWindow(GetWindowType::FirstChild);
2032 if (!pChild)
2033 return Window::GetOptimalSize();
2034 return VclContainer::getLayoutRequisition(*pChild);
2035 }
2036
2037 void DataNavigatorWindow::SetDocModified()
2038 {
2039 SfxObjectShell* pCurrentDoc = SfxObjectShell::Current();
2040 DBG_ASSERT( pCurrentDoc, "DataNavigatorWindow::SetDocModified(): no objectshell" );
2041 if ( !pCurrentDoc->IsModified() && pCurrentDoc->IsEnableSetModified() )
2042 pCurrentDoc->SetModified();
2043 }
2044
2045 void DataNavigatorWindow::NotifyChanges( bool _bLoadAll )
2046 {
2047 if ( !m_bIsNotifyDisabled )
2048 {
2049 if ( _bLoadAll )
2050 {
2051 // reset all members
2052 RemoveBroadcaster();
2053 m_xDataContainer.clear();
2054 m_xFrameModel.clear();
2055 m_pModelsBox->Clear();
2056 m_nLastSelectedPos = LISTBOX_ENTRY_NOTFOUND;
2057 // for a reload
2058 LoadModels();
2059 }
2060 else
2061 m_aUpdateTimer.Start();
2062 }
2063 }
2064
2065
2066 void DataNavigatorWindow::AddContainerBroadcaster( const css::uno::Reference< css::container::XContainer >& xContainer )
2067 {
2068 Reference< XContainerListener > xListener(
2069 static_cast< XContainerListener* >( m_xDataListener.get() ), UNO_QUERY );
2070 xContainer->addContainerListener( xListener );
2071 m_aContainerList.push_back( xContainer );
2072 }
2073
2074
2075 void DataNavigatorWindow::AddEventBroadcaster( const css::uno::Reference< css::xml::dom::events::XEventTarget >& xTarget )
2076 {
2077 Reference< XEventListener > xListener(
2078 static_cast< XEventListener* >( m_xDataListener.get() ), UNO_QUERY );
2079 xTarget->addEventListener( EVENTTYPE_CHARDATA, xListener, true );
2080 xTarget->addEventListener( EVENTTYPE_CHARDATA, xListener, false );
2081 xTarget->addEventListener( EVENTTYPE_ATTR, xListener, true );
2082 xTarget->addEventListener( EVENTTYPE_ATTR, xListener, false );
2083 m_aEventTargetList.push_back( xTarget );
2084 }
2085
2086
2087 void DataNavigatorWindow::RemoveBroadcaster()
2088 {
2089 Reference< XContainerListener > xContainerListener(
2090 static_cast< XContainerListener* >( m_xDataListener.get() ), UNO_QUERY );
2091 sal_Int32 i, nCount = m_aContainerList.size();
2092 for ( i = 0; i < nCount; ++i )
2093 m_aContainerList[i]->removeContainerListener( xContainerListener );
2094 Reference< XEventListener > xEventListener(
2095 static_cast< XEventListener* >( m_xDataListener.get() ), UNO_QUERY );
2096 nCount = m_aEventTargetList.size();
2097 for ( i = 0; i < nCount; ++i )
2098 {
2099 m_aEventTargetList[i]->removeEventListener( EVENTTYPE_CHARDATA, xEventListener, true );
2100 m_aEventTargetList[i]->removeEventListener( EVENTTYPE_CHARDATA, xEventListener, false );
2101 m_aEventTargetList[i]->removeEventListener( EVENTTYPE_ATTR, xEventListener, true );
2102 m_aEventTargetList[i]->removeEventListener( EVENTTYPE_ATTR, xEventListener, false );
2103 }
2104 }
2105
2106 DataNavigator::DataNavigator( SfxBindings* _pBindings, SfxChildWindow* _pMgr, vcl::Window* _pParent ) :
2107
2108 SfxDockingWindow( _pBindings, _pMgr, _pParent,
2109 WinBits(WB_STDMODELESS|WB_SIZEABLE|WB_ROLLABLE|WB_3DLOOK|WB_DOCKABLE) ),
2110 SfxControllerItem( SID_FM_DATANAVIGATOR_CONTROL, *_pBindings ),
2111
2112 m_aDataWin( VclPtr<DataNavigatorWindow>::Create(this, _pBindings) )
2113
2114 {
2115
2116 SetText( SvxResId( RID_STR_DATANAVIGATOR ) );
2117
2118 Size aSize = m_aDataWin->GetOutputSizePixel();
2119 Size aLogSize = PixelToLogic(aSize, MapMode(MapUnit::MapAppFont));
2120 SfxDockingWindow::SetFloatingSize( aLogSize );
2121
2122 m_aDataWin->Show();
2123 }
2124
2125
2126 DataNavigator::~DataNavigator()
2127 {
2128 disposeOnce();
2129 }
2130
2131 void DataNavigator::dispose()
2132 {
2133 m_aDataWin.disposeAndClear();
2134 ::SfxControllerItem::dispose();
2135 SfxDockingWindow::dispose();
2136 }
2137
2138 void DataNavigator::StateChanged( sal_uInt16 , SfxItemState , const SfxPoolItem* )
2139 {
2140 }
2141
2142
2143 Size DataNavigator::CalcDockingSize( SfxChildAlignment eAlign )
2144 {
2145 if ( ( eAlign == SfxChildAlignment::TOP ) || ( eAlign == SfxChildAlignment::BOTTOM ) )
2146 return Size();
2147
2148 return SfxDockingWindow::CalcDockingSize( eAlign );
2149 }
2150
2151
2152 SfxChildAlignment DataNavigator::CheckAlignment( SfxChildAlignment eActAlign, SfxChildAlignment eAlign )
2153 {
2154 switch ( eAlign )
2155 {
2156 case SfxChildAlignment::LEFT:
2157 case SfxChildAlignment::RIGHT:
2158 case SfxChildAlignment::NOALIGNMENT:
2159 return eAlign;
2160 default:
2161 break;
2162 }
2163 return eActAlign;
2164 }
2165
2166
2167 void DataNavigator::Resize()
2168 {
2169 SfxDockingWindow::Resize();
2170
2171 Size aLogOutputSize = PixelToLogic(GetOutputSizePixel(), MapMode(MapUnit::MapAppFont));
2172 Size aLogExplSize = aLogOutputSize;
2173 aLogExplSize.AdjustWidth( -2 );
2174 aLogExplSize.AdjustHeight( -2 );
2175
2176 Point aExplPos = LogicToPixel(Point(1,1), MapMode(MapUnit::MapAppFont));
2177 Size aExplSize = LogicToPixel(aLogExplSize, MapMode(MapUnit::MapAppFont));
2178
2179 m_aDataWin->SetPosSizePixel( aExplPos, aExplSize );
2180 }
2181
2182
2183 // class NavigatorFrameManager
2184
2185
2186 SFX_IMPL_DOCKINGWINDOW( DataNavigatorManager, SID_FM_SHOW_DATANAVIGATOR )
2187
2188
2189 DataNavigatorManager::DataNavigatorManager(
2190 vcl::Window* _pParent, sal_uInt16 _nId, SfxBindings* _pBindings, SfxChildWinInfo* _pInfo ) :
2191
2192 SfxChildWindow( _pParent, _nId )
2193
2194 {
2195 SetWindow( VclPtr<DataNavigator>::Create( _pBindings, this, _pParent ) );
2196 SetAlignment(SfxChildAlignment::RIGHT);
2197 GetWindow()->SetSizePixel( Size( 250, 400 ) );
2198 static_cast<SfxDockingWindow*>(GetWindow())->Initialize( _pInfo );
2199 }
2200
2201 AddDataItemDialog::AddDataItemDialog(weld::Window* pParent, ItemNode* _pNode,
2202 const Reference< css::xforms::XFormsUIHelper1 >& _rUIHelper)
2203 : GenericDialogController(pParent, "svx/ui/adddataitemdialog.ui", "AddDataItemDialog")
2204 , m_xUIHelper(_rUIHelper)
2205 , m_pItemNode(_pNode)
2206 , m_eItemType(DITNone)
2207 , m_sFL_Element(SvxResId(RID_STR_ELEMENT))
2208 , m_sFL_Attribute(SvxResId(RID_STR_ATTRIBUTE))
2209 , m_sFL_Binding(SvxResId(RID_STR_BINDING))
2210 , m_sFT_BindingExp(SvxResId(RID_STR_BINDING_EXPR))
2211 , m_xItemFrame(m_xBuilder->weld_frame("itemframe"))
2212 , m_xNameFT(m_xBuilder->weld_label("nameft"))
2213 , m_xNameED(m_xBuilder->weld_entry("name"))
2214 , m_xDefaultFT(m_xBuilder->weld_label("valueft"))
2215 , m_xDefaultED(m_xBuilder->weld_entry("value"))
2216 , m_xDefaultBtn(m_xBuilder->weld_button("browse"))
2217 , m_xSettingsFrame(m_xBuilder->weld_widget("settingsframe"))
2218 , m_xDataTypeFT(m_xBuilder->weld_label("datatypeft"))
2219 , m_xDataTypeLB(m_xBuilder->weld_combo_box("datatype"))
2220 , m_xRequiredCB(m_xBuilder->weld_check_button("required"))
2221 , m_xRequiredBtn(m_xBuilder->weld_button("requiredcond"))
2222 , m_xRelevantCB(m_xBuilder->weld_check_button("relevant"))
2223 , m_xRelevantBtn(m_xBuilder->weld_button("relevantcond"))
2224 , m_xConstraintCB(m_xBuilder->weld_check_button("constraint"))
2225 , m_xConstraintBtn(m_xBuilder->weld_button("constraintcond"))
2226 , m_xReadonlyCB(m_xBuilder->weld_check_button("readonly"))
2227 , m_xReadonlyBtn(m_xBuilder->weld_button("readonlycond"))
2228 , m_xCalculateCB(m_xBuilder->weld_check_button("calculate"))
2229 , m_xCalculateBtn(m_xBuilder->weld_button("calculatecond"))
2230 , m_xOKBtn(m_xBuilder->weld_button("ok"))
2231 {
2232 InitDialog();
2233 InitFromNode();
2234 InitDataTypeBox();
2235 Check(nullptr);
2236 }
2237
2238 AddDataItemDialog::~AddDataItemDialog()
2239 {
2240 if ( m_xTempBinding.is() )
2241 {
2242 Reference< css::xforms::XModel > xModel( m_xUIHelper, UNO_QUERY );
2243 if ( xModel.is() )
2244 {
2245 try
2246 {
2247 Reference < XSet > xBindings = xModel->getBindings();
2248 if ( xBindings.is() )
2249 xBindings->remove( makeAny( m_xTempBinding ) );
2250 }
2251 catch (const Exception&)
2252 {
2253 TOOLS_WARN_EXCEPTION( "svx.form", "AddDataItemDialog::Dtor()" );
2254 }
2255 }
2256 }
2257 if( m_xUIHelper.is() && m_xBinding.is() )
2258 {
2259 // remove binding, if it does not convey 'useful' information
2260 m_xUIHelper->removeBindingIfUseless( m_xBinding );
2261 }
2262 }
2263
2264 IMPL_LINK(AddDataItemDialog, CheckHdl, weld::ToggleButton&, rBox, void)
2265 {
2266 Check(&rBox);
2267 }
2268
2269 void AddDataItemDialog::Check(const weld::ToggleButton* pBox)
2270 {
2271 // Condition buttons are only enable if their check box is checked
2272 m_xReadonlyBtn->set_sensitive( m_xReadonlyCB->get_active() );
2273 m_xRequiredBtn->set_sensitive( m_xRequiredCB->get_active() );
2274 m_xRelevantBtn->set_sensitive( m_xRelevantCB->get_active() );
2275 m_xConstraintBtn->set_sensitive( m_xConstraintCB->get_active() );
2276 m_xCalculateBtn->set_sensitive( m_xCalculateCB->get_active() );
2277
2278 if ( pBox && m_xTempBinding.is() )
2279 {
2280 OUString sTemp, sPropName;
2281 if ( m_xRequiredCB.get() == pBox )
2282 sPropName = PN_REQUIRED_EXPR;
2283 else if ( m_xRelevantCB.get() == pBox )
2284 sPropName = PN_RELEVANT_EXPR;
2285 else if ( m_xConstraintCB.get() == pBox )
2286 sPropName = PN_CONSTRAINT_EXPR;
2287 else if ( m_xReadonlyCB.get() == pBox )
2288 sPropName = PN_READONLY_EXPR;
2289 else if ( m_xCalculateCB.get() == pBox )
2290 sPropName = PN_CALCULATE_EXPR;
2291 bool bIsChecked = pBox->get_active();
2292 m_xTempBinding->getPropertyValue( sPropName ) >>= sTemp;
2293 if ( bIsChecked && sTemp.isEmpty() )
2294 sTemp = TRUE_VALUE;
2295 else if ( !bIsChecked && !sTemp.isEmpty() )
2296 sTemp.clear();
2297 m_xTempBinding->setPropertyValue( sPropName, makeAny( sTemp ) );
2298 }
2299 }
2300
2301 IMPL_LINK(AddDataItemDialog, ConditionHdl, weld::Button&, rBtn, void)
2302 {
2303 OUString sTemp, sPropName;
2304 if ( m_xDefaultBtn.get() == &rBtn )
2305 sPropName = PN_BINDING_EXPR;
2306 else if ( m_xRequiredBtn.get() == &rBtn )
2307 sPropName = PN_REQUIRED_EXPR;
2308 else if ( m_xRelevantBtn.get() == &rBtn )
2309 sPropName = PN_RELEVANT_EXPR;
2310 else if ( m_xConstraintBtn.get() == &rBtn )
2311 sPropName = PN_CONSTRAINT_EXPR;
2312 else if (m_xReadonlyBtn.get() == &rBtn)
2313 sPropName = PN_READONLY_EXPR;
2314 else if (m_xCalculateBtn.get() == &rBtn)
2315 sPropName = PN_CALCULATE_EXPR;
2316 AddConditionDialog aDlg(m_xDialog.get(), sPropName, m_xTempBinding);
2317 bool bIsDefBtn = ( m_xDefaultBtn.get() == &rBtn );
2318 OUString sCondition;
2319 if ( bIsDefBtn )
2320 sCondition = m_xDefaultED->get_text();
2321 else
2322 {
2323 m_xTempBinding->getPropertyValue( sPropName ) >>= sTemp;
2324 if ( sTemp.isEmpty() )
2325 sTemp = TRUE_VALUE;
2326 sCondition = sTemp;
2327 }
2328 aDlg.SetCondition( sCondition );
2329
2330 if (aDlg.run() == RET_OK)
2331 {
2332 OUString sNewCondition = aDlg.GetCondition();
2333 if ( bIsDefBtn )
2334 m_xDefaultED->set_text(sNewCondition);
2335 else
2336 {
2337
2338 m_xTempBinding->setPropertyValue(
2339 sPropName, makeAny( sNewCondition ) );
2340 }
2341 }
2342 }
2343
2344 static void copyPropSet( const Reference< XPropertySet >& xFrom, Reference< XPropertySet > const & xTo )
2345 {
2346 DBG_ASSERT( xFrom.is(), "copyPropSet(): no source" );
2347 DBG_ASSERT( xTo.is(), "copyPropSet(): no target" );
2348
2349 try
2350 {
2351 // get property names & infos, and iterate over target properties
2352 const Sequence< Property > aProperties = xTo->getPropertySetInfo()->getProperties();
2353 Reference< XPropertySetInfo > xFromInfo = xFrom->getPropertySetInfo();
2354 for ( const Property& rProperty : aProperties )
2355 {
2356 const OUString& rName = rProperty.Name;
2357
2358 // if both set have the property, copy the value
2359 // (catch and ignore exceptions, if any)
2360 if ( xFromInfo->hasPropertyByName( rName ) )
2361 {
2362 // don't set readonly properties
2363 Property aProperty = xFromInfo->getPropertyByName( rName );
2364 if ( ( aProperty.Attributes & PropertyAttribute::READONLY ) == 0 )
2365 xTo->setPropertyValue(rName, xFrom->getPropertyValue( rName ));
2366 }
2367 // else: no property? then ignore.
2368 }
2369 }
2370 catch ( Exception const & )
2371 {
2372 TOOLS_WARN_EXCEPTION( "svx.form", "copyPropSet()" );
2373 }
2374 }
2375
2376 IMPL_LINK_NOARG(AddDataItemDialog, OKHdl, weld::Button&, void)
2377 {
2378 bool bIsHandleBinding = ( DITBinding == m_eItemType );
2379 bool bIsHandleText = ( DITText == m_eItemType );
2380 OUString sNewName( m_xNameED->get_text() );
2381
2382 if ( ( !bIsHandleBinding && !bIsHandleText && !m_xUIHelper->isValidXMLName( sNewName ) ) ||
2383 ( bIsHandleBinding && sNewName.isEmpty() ) )
2384 {
2385 // Error and don't close the dialog
2386 std::unique_ptr<weld::MessageDialog> xErrBox(Application::CreateMessageDialog(m_xDialog.get(),
2387 VclMessageType::Warning, VclButtonsType::Ok,
2388 SvxResId(RID_STR_INVALID_XMLNAME)));
2389 xErrBox->set_primary_text(xErrBox->get_primary_text().replaceFirst(MSG_VARIABLE, sNewName));
2390 xErrBox->run();
2391 return;
2392 }
2393
2394 OUString sDataType( m_xDataTypeLB->get_active_text() );
2395 m_xTempBinding->setPropertyValue( PN_BINDING_TYPE, makeAny( sDataType ) );
2396
2397 if ( bIsHandleBinding )
2398 {
2399 // copy properties from temp binding to original binding
2400 copyPropSet( m_xTempBinding, m_pItemNode->m_xPropSet );
2401 try
2402 {
2403 OUString sValue = m_xNameED->get_text();
2404 m_pItemNode->m_xPropSet->setPropertyValue( PN_BINDING_ID, makeAny( sValue ) );
2405 sValue = m_xDefaultED->get_text();
2406 m_pItemNode->m_xPropSet->setPropertyValue( PN_BINDING_EXPR, makeAny( sValue ) );
2407 }
2408 catch ( Exception const & )
2409 {
2410 TOOLS_WARN_EXCEPTION( "svx.form", "AddDataDialog::OKHdl()" );
2411 }
2412 }
2413 else
2414 {
2415 // copy properties from temp binding to original binding
2416 copyPropSet( m_xTempBinding, m_xBinding );
2417 try
2418 {
2419 if ( bIsHandleText )
2420 m_xUIHelper->setNodeValue( m_pItemNode->m_xNode, m_xDefaultED->get_text() );
2421 else
2422 {
2423 Reference< css::xml::dom::XNode > xNewNode =
2424 m_xUIHelper->renameNode( m_pItemNode->m_xNode, m_xNameED->get_text() );
2425 m_xUIHelper->setNodeValue( xNewNode, m_xDefaultED->get_text() );
2426 m_pItemNode->m_xNode = xNewNode;
2427 }
2428 }
2429 catch ( Exception const & )
2430 {
2431 TOOLS_WARN_EXCEPTION( "svx.form", "AddDataDialog::OKHdl()" );
2432 }
2433 }
2434 // then close the dialog
2435 m_xDialog->response(RET_OK);
2436 }
2437
2438 void AddDataItemDialog::InitDialog()
2439 {
2440 // set handler
2441 Link<weld::ToggleButton&,void> aLink = LINK( this, AddDataItemDialog, CheckHdl );
2442 m_xRequiredCB->connect_toggled( aLink );
2443 m_xRelevantCB->connect_toggled( aLink );
2444 m_xConstraintCB->connect_toggled( aLink );
2445 m_xReadonlyCB->connect_toggled( aLink );
2446 m_xCalculateCB->connect_toggled( aLink );
2447
2448 Link<weld::Button&,void> aLink2 = LINK( this, AddDataItemDialog, ConditionHdl );
2449 m_xDefaultBtn->connect_clicked( aLink2 );
2450 m_xRequiredBtn->connect_clicked( aLink2 );
2451 m_xRelevantBtn->connect_clicked( aLink2 );
2452 m_xConstraintBtn->connect_clicked( aLink2 );
2453 m_xReadonlyBtn->connect_clicked( aLink2 );
2454 m_xCalculateBtn->connect_clicked( aLink2 );
2455
2456 m_xOKBtn->connect_clicked( LINK( this, AddDataItemDialog, OKHdl ) );
2457 }
2458
2459 void AddDataItemDialog::InitFromNode()
2460 {
2461 if ( m_pItemNode )
2462 {
2463 if ( m_pItemNode->m_xNode.is() )
2464 {
2465 try
2466 {
2467 // detect type of the node
2468 css::xml::dom::NodeType eChildType = m_pItemNode->m_xNode->getNodeType();
2469 switch ( eChildType )
2470 {
2471 case css::xml::dom::NodeType_ATTRIBUTE_NODE:
2472 m_eItemType = DITAttribute;
2473 break;
2474 case css::xml::dom::NodeType_ELEMENT_NODE:
2475 m_eItemType = DITElement;
2476 break;
2477 case css::xml::dom::NodeType_TEXT_NODE:
2478 m_eItemType = DITText;
2479 break;
2480 default:
2481 OSL_FAIL( "AddDataItemDialog::InitFronNode: cannot handle this node type!" );
2482 break;
2483 }
2484
2485 /** Get binding of the node and clone it
2486 Then use this temporary binding in the dialog.
2487 When the user click OK the temporary binding will be copied
2488 into the original binding.
2489 */
2490
2491 Reference< css::xml::dom::XNode > xNode = m_pItemNode->m_xNode;
2492 m_xBinding = m_xUIHelper->getBindingForNode( xNode, true );
2493 if ( m_xBinding.is() )
2494 {
2495 Reference< css::xforms::XModel > xModel( m_xUIHelper, UNO_QUERY );
2496 if ( xModel.is() )
2497 {
2498 m_xTempBinding = m_xUIHelper->cloneBindingAsGhost( m_xBinding );
2499 Reference < XSet > xBindings = xModel->getBindings();
2500 if ( xBindings.is() )
2501 xBindings->insert( makeAny( m_xTempBinding ) );
2502 }
2503 }
2504
2505 if ( m_eItemType != DITText )
2506 {
2507 OUString sName( m_xUIHelper->getNodeName( m_pItemNode->m_xNode ) );
2508 m_xNameED->set_text( sName );
2509 }
2510 m_xDefaultED->set_text( m_pItemNode->m_xNode->getNodeValue() );
2511 }
2512 catch( Exception const & )
2513 {
2514 TOOLS_WARN_EXCEPTION( "svx.form", "AddDataItemDialog::InitFromNode()" );
2515 }
2516 }
2517 else if ( m_pItemNode->m_xPropSet.is() )
2518 {
2519 m_eItemType = DITBinding;
2520 Reference< css::xforms::XModel > xModel( m_xUIHelper, UNO_QUERY );
2521 if ( xModel.is() )
2522 {
2523 try
2524 {
2525 m_xTempBinding = m_xUIHelper->cloneBindingAsGhost( m_pItemNode->m_xPropSet );
2526 Reference < XSet > xBindings = xModel->getBindings();
2527 if ( xBindings.is() )
2528 xBindings->insert( makeAny( m_xTempBinding ) );
2529 }
2530 catch ( Exception const & )
2531 {
2532 TOOLS_WARN_EXCEPTION( "svx.form", "AddDataItemDialog::InitFromNode()" );
2533 }
2534 }
2535 OUString sTemp;
2536 try
2537 {
2538 Reference< XPropertySetInfo > xInfo = m_pItemNode->m_xPropSet->getPropertySetInfo();
2539 if ( xInfo->hasPropertyByName( PN_BINDING_ID ) )
2540 {
2541 m_pItemNode->m_xPropSet->getPropertyValue( PN_BINDING_ID ) >>= sTemp;
2542 m_xNameED->set_text( sTemp );
2543 m_pItemNode->m_xPropSet->getPropertyValue( PN_BINDING_EXPR ) >>= sTemp;
2544 m_xDefaultED->set_text( sTemp );
2545 }
2546 else if ( xInfo->hasPropertyByName( PN_SUBMISSION_BIND ) )
2547 {
2548 m_pItemNode->m_xPropSet->getPropertyValue( PN_SUBMISSION_ID ) >>= sTemp;
2549 m_xNameED->set_text( sTemp );
2550 }
2551 }
2552 catch( Exception const & )
2553 {
2554 TOOLS_WARN_EXCEPTION( "svx.form", "AddDataItemDialog::InitFromNode()" );
2555 }
2556
2557 m_xDefaultBtn->show();
2558 }
2559
2560 if ( m_xTempBinding.is() )
2561 {
2562 OUString sTemp;
2563 try
2564 {
2565 if ( ( m_xTempBinding->getPropertyValue( PN_REQUIRED_EXPR ) >>= sTemp )
2566 && !sTemp.isEmpty() )
2567 m_xRequiredCB->set_active(true);
2568 if ( ( m_xTempBinding->getPropertyValue( PN_RELEVANT_EXPR ) >>= sTemp )
2569 && !sTemp.isEmpty() )
2570 m_xRelevantCB->set_active(true);
2571 if ( ( m_xTempBinding->getPropertyValue( PN_CONSTRAINT_EXPR ) >>= sTemp )
2572 && !sTemp.isEmpty() )
2573 m_xConstraintCB->set_active(true);
2574 if ( ( m_xTempBinding->getPropertyValue( PN_READONLY_EXPR ) >>= sTemp )
2575 && !sTemp.isEmpty() )
2576 m_xReadonlyCB->set_active(true);
2577 if ( ( m_xTempBinding->getPropertyValue( PN_CALCULATE_EXPR ) >>= sTemp )
2578 && !sTemp.isEmpty() )
2579 m_xCalculateCB->set_active(true);
2580 }
2581 catch (const Exception&)
2582 {
2583 TOOLS_WARN_EXCEPTION( "svx.form", "AddDataItemDialog::InitFromNode()" );
2584 }
2585 }
2586 }
2587
2588 if ( DITText == m_eItemType )
2589 {
2590 m_xSettingsFrame->hide();
2591 m_xNameFT->set_sensitive(false);
2592 m_xNameED->set_sensitive(false);
2593 }
2594 }
2595
2596 void AddDataItemDialog::InitDataTypeBox()
2597 {
2598 if ( m_eItemType != DITText )
2599 {
2600 Reference< css::xforms::XModel > xModel( m_xUIHelper, UNO_QUERY );
2601 if ( xModel.is() )
2602 {
2603 try
2604 {
2605 Reference< css::xforms::XDataTypeRepository > xDataTypes =
2606 xModel->getDataTypeRepository();
2607 if ( xDataTypes.is() )
2608 {
2609 const Sequence< OUString > aNameList = xDataTypes->getElementNames();
2610 for ( const OUString& rName : aNameList )
2611 m_xDataTypeLB->append_text(rName);
2612 }
2613
2614 if ( m_xTempBinding.is() )
2615 {
2616 OUString sTemp;
2617 if ( m_xTempBinding->getPropertyValue( PN_BINDING_TYPE ) >>= sTemp )
2618 {
2619 int nPos = m_xDataTypeLB->find_text(sTemp);
2620 if (nPos == -1)
2621 {
2622 m_xDataTypeLB->append_text(sTemp);
2623 nPos = m_xDataTypeLB->get_count() - 1;
2624 }
2625 m_xDataTypeLB->set_active(nPos);
2626 }
2627 }
2628 }
2629 catch ( Exception const & )
2630 {
2631 TOOLS_WARN_EXCEPTION( "svx.form", "AddDataItemDialog::InitDataTypeBox()" );
2632 }
2633 }
2634 }
2635 }
2636
2637 void AddDataItemDialog::InitText( DataItemType _eType )
2638 {
2639 OUString sText;
2640
2641 switch ( _eType )
2642 {
2643 case DITAttribute :
2644 {
2645 sText = m_sFL_Attribute;
2646 break;
2647 }
2648
2649 case DITBinding :
2650 {
2651 sText = m_sFL_Binding;
2652 m_xDefaultFT->set_label(m_sFT_BindingExp);
2653 break;
2654 }
2655
2656 default:
2657 {
2658 sText = m_sFL_Element;
2659 }
2660 }
2661
2662 m_xItemFrame->set_label(sText);
2663 }
2664
2665 AddConditionDialog::AddConditionDialog(weld::Window* pParent,
2666 const OUString& _rPropertyName,
2667 const Reference< XPropertySet >& _rPropSet)
2668 : GenericDialogController(pParent, "svx/ui/addconditiondialog.ui", "AddConditionDialog")
2669 , m_sPropertyName(_rPropertyName)
2670 , m_xBinding(_rPropSet)
2671 , m_xConditionED(m_xBuilder->weld_text_view("condition"))
2672 , m_xResultWin(m_xBuilder->weld_text_view("result"))
2673 , m_xEditNamespacesBtn(m_xBuilder->weld_button("edit"))
2674 , m_xOKBtn(m_xBuilder->weld_button("ok"))
2675 {
2676 DBG_ASSERT( m_xBinding.is(), "AddConditionDialog::Ctor(): no Binding" );
2677
2678 m_xConditionED->set_size_request(m_xConditionED->get_approximate_digit_width() * 52,
2679 m_xConditionED->get_height_rows(4));
2680 m_xResultWin->set_size_request(m_xResultWin->get_approximate_digit_width() * 52,
2681 m_xResultWin->get_height_rows(4));
2682
2683 m_xConditionED->connect_changed( LINK( this, AddConditionDialog, ModifyHdl ) );
2684 m_xEditNamespacesBtn->connect_clicked( LINK( this, AddConditionDialog, EditHdl ) );
2685 m_xOKBtn->connect_clicked( LINK( this, AddConditionDialog, OKHdl ) );
2686 m_aResultIdle.SetPriority( TaskPriority::LOWEST );
2687 m_aResultIdle.SetInvokeHandler( LINK( this, AddConditionDialog, ResultHdl ) );
2688
2689 if ( !m_sPropertyName.isEmpty() )
2690 {
2691 try
2692 {
2693 OUString sTemp;
2694 if ( ( m_xBinding->getPropertyValue( m_sPropertyName ) >>= sTemp )
2695 && !sTemp.isEmpty() )
2696 {
2697 m_xConditionED->set_text( sTemp );
2698 }
2699 else
2700 {
2701 //! m_xBinding->setPropertyValue( m_sPropertyName, makeAny( TRUE_VALUE ) );
2702 m_xConditionED->set_text( TRUE_VALUE );
2703 }
2704
2705 Reference< css::xforms::XModel > xModel;
2706 if ( ( m_xBinding->getPropertyValue( PN_BINDING_MODEL ) >>= xModel ) && xModel.is() )
2707 m_xUIHelper.set( xModel, UNO_QUERY );
2708 }
2709 catch (const Exception&)
2710 {
2711 TOOLS_WARN_EXCEPTION( "svx.form", "AddConditionDialog::Ctor()" );
2712 }
2713 }
2714
2715 DBG_ASSERT( m_xUIHelper.is(), "AddConditionDialog::Ctor(): no UIHelper" );
2716 ResultHdl( &m_aResultIdle );
2717 }
2718
2719 AddConditionDialog::~AddConditionDialog()
2720 {
2721 }
2722
2723 IMPL_LINK_NOARG(AddConditionDialog, EditHdl, weld::Button&, void)
2724 {
2725 Reference< XNameContainer > xNameContnr;
2726 try
2727 {
2728 m_xBinding->getPropertyValue( PN_BINDING_NAMESPACES ) >>= xNameContnr;
2729 }
2730 catch ( Exception const & )
2731 {
2732 TOOLS_WARN_EXCEPTION( "svx.form", "AddDataItemDialog::EditHdl()" );
2733 }
2734 NamespaceItemDialog aDlg(this, xNameContnr);
2735 aDlg.run();
2736 try
2737 {
2738 m_xBinding->setPropertyValue( PN_BINDING_NAMESPACES, makeAny( xNameContnr ) );
2739 }
2740 catch ( Exception const & )
2741 {
2742 TOOLS_WARN_EXCEPTION( "svx.form", "AddDataItemDialog::EditHdl()" );
2743 }
2744 }
2745
2746 IMPL_LINK_NOARG(AddConditionDialog, OKHdl, weld::Button&, void)
2747 {
2748 m_xDialog->response(RET_OK);
2749 }
2750
2751 IMPL_LINK_NOARG(AddConditionDialog, ModifyHdl, weld::TextView&, void)
2752 {
2753 m_aResultIdle.Start();
2754 }
2755
2756 IMPL_LINK_NOARG(AddConditionDialog, ResultHdl, Timer *, void)
2757 {
2758 OUString sCondition = comphelper::string::strip(m_xConditionED->get_text(), ' ');
2759 OUString sResult;
2760 if ( !sCondition.isEmpty() )
2761 {
2762 try
2763 {
2764 sResult = m_xUIHelper->getResultForExpression( m_xBinding, ( m_sPropertyName == PN_BINDING_EXPR ), sCondition );
2765 }
2766 catch ( Exception const & )
2767 {
2768 TOOLS_WARN_EXCEPTION( "svx.form", "AddConditionDialog::ResultHdl()" );
2769 }
2770 }
2771 m_xResultWin->set_text(sResult);
2772 }
2773
2774 NamespaceItemDialog::NamespaceItemDialog(AddConditionDialog* pCondDlg, Reference<XNameContainer>& rContainer)
2775 : GenericDialogController(pCondDlg->getDialog(), "svx/ui/namespacedialog.ui", "NamespaceDialog")
2776 , m_pConditionDlg(pCondDlg)
2777 , m_rNamespaces(rContainer)
2778 , m_xNamespacesList(m_xBuilder->weld_tree_view("namespaces"))
2779 , m_xAddNamespaceBtn(m_xBuilder->weld_button("add"))
2780 , m_xEditNamespaceBtn(m_xBuilder->weld_button("edit"))
2781 , m_xDeleteNamespaceBtn(m_xBuilder->weld_button("delete"))
2782 , m_xOKBtn(m_xBuilder->weld_button("ok"))
2783 {
2784 m_xNamespacesList->set_size_request(m_xNamespacesList->get_approximate_digit_width() * 80,
2785 m_xNamespacesList->get_height_rows(8));
2786
2787 std::vector<int> aWidths;
2788 aWidths.push_back(m_xNamespacesList->get_approximate_digit_width() * 20);
2789 m_xNamespacesList->set_column_fixed_widths(aWidths);
2790
2791 m_xNamespacesList->connect_changed( LINK( this, NamespaceItemDialog, SelectHdl ) );
2792 Link<weld::Button&,void> aLink = LINK( this, NamespaceItemDialog, ClickHdl );
2793 m_xAddNamespaceBtn->connect_clicked( aLink );
2794 m_xEditNamespaceBtn->connect_clicked( aLink );
2795 m_xDeleteNamespaceBtn->connect_clicked( aLink );
2796 m_xOKBtn->connect_clicked( LINK( this, NamespaceItemDialog, OKHdl ) );
2797
2798 LoadNamespaces();
2799 SelectHdl(*m_xNamespacesList);
2800 }
2801
2802 NamespaceItemDialog::~NamespaceItemDialog()
2803 {
2804 }
2805
2806 IMPL_LINK_NOARG( NamespaceItemDialog, SelectHdl, weld::TreeView&, void)
2807 {
2808 bool bEnable = m_xNamespacesList->get_selected_index() != -1;
2809 m_xEditNamespaceBtn->set_sensitive( bEnable );
2810 m_xDeleteNamespaceBtn->set_sensitive( bEnable );
2811 }
2812
2813 IMPL_LINK( NamespaceItemDialog, ClickHdl, weld::Button&, rButton, void )
2814 {
2815 if (m_xAddNamespaceBtn.get() == &rButton)
2816 {
2817 ManageNamespaceDialog aDlg(m_xDialog.get(), m_pConditionDlg, false);
2818 if (aDlg.run() == RET_OK)
2819 {
2820 m_xNamespacesList->append_text(aDlg.GetPrefix());
2821 int nRow = m_xNamespacesList->n_children();
2822 m_xNamespacesList->set_text(nRow - 1, aDlg.GetURL(), 1);
2823 }
2824 }
2825 else if (m_xEditNamespaceBtn.get() == &rButton)
2826 {
2827 ManageNamespaceDialog aDlg(m_xDialog.get(), m_pConditionDlg, true);
2828 int nEntry = m_xNamespacesList->get_selected_index();
2829 DBG_ASSERT( nEntry != -1, "NamespaceItemDialog::ClickHdl(): no entry" );
2830 OUString sPrefix(m_xNamespacesList->get_text(nEntry, 0));
2831 aDlg.SetNamespace(sPrefix, m_xNamespacesList->get_text(nEntry, 1));
2832 if (aDlg.run() == RET_OK)
2833 {
2834 // if a prefix was changed, mark the old prefix as 'removed'
2835 if( sPrefix != aDlg.GetPrefix() )
2836 m_aRemovedList.push_back( sPrefix );
2837
2838 m_xNamespacesList->set_text(nEntry, aDlg.GetPrefix(), 0);
2839 m_xNamespacesList->set_text(nEntry, aDlg.GetURL(), 1);
2840 }
2841 }
2842 else if (m_xDeleteNamespaceBtn.get() == &rButton)
2843 {
2844 int nEntry = m_xNamespacesList->get_selected_index();
2845 DBG_ASSERT( nEntry != -1, "NamespaceItemDialog::ClickHdl(): no entry" );
2846 OUString sPrefix(m_xNamespacesList->get_text(nEntry, 0));
2847 m_aRemovedList.push_back( sPrefix );
2848 m_xNamespacesList->remove(nEntry);
2849 }
2850 else
2851 {
2852 SAL_WARN( "svx.form", "NamespaceItemDialog::ClickHdl(): invalid button" );
2853 }
2854
2855 SelectHdl(*m_xNamespacesList);
2856 }
2857
2858 IMPL_LINK_NOARG(NamespaceItemDialog, OKHdl, weld::Button&, void)
2859 {
2860 try
2861 {
2862 // update namespace container
2863 sal_Int32 i, nRemovedCount = m_aRemovedList.size();
2864 for( i = 0; i < nRemovedCount; ++i )
2865 m_rNamespaces->removeByName( m_aRemovedList[i] );
2866
2867 sal_Int32 nEntryCount = m_xNamespacesList->n_children();
2868 for( i = 0; i < nEntryCount; ++i )
2869 {
2870 OUString sPrefix(m_xNamespacesList->get_text(i, 0));
2871 OUString sURL(m_xNamespacesList->get_text(i, 1));
2872
2873 if ( m_rNamespaces->hasByName( sPrefix ) )
2874 m_rNamespaces->replaceByName( sPrefix, makeAny( sURL ) );
2875 else
2876 m_rNamespaces->insertByName( sPrefix, makeAny( sURL ) );
2877 }
2878 }
2879 catch ( Exception const & )
2880 {
2881 TOOLS_WARN_EXCEPTION( "svx.form", "NamespaceItemDialog::OKHdl()" );
2882 }
2883 // and close the dialog
2884 m_xDialog->response(RET_OK);
2885 }
2886
2887 void NamespaceItemDialog::LoadNamespaces()
2888 {
2889 try
2890 {
2891 int nRow = 0;
2892 const Sequence< OUString > aAllNames = m_rNamespaces->getElementNames();
2893 for ( const OUString& sPrefix : aAllNames )
2894 {
2895 if ( m_rNamespaces->hasByName( sPrefix ) )
2896 {
2897 OUString sURL;
2898 Any aAny = m_rNamespaces->getByName( sPrefix );
2899 if (aAny >>= sURL)
2900 {
2901 m_xNamespacesList->append_text(sPrefix);
2902 m_xNamespacesList->set_text(nRow, sURL, 1);
2903 ++nRow;
2904 }
2905 }
2906 }
2907 }
2908 catch ( Exception const & )
2909 {
2910 TOOLS_WARN_EXCEPTION( "svx.form", "NamespaceItemDialog::LoadNamespaces()" );
2911 }
2912 }
2913
2914 ManageNamespaceDialog::ManageNamespaceDialog(weld::Window* pParent, AddConditionDialog* pCondDlg, bool bIsEdit)
2915 : GenericDialogController(pParent, "svx/ui/addnamespacedialog.ui", "AddNamespaceDialog")
2916 , m_pConditionDlg(pCondDlg)
2917 , m_xPrefixED(m_xBuilder->weld_entry("prefix"))
2918 , m_xUrlED(m_xBuilder->weld_entry("url"))
2919 , m_xOKBtn(m_xBuilder->weld_button("ok"))
2920 , m_xAltTitle(m_xBuilder->weld_label("alttitle"))
2921 {
2922 if (bIsEdit)
2923 m_xDialog->set_title(m_xAltTitle->get_label());
2924
2925 m_xOKBtn->connect_clicked(LINK(this, ManageNamespaceDialog, OKHdl));
2926 }
2927
2928 ManageNamespaceDialog::~ManageNamespaceDialog()
2929 {
2930 }
2931
2932 IMPL_LINK_NOARG(ManageNamespaceDialog, OKHdl, weld::Button&, void)
2933 {
2934 OUString sPrefix = m_xPrefixED->get_text();
2935
2936 try
2937 {
2938 if (!m_pConditionDlg->GetUIHelper()->isValidPrefixName(sPrefix))
2939 {
2940 std::unique_ptr<weld::MessageDialog> xErrBox(Application::CreateMessageDialog(m_xDialog.get(),
2941 VclMessageType::Warning, VclButtonsType::Ok,
2942 SvxResId(RID_STR_INVALID_XMLPREFIX)));
2943 xErrBox->set_primary_text(xErrBox->get_primary_text().replaceFirst(MSG_VARIABLE, sPrefix));
2944 xErrBox->run();
2945 return;
2946 }
2947 }
2948 catch ( Exception const & )
2949 {
2950 TOOLS_WARN_EXCEPTION( "svx.form", "ManageNamespacesDialog::OKHdl()" );
2951 }
2952
2953 // no error so close the dialog
2954 m_xDialog->response(RET_OK);
2955 }
2956
2957 AddSubmissionDialog::AddSubmissionDialog(
2958 weld::Window* pParent, ItemNode* _pNode,
2959 const Reference< css::xforms::XFormsUIHelper1 >& _rUIHelper)
2960 : GenericDialogController(pParent, "svx/ui/addsubmissiondialog.ui", "AddSubmissionDialog")
2961 , m_pItemNode(_pNode)
2962 , m_xUIHelper(_rUIHelper)
2963 , m_xNameED(m_xBuilder->weld_entry("name"))
2964 , m_xActionED(m_xBuilder->weld_entry("action"))
2965 , m_xMethodLB(m_xBuilder->weld_combo_box("method"))
2966 , m_xRefED(m_xBuilder->weld_entry("expression"))
2967 , m_xRefBtn(m_xBuilder->weld_button("browse"))
2968 , m_xBindLB(m_xBuilder->weld_combo_box("binding"))
2969 , m_xReplaceLB(m_xBuilder->weld_combo_box("replace"))
2970 , m_xOKBtn(m_xBuilder->weld_button("ok"))
2971 {
2972 FillAllBoxes();
2973
2974 m_xRefBtn->connect_clicked( LINK( this, AddSubmissionDialog, RefHdl ) );
2975 m_xOKBtn->connect_clicked( LINK( this, AddSubmissionDialog, OKHdl ) );
2976 }
2977
2978 AddSubmissionDialog::~AddSubmissionDialog()
2979 {
2980 // #i38991# if we have added a binding, we need to remove it as well.
2981 if( m_xCreatedBinding.is() && m_xUIHelper.is() )
2982 m_xUIHelper->removeBindingIfUseless( m_xCreatedBinding );
2983 }
2984
2985 IMPL_LINK_NOARG(AddSubmissionDialog, RefHdl, weld::Button&, void)
2986 {
2987 AddConditionDialog aDlg(m_xDialog.get(), PN_BINDING_EXPR, m_xTempBinding );
2988 aDlg.SetCondition( m_xRefED->get_text() );
2989 if ( aDlg.run() == RET_OK )
2990 m_xRefED->set_text(aDlg.GetCondition());
2991 }
2992
2993 IMPL_LINK_NOARG(AddSubmissionDialog, OKHdl, weld::Button&, void)
2994 {
2995 OUString sName(m_xNameED->get_text());
2996 if(sName.isEmpty())
2997 {
2998 std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(m_xDialog.get(),
2999 VclMessageType::Warning, VclButtonsType::Ok,
3000 SvxResId(RID_STR_EMPTY_SUBMISSIONNAME)));
3001 xErrorBox->set_primary_text(Application::GetDisplayName());
3002 xErrorBox->run();
3003 return;
3004 }
3005
3006 if ( !m_xSubmission.is() )
3007 {
3008 DBG_ASSERT( !m_xNewSubmission.is(),
3009 "AddSubmissionDialog::OKHdl(): new submission already exists" );
3010
3011 // add a new submission
3012 Reference< css::xforms::XModel > xModel( m_xUIHelper, UNO_QUERY );
3013 if ( xModel.is() )
3014 {
3015 try
3016 {
3017 m_xNewSubmission = xModel->createSubmission();
3018 m_xSubmission = m_xNewSubmission;
3019 }
3020 catch ( Exception const & )
3021 {
3022 TOOLS_WARN_EXCEPTION( "svx.form", "AddSubmissionDialog::OKHdl()" );
3023 }
3024 }
3025 }
3026
3027 if ( m_xSubmission.is() )
3028 {
3029 OUString sTemp = m_xNameED->get_text();
3030 try
3031 {
3032 m_xSubmission->setPropertyValue( PN_SUBMISSION_ID, makeAny( sTemp ) );
3033 sTemp = m_xActionED->get_text();
3034 m_xSubmission->setPropertyValue( PN_SUBMISSION_ACTION, makeAny( sTemp ) );
3035 sTemp = m_aMethodString.toAPI( m_xMethodLB->get_active_text() );
3036 m_xSubmission->setPropertyValue( PN_SUBMISSION_METHOD, makeAny( sTemp ) );
3037 sTemp = m_xRefED->get_text();
3038 m_xSubmission->setPropertyValue( PN_SUBMISSION_REF, makeAny( sTemp ) );
3039 OUString sEntry = m_xBindLB->get_active_text();
3040 sal_Int32 nColonIdx = sEntry.indexOf(':');
3041 if (nColonIdx != -1)
3042 sEntry = sEntry.copy(0, nColonIdx);
3043 sTemp = sEntry;
3044 m_xSubmission->setPropertyValue( PN_SUBMISSION_BIND, makeAny( sTemp ) );
3045 sTemp = m_aReplaceString.toAPI( m_xReplaceLB->get_active_text() );
3046 m_xSubmission->setPropertyValue( PN_SUBMISSION_REPLACE, makeAny( sTemp ) );
3047 }
3048 catch ( Exception const & )
3049 {
3050 TOOLS_WARN_EXCEPTION( "svx.form", "AddSubmissionDialog::OKHdl()" );
3051 }
3052 }
3053
3054 m_xDialog->response(RET_OK);
3055 }
3056
3057 void AddSubmissionDialog::FillAllBoxes()
3058 {
3059 // method box
3060 m_xMethodLB->append_text(SvxResId(RID_STR_METHOD_POST));
3061 m_xMethodLB->append_text(SvxResId(RID_STR_METHOD_PUT));
3062 m_xMethodLB->append_text(SvxResId(RID_STR_METHOD_GET));
3063 m_xMethodLB->set_active(0);
3064
3065 // binding box
3066 Reference< css::xforms::XModel > xModel( m_xUIHelper, UNO_QUERY );
3067 if ( xModel.is() )
3068 {
3069 try
3070 {
3071 Reference< XEnumerationAccess > xNumAccess = xModel->getBindings();
3072 if ( xNumAccess.is() )
3073 {
3074 Reference < XEnumeration > xNum = xNumAccess->createEnumeration();
3075 if ( xNum.is() && xNum->hasMoreElements() )
3076 {
3077 while ( xNum->hasMoreElements() )
3078 {
3079 Reference< XPropertySet > xPropSet;
3080 Any aAny = xNum->nextElement();
3081 if ( aAny >>= xPropSet )
3082 {
3083 OUString sEntry;
3084 OUString sTemp;
3085 xPropSet->getPropertyValue( PN_BINDING_ID ) >>= sTemp;
3086 sEntry += sTemp + ": ";
3087 xPropSet->getPropertyValue( PN_BINDING_EXPR ) >>= sTemp;
3088 sEntry += sTemp;
3089 m_xBindLB->append_text(sEntry);
3090
3091 if ( !m_xTempBinding.is() )
3092 m_xTempBinding = xPropSet;
3093 }
3094 }
3095 }
3096 }
3097 }
3098 catch ( Exception const & )
3099 {
3100 TOOLS_WARN_EXCEPTION( "svx.form", "AddSubmissionDialog::FillAllBoxes()" );
3101 }
3102 }
3103
3104 // #i36342# we need a temporary binding; create one if no existing binding
3105 // is found
3106 if( !m_xTempBinding.is() )
3107 {
3108 m_xCreatedBinding = m_xUIHelper->getBindingForNode(
3109 Reference<css::xml::dom::XNode>(
3110 xModel->getDefaultInstance()->getDocumentElement(),
3111 UNO_QUERY_THROW ),
3112 true );
3113 m_xTempBinding = m_xCreatedBinding;
3114 }
3115
3116 // replace box
3117 m_xReplaceLB->append_text(SvxResId(RID_STR_REPLACE_NONE));
3118 m_xReplaceLB->append_text(SvxResId(RID_STR_REPLACE_INST));
3119 m_xReplaceLB->append_text(SvxResId(RID_STR_REPLACE_DOC));
3120
3121
3122 // init the controls with the values of the submission
3123 if ( m_pItemNode && m_pItemNode->m_xPropSet.is() )
3124 {
3125 m_xSubmission = m_pItemNode->m_xPropSet;
3126 OUString sTemp;
3127 try
3128 {
3129 m_xSubmission->getPropertyValue( PN_SUBMISSION_ID ) >>= sTemp;
3130 m_xNameED->set_text( sTemp );
3131 m_xSubmission->getPropertyValue( PN_SUBMISSION_ACTION ) >>= sTemp;
3132 m_xActionED->set_text( sTemp );
3133 m_xSubmission->getPropertyValue( PN_SUBMISSION_REF ) >>= sTemp;
3134 m_xRefED->set_text(sTemp);
3135
3136 m_xSubmission->getPropertyValue( PN_SUBMISSION_METHOD ) >>= sTemp;
3137 sTemp = m_aMethodString.toUI( sTemp );
3138 sal_Int32 nPos = m_xMethodLB->find_text( sTemp );
3139 if (nPos == -1)
3140 {
3141 m_xMethodLB->append_text( sTemp );
3142 nPos = m_xMethodLB->get_count() - 1;
3143 }
3144 m_xMethodLB->set_active( nPos );
3145
3146 m_xSubmission->getPropertyValue( PN_SUBMISSION_BIND ) >>= sTemp;
3147 nPos = m_xBindLB->find_text(sTemp);
3148 if (nPos == -1)
3149 {
3150 m_xBindLB->append_text(sTemp);
3151 nPos = m_xBindLB->get_count() - 1;
3152 }
3153 m_xBindLB->set_active(nPos);
3154
3155 m_xSubmission->getPropertyValue( PN_SUBMISSION_REPLACE ) >>= sTemp;
3156 sTemp = m_aReplaceString.toUI( sTemp );
3157 if ( sTemp.isEmpty() )
3158 sTemp = m_xReplaceLB->get_text(0); // first entry == "none"
3159 nPos = m_xReplaceLB->find_text(sTemp);
3160 if (nPos == -1)
3161 {
3162 m_xReplaceLB->append_text(sTemp);
3163 nPos = m_xReplaceLB->get_count() - 1;
3164 }
3165 m_xReplaceLB->set_active(nPos);
3166 }
3167 catch ( Exception const & )
3168 {
3169 TOOLS_WARN_EXCEPTION( "svx.form", "AddSubmissionDialog::FillAllBoxes()" );
3170 }
3171 }
3172
3173 m_xRefBtn->set_sensitive(m_xTempBinding.is());
3174 }
3175
3176 AddModelDialog::AddModelDialog(weld::Window* pParent, bool bIsEdit)
3177 : GenericDialogController(pParent, "svx/ui/addmodeldialog.ui", "AddModelDialog")
3178 , m_xNameED(m_xBuilder->weld_entry("name"))
3179 , m_xModifyCB(m_xBuilder->weld_check_button("modify"))
3180 , m_xAltTitle(m_xBuilder->weld_label("alttitle"))
3181 {
3182 if (bIsEdit)
3183 m_xDialog->set_title(m_xAltTitle->get_label());
3184 }
3185
3186 AddModelDialog::~AddModelDialog()
3187 {
3188 }
3189
3190 AddInstanceDialog::AddInstanceDialog(weld::Window* pParent, bool _bEdit)
3191 : GenericDialogController(pParent, "svx/ui/addinstancedialog.ui", "AddInstanceDialog")
3192 , m_xNameED(m_xBuilder->weld_entry("name"))
3193 , m_xURLFT(m_xBuilder->weld_label("urlft"))
3194 , m_xURLED(new URLBox(m_xBuilder->weld_combo_box("url")))
3195 , m_xFilePickerBtn(m_xBuilder->weld_button("browse"))
3196 , m_xLinkInstanceCB(m_xBuilder->weld_check_button("link"))
3197 , m_xAltTitle(m_xBuilder->weld_label("alttitle"))
3198 {
3199 if (_bEdit)
3200 m_xDialog->set_title(m_xAltTitle->get_label());
3201
3202 m_xURLED->DisableHistory();
3203 m_xFilePickerBtn->connect_clicked(LINK(this, AddInstanceDialog, FilePickerHdl));
3204
3205 // load the filter name from fps resource
3206 m_sAllFilterName = Translate::get(STR_FILTERNAME_ALL, Translate::Create("fps"));
3207 }
3208
3209 AddInstanceDialog::~AddInstanceDialog()
3210 {
3211 }
3212
3213 IMPL_LINK_NOARG(AddInstanceDialog, FilePickerHdl, weld::Button&, void)
3214 {
3215 ::sfx2::FileDialogHelper aDlg(
3216 css::ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE,
3217 FileDialogFlags::NONE, m_xDialog.get());
3218 INetURLObject aFile( SvtPathOptions().GetWorkPath() );
3219
3220 aDlg.AddFilter( m_sAllFilterName, FILEDIALOG_FILTER_ALL );
3221 OUString sFilterName( "XML" );
3222 aDlg.AddFilter( sFilterName, "*.xml" );
3223 aDlg.SetCurrentFilter( sFilterName );
3224 aDlg.SetDisplayDirectory( aFile.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
3225
3226 if (aDlg.Execute() == ERRCODE_NONE)
3227 m_xURLED->set_entry_text(aDlg.GetPath());
3228 }
3229
3230 LinkedInstanceWarningBox::LinkedInstanceWarningBox(weld::Widget* pParent)
3231 : MessageDialogController(pParent, "svx/ui/formlinkwarndialog.ui",
3232 "FormLinkWarnDialog")
3233 {
3234 }
3235
3236 }
3237
3238 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE