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